Root/
1 | /* net/atm/svc.c - ATM SVC sockets */ |
2 | |
3 | /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */ |
4 | |
5 | #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__ |
6 | |
7 | #include <linux/string.h> |
8 | #include <linux/net.h> /* struct socket, struct proto_ops */ |
9 | #include <linux/errno.h> /* error codes */ |
10 | #include <linux/kernel.h> /* printk */ |
11 | #include <linux/skbuff.h> |
12 | #include <linux/wait.h> |
13 | #include <linux/sched.h> /* jiffies and HZ */ |
14 | #include <linux/fcntl.h> /* O_NONBLOCK */ |
15 | #include <linux/init.h> |
16 | #include <linux/atm.h> /* ATM stuff */ |
17 | #include <linux/atmsap.h> |
18 | #include <linux/atmsvc.h> |
19 | #include <linux/atmdev.h> |
20 | #include <linux/bitops.h> |
21 | #include <net/sock.h> /* for sock_no_* */ |
22 | #include <linux/uaccess.h> |
23 | #include <linux/export.h> |
24 | |
25 | #include "resources.h" |
26 | #include "common.h" /* common for PVCs and SVCs */ |
27 | #include "signaling.h" |
28 | #include "addr.h" |
29 | |
30 | static int svc_create(struct net *net, struct socket *sock, int protocol, |
31 | int kern); |
32 | |
33 | /* |
34 | * Note: since all this is still nicely synchronized with the signaling demon, |
35 | * there's no need to protect sleep loops with clis. If signaling is |
36 | * moved into the kernel, that would change. |
37 | */ |
38 | |
39 | |
40 | static int svc_shutdown(struct socket *sock, int how) |
41 | { |
42 | return 0; |
43 | } |
44 | |
45 | static void svc_disconnect(struct atm_vcc *vcc) |
46 | { |
47 | DEFINE_WAIT(wait); |
48 | struct sk_buff *skb; |
49 | struct sock *sk = sk_atm(vcc); |
50 | |
51 | pr_debug("%p\n", vcc); |
52 | if (test_bit(ATM_VF_REGIS, &vcc->flags)) { |
53 | prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE); |
54 | sigd_enq(vcc, as_close, NULL, NULL, NULL); |
55 | while (!test_bit(ATM_VF_RELEASED, &vcc->flags) && sigd) { |
56 | schedule(); |
57 | prepare_to_wait(sk_sleep(sk), &wait, |
58 | TASK_UNINTERRUPTIBLE); |
59 | } |
60 | finish_wait(sk_sleep(sk), &wait); |
61 | } |
62 | /* beware - socket is still in use by atmsigd until the last |
63 | as_indicate has been answered */ |
64 | while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) { |
65 | atm_return(vcc, skb->truesize); |
66 | pr_debug("LISTEN REL\n"); |
67 | sigd_enq2(NULL, as_reject, vcc, NULL, NULL, &vcc->qos, 0); |
68 | dev_kfree_skb(skb); |
69 | } |
70 | clear_bit(ATM_VF_REGIS, &vcc->flags); |
71 | /* ... may retry later */ |
72 | } |
73 | |
74 | static int svc_release(struct socket *sock) |
75 | { |
76 | struct sock *sk = sock->sk; |
77 | struct atm_vcc *vcc; |
78 | |
79 | if (sk) { |
80 | vcc = ATM_SD(sock); |
81 | pr_debug("%p\n", vcc); |
82 | clear_bit(ATM_VF_READY, &vcc->flags); |
83 | /* |
84 | * VCC pointer is used as a reference, |
85 | * so we must not free it (thereby subjecting it to re-use) |
86 | * before all pending connections are closed |
87 | */ |
88 | svc_disconnect(vcc); |
89 | vcc_release(sock); |
90 | } |
91 | return 0; |
92 | } |
93 | |
94 | static int svc_bind(struct socket *sock, struct sockaddr *sockaddr, |
95 | int sockaddr_len) |
96 | { |
97 | DEFINE_WAIT(wait); |
98 | struct sock *sk = sock->sk; |
99 | struct sockaddr_atmsvc *addr; |
100 | struct atm_vcc *vcc; |
101 | int error; |
102 | |
103 | if (sockaddr_len != sizeof(struct sockaddr_atmsvc)) |
104 | return -EINVAL; |
105 | lock_sock(sk); |
106 | if (sock->state == SS_CONNECTED) { |
107 | error = -EISCONN; |
108 | goto out; |
109 | } |
110 | if (sock->state != SS_UNCONNECTED) { |
111 | error = -EINVAL; |
112 | goto out; |
113 | } |
114 | vcc = ATM_SD(sock); |
115 | addr = (struct sockaddr_atmsvc *) sockaddr; |
116 | if (addr->sas_family != AF_ATMSVC) { |
117 | error = -EAFNOSUPPORT; |
118 | goto out; |
119 | } |
120 | clear_bit(ATM_VF_BOUND, &vcc->flags); |
121 | /* failing rebind will kill old binding */ |
122 | /* @@@ check memory (de)allocation on rebind */ |
123 | if (!test_bit(ATM_VF_HASQOS, &vcc->flags)) { |
124 | error = -EBADFD; |
125 | goto out; |
126 | } |
127 | vcc->local = *addr; |
128 | set_bit(ATM_VF_WAITING, &vcc->flags); |
129 | prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE); |
130 | sigd_enq(vcc, as_bind, NULL, NULL, &vcc->local); |
131 | while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) { |
132 | schedule(); |
133 | prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE); |
134 | } |
135 | finish_wait(sk_sleep(sk), &wait); |
136 | clear_bit(ATM_VF_REGIS, &vcc->flags); /* doesn't count */ |
137 | if (!sigd) { |
138 | error = -EUNATCH; |
139 | goto out; |
140 | } |
141 | if (!sk->sk_err) |
142 | set_bit(ATM_VF_BOUND, &vcc->flags); |
143 | error = -sk->sk_err; |
144 | out: |
145 | release_sock(sk); |
146 | return error; |
147 | } |
148 | |
149 | static int svc_connect(struct socket *sock, struct sockaddr *sockaddr, |
150 | int sockaddr_len, int flags) |
151 | { |
152 | DEFINE_WAIT(wait); |
153 | struct sock *sk = sock->sk; |
154 | struct sockaddr_atmsvc *addr; |
155 | struct atm_vcc *vcc = ATM_SD(sock); |
156 | int error; |
157 | |
158 | pr_debug("%p\n", vcc); |
159 | lock_sock(sk); |
160 | if (sockaddr_len != sizeof(struct sockaddr_atmsvc)) { |
161 | error = -EINVAL; |
162 | goto out; |
163 | } |
164 | |
165 | switch (sock->state) { |
166 | default: |
167 | error = -EINVAL; |
168 | goto out; |
169 | case SS_CONNECTED: |
170 | error = -EISCONN; |
171 | goto out; |
172 | case SS_CONNECTING: |
173 | if (test_bit(ATM_VF_WAITING, &vcc->flags)) { |
174 | error = -EALREADY; |
175 | goto out; |
176 | } |
177 | sock->state = SS_UNCONNECTED; |
178 | if (sk->sk_err) { |
179 | error = -sk->sk_err; |
180 | goto out; |
181 | } |
182 | break; |
183 | case SS_UNCONNECTED: |
184 | addr = (struct sockaddr_atmsvc *) sockaddr; |
185 | if (addr->sas_family != AF_ATMSVC) { |
186 | error = -EAFNOSUPPORT; |
187 | goto out; |
188 | } |
189 | if (!test_bit(ATM_VF_HASQOS, &vcc->flags)) { |
190 | error = -EBADFD; |
191 | goto out; |
192 | } |
193 | if (vcc->qos.txtp.traffic_class == ATM_ANYCLASS || |
194 | vcc->qos.rxtp.traffic_class == ATM_ANYCLASS) { |
195 | error = -EINVAL; |
196 | goto out; |
197 | } |
198 | if (!vcc->qos.txtp.traffic_class && |
199 | !vcc->qos.rxtp.traffic_class) { |
200 | error = -EINVAL; |
201 | goto out; |
202 | } |
203 | vcc->remote = *addr; |
204 | set_bit(ATM_VF_WAITING, &vcc->flags); |
205 | prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); |
206 | sigd_enq(vcc, as_connect, NULL, NULL, &vcc->remote); |
207 | if (flags & O_NONBLOCK) { |
208 | finish_wait(sk_sleep(sk), &wait); |
209 | sock->state = SS_CONNECTING; |
210 | error = -EINPROGRESS; |
211 | goto out; |
212 | } |
213 | error = 0; |
214 | while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) { |
215 | schedule(); |
216 | if (!signal_pending(current)) { |
217 | prepare_to_wait(sk_sleep(sk), &wait, |
218 | TASK_INTERRUPTIBLE); |
219 | continue; |
220 | } |
221 | pr_debug("*ABORT*\n"); |
222 | /* |
223 | * This is tricky: |
224 | * Kernel ---close--> Demon |
225 | * Kernel <--close--- Demon |
226 | * or |
227 | * Kernel ---close--> Demon |
228 | * Kernel <--error--- Demon |
229 | * or |
230 | * Kernel ---close--> Demon |
231 | * Kernel <--okay---- Demon |
232 | * Kernel <--close--- Demon |
233 | */ |
234 | sigd_enq(vcc, as_close, NULL, NULL, NULL); |
235 | while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) { |
236 | prepare_to_wait(sk_sleep(sk), &wait, |
237 | TASK_INTERRUPTIBLE); |
238 | schedule(); |
239 | } |
240 | if (!sk->sk_err) |
241 | while (!test_bit(ATM_VF_RELEASED, &vcc->flags) && |
242 | sigd) { |
243 | prepare_to_wait(sk_sleep(sk), &wait, |
244 | TASK_INTERRUPTIBLE); |
245 | schedule(); |
246 | } |
247 | clear_bit(ATM_VF_REGIS, &vcc->flags); |
248 | clear_bit(ATM_VF_RELEASED, &vcc->flags); |
249 | clear_bit(ATM_VF_CLOSE, &vcc->flags); |
250 | /* we're gone now but may connect later */ |
251 | error = -EINTR; |
252 | break; |
253 | } |
254 | finish_wait(sk_sleep(sk), &wait); |
255 | if (error) |
256 | goto out; |
257 | if (!sigd) { |
258 | error = -EUNATCH; |
259 | goto out; |
260 | } |
261 | if (sk->sk_err) { |
262 | error = -sk->sk_err; |
263 | goto out; |
264 | } |
265 | } |
266 | /* |
267 | * Not supported yet |
268 | * |
269 | * #ifndef CONFIG_SINGLE_SIGITF |
270 | */ |
271 | vcc->qos.txtp.max_pcr = SELECT_TOP_PCR(vcc->qos.txtp); |
272 | vcc->qos.txtp.pcr = 0; |
273 | vcc->qos.txtp.min_pcr = 0; |
274 | /* |
275 | * #endif |
276 | */ |
277 | error = vcc_connect(sock, vcc->itf, vcc->vpi, vcc->vci); |
278 | if (!error) |
279 | sock->state = SS_CONNECTED; |
280 | else |
281 | (void)svc_disconnect(vcc); |
282 | out: |
283 | release_sock(sk); |
284 | return error; |
285 | } |
286 | |
287 | static int svc_listen(struct socket *sock, int backlog) |
288 | { |
289 | DEFINE_WAIT(wait); |
290 | struct sock *sk = sock->sk; |
291 | struct atm_vcc *vcc = ATM_SD(sock); |
292 | int error; |
293 | |
294 | pr_debug("%p\n", vcc); |
295 | lock_sock(sk); |
296 | /* let server handle listen on unbound sockets */ |
297 | if (test_bit(ATM_VF_SESSION, &vcc->flags)) { |
298 | error = -EINVAL; |
299 | goto out; |
300 | } |
301 | if (test_bit(ATM_VF_LISTEN, &vcc->flags)) { |
302 | error = -EADDRINUSE; |
303 | goto out; |
304 | } |
305 | set_bit(ATM_VF_WAITING, &vcc->flags); |
306 | prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE); |
307 | sigd_enq(vcc, as_listen, NULL, NULL, &vcc->local); |
308 | while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) { |
309 | schedule(); |
310 | prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE); |
311 | } |
312 | finish_wait(sk_sleep(sk), &wait); |
313 | if (!sigd) { |
314 | error = -EUNATCH; |
315 | goto out; |
316 | } |
317 | set_bit(ATM_VF_LISTEN, &vcc->flags); |
318 | vcc_insert_socket(sk); |
319 | sk->sk_max_ack_backlog = backlog > 0 ? backlog : ATM_BACKLOG_DEFAULT; |
320 | error = -sk->sk_err; |
321 | out: |
322 | release_sock(sk); |
323 | return error; |
324 | } |
325 | |
326 | static int svc_accept(struct socket *sock, struct socket *newsock, int flags) |
327 | { |
328 | struct sock *sk = sock->sk; |
329 | struct sk_buff *skb; |
330 | struct atmsvc_msg *msg; |
331 | struct atm_vcc *old_vcc = ATM_SD(sock); |
332 | struct atm_vcc *new_vcc; |
333 | int error; |
334 | |
335 | lock_sock(sk); |
336 | |
337 | error = svc_create(sock_net(sk), newsock, 0, 0); |
338 | if (error) |
339 | goto out; |
340 | |
341 | new_vcc = ATM_SD(newsock); |
342 | |
343 | pr_debug("%p -> %p\n", old_vcc, new_vcc); |
344 | while (1) { |
345 | DEFINE_WAIT(wait); |
346 | |
347 | prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); |
348 | while (!(skb = skb_dequeue(&sk->sk_receive_queue)) && |
349 | sigd) { |
350 | if (test_bit(ATM_VF_RELEASED, &old_vcc->flags)) |
351 | break; |
352 | if (test_bit(ATM_VF_CLOSE, &old_vcc->flags)) { |
353 | error = -sk->sk_err; |
354 | break; |
355 | } |
356 | if (flags & O_NONBLOCK) { |
357 | error = -EAGAIN; |
358 | break; |
359 | } |
360 | release_sock(sk); |
361 | schedule(); |
362 | lock_sock(sk); |
363 | if (signal_pending(current)) { |
364 | error = -ERESTARTSYS; |
365 | break; |
366 | } |
367 | prepare_to_wait(sk_sleep(sk), &wait, |
368 | TASK_INTERRUPTIBLE); |
369 | } |
370 | finish_wait(sk_sleep(sk), &wait); |
371 | if (error) |
372 | goto out; |
373 | if (!skb) { |
374 | error = -EUNATCH; |
375 | goto out; |
376 | } |
377 | msg = (struct atmsvc_msg *)skb->data; |
378 | new_vcc->qos = msg->qos; |
379 | set_bit(ATM_VF_HASQOS, &new_vcc->flags); |
380 | new_vcc->remote = msg->svc; |
381 | new_vcc->local = msg->local; |
382 | new_vcc->sap = msg->sap; |
383 | error = vcc_connect(newsock, msg->pvc.sap_addr.itf, |
384 | msg->pvc.sap_addr.vpi, |
385 | msg->pvc.sap_addr.vci); |
386 | dev_kfree_skb(skb); |
387 | sk->sk_ack_backlog--; |
388 | if (error) { |
389 | sigd_enq2(NULL, as_reject, old_vcc, NULL, NULL, |
390 | &old_vcc->qos, error); |
391 | error = error == -EAGAIN ? -EBUSY : error; |
392 | goto out; |
393 | } |
394 | /* wait should be short, so we ignore the non-blocking flag */ |
395 | set_bit(ATM_VF_WAITING, &new_vcc->flags); |
396 | prepare_to_wait(sk_sleep(sk_atm(new_vcc)), &wait, |
397 | TASK_UNINTERRUPTIBLE); |
398 | sigd_enq(new_vcc, as_accept, old_vcc, NULL, NULL); |
399 | while (test_bit(ATM_VF_WAITING, &new_vcc->flags) && sigd) { |
400 | release_sock(sk); |
401 | schedule(); |
402 | lock_sock(sk); |
403 | prepare_to_wait(sk_sleep(sk_atm(new_vcc)), &wait, |
404 | TASK_UNINTERRUPTIBLE); |
405 | } |
406 | finish_wait(sk_sleep(sk_atm(new_vcc)), &wait); |
407 | if (!sigd) { |
408 | error = -EUNATCH; |
409 | goto out; |
410 | } |
411 | if (!sk_atm(new_vcc)->sk_err) |
412 | break; |
413 | if (sk_atm(new_vcc)->sk_err != ERESTARTSYS) { |
414 | error = -sk_atm(new_vcc)->sk_err; |
415 | goto out; |
416 | } |
417 | } |
418 | newsock->state = SS_CONNECTED; |
419 | out: |
420 | release_sock(sk); |
421 | return error; |
422 | } |
423 | |
424 | static int svc_getname(struct socket *sock, struct sockaddr *sockaddr, |
425 | int *sockaddr_len, int peer) |
426 | { |
427 | struct sockaddr_atmsvc *addr; |
428 | |
429 | *sockaddr_len = sizeof(struct sockaddr_atmsvc); |
430 | addr = (struct sockaddr_atmsvc *) sockaddr; |
431 | memcpy(addr, peer ? &ATM_SD(sock)->remote : &ATM_SD(sock)->local, |
432 | sizeof(struct sockaddr_atmsvc)); |
433 | return 0; |
434 | } |
435 | |
436 | int svc_change_qos(struct atm_vcc *vcc, struct atm_qos *qos) |
437 | { |
438 | struct sock *sk = sk_atm(vcc); |
439 | DEFINE_WAIT(wait); |
440 | |
441 | set_bit(ATM_VF_WAITING, &vcc->flags); |
442 | prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE); |
443 | sigd_enq2(vcc, as_modify, NULL, NULL, &vcc->local, qos, 0); |
444 | while (test_bit(ATM_VF_WAITING, &vcc->flags) && |
445 | !test_bit(ATM_VF_RELEASED, &vcc->flags) && sigd) { |
446 | schedule(); |
447 | prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE); |
448 | } |
449 | finish_wait(sk_sleep(sk), &wait); |
450 | if (!sigd) |
451 | return -EUNATCH; |
452 | return -sk->sk_err; |
453 | } |
454 | |
455 | static int svc_setsockopt(struct socket *sock, int level, int optname, |
456 | char __user *optval, unsigned int optlen) |
457 | { |
458 | struct sock *sk = sock->sk; |
459 | struct atm_vcc *vcc = ATM_SD(sock); |
460 | int value, error = 0; |
461 | |
462 | lock_sock(sk); |
463 | switch (optname) { |
464 | case SO_ATMSAP: |
465 | if (level != SOL_ATM || optlen != sizeof(struct atm_sap)) { |
466 | error = -EINVAL; |
467 | goto out; |
468 | } |
469 | if (copy_from_user(&vcc->sap, optval, optlen)) { |
470 | error = -EFAULT; |
471 | goto out; |
472 | } |
473 | set_bit(ATM_VF_HASSAP, &vcc->flags); |
474 | break; |
475 | case SO_MULTIPOINT: |
476 | if (level != SOL_ATM || optlen != sizeof(int)) { |
477 | error = -EINVAL; |
478 | goto out; |
479 | } |
480 | if (get_user(value, (int __user *)optval)) { |
481 | error = -EFAULT; |
482 | goto out; |
483 | } |
484 | if (value == 1) |
485 | set_bit(ATM_VF_SESSION, &vcc->flags); |
486 | else if (value == 0) |
487 | clear_bit(ATM_VF_SESSION, &vcc->flags); |
488 | else |
489 | error = -EINVAL; |
490 | break; |
491 | default: |
492 | error = vcc_setsockopt(sock, level, optname, optval, optlen); |
493 | } |
494 | |
495 | out: |
496 | release_sock(sk); |
497 | return error; |
498 | } |
499 | |
500 | static int svc_getsockopt(struct socket *sock, int level, int optname, |
501 | char __user *optval, int __user *optlen) |
502 | { |
503 | struct sock *sk = sock->sk; |
504 | int error = 0, len; |
505 | |
506 | lock_sock(sk); |
507 | if (!__SO_LEVEL_MATCH(optname, level) || optname != SO_ATMSAP) { |
508 | error = vcc_getsockopt(sock, level, optname, optval, optlen); |
509 | goto out; |
510 | } |
511 | if (get_user(len, optlen)) { |
512 | error = -EFAULT; |
513 | goto out; |
514 | } |
515 | if (len != sizeof(struct atm_sap)) { |
516 | error = -EINVAL; |
517 | goto out; |
518 | } |
519 | if (copy_to_user(optval, &ATM_SD(sock)->sap, sizeof(struct atm_sap))) { |
520 | error = -EFAULT; |
521 | goto out; |
522 | } |
523 | out: |
524 | release_sock(sk); |
525 | return error; |
526 | } |
527 | |
528 | static int svc_addparty(struct socket *sock, struct sockaddr *sockaddr, |
529 | int sockaddr_len, int flags) |
530 | { |
531 | DEFINE_WAIT(wait); |
532 | struct sock *sk = sock->sk; |
533 | struct atm_vcc *vcc = ATM_SD(sock); |
534 | int error; |
535 | |
536 | lock_sock(sk); |
537 | set_bit(ATM_VF_WAITING, &vcc->flags); |
538 | prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); |
539 | sigd_enq(vcc, as_addparty, NULL, NULL, |
540 | (struct sockaddr_atmsvc *) sockaddr); |
541 | if (flags & O_NONBLOCK) { |
542 | finish_wait(sk_sleep(sk), &wait); |
543 | error = -EINPROGRESS; |
544 | goto out; |
545 | } |
546 | pr_debug("added wait queue\n"); |
547 | while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) { |
548 | schedule(); |
549 | prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); |
550 | } |
551 | finish_wait(sk_sleep(sk), &wait); |
552 | error = xchg(&sk->sk_err_soft, 0); |
553 | out: |
554 | release_sock(sk); |
555 | return error; |
556 | } |
557 | |
558 | static int svc_dropparty(struct socket *sock, int ep_ref) |
559 | { |
560 | DEFINE_WAIT(wait); |
561 | struct sock *sk = sock->sk; |
562 | struct atm_vcc *vcc = ATM_SD(sock); |
563 | int error; |
564 | |
565 | lock_sock(sk); |
566 | set_bit(ATM_VF_WAITING, &vcc->flags); |
567 | prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); |
568 | sigd_enq2(vcc, as_dropparty, NULL, NULL, NULL, NULL, ep_ref); |
569 | while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) { |
570 | schedule(); |
571 | prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); |
572 | } |
573 | finish_wait(sk_sleep(sk), &wait); |
574 | if (!sigd) { |
575 | error = -EUNATCH; |
576 | goto out; |
577 | } |
578 | error = xchg(&sk->sk_err_soft, 0); |
579 | out: |
580 | release_sock(sk); |
581 | return error; |
582 | } |
583 | |
584 | static int svc_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) |
585 | { |
586 | int error, ep_ref; |
587 | struct sockaddr_atmsvc sa; |
588 | struct atm_vcc *vcc = ATM_SD(sock); |
589 | |
590 | switch (cmd) { |
591 | case ATM_ADDPARTY: |
592 | if (!test_bit(ATM_VF_SESSION, &vcc->flags)) |
593 | return -EINVAL; |
594 | if (copy_from_user(&sa, (void __user *) arg, sizeof(sa))) |
595 | return -EFAULT; |
596 | error = svc_addparty(sock, (struct sockaddr *)&sa, sizeof(sa), |
597 | 0); |
598 | break; |
599 | case ATM_DROPPARTY: |
600 | if (!test_bit(ATM_VF_SESSION, &vcc->flags)) |
601 | return -EINVAL; |
602 | if (copy_from_user(&ep_ref, (void __user *) arg, sizeof(int))) |
603 | return -EFAULT; |
604 | error = svc_dropparty(sock, ep_ref); |
605 | break; |
606 | default: |
607 | error = vcc_ioctl(sock, cmd, arg); |
608 | } |
609 | |
610 | return error; |
611 | } |
612 | |
613 | #ifdef CONFIG_COMPAT |
614 | static int svc_compat_ioctl(struct socket *sock, unsigned int cmd, |
615 | unsigned long arg) |
616 | { |
617 | /* The definition of ATM_ADDPARTY uses the size of struct atm_iobuf. |
618 | But actually it takes a struct sockaddr_atmsvc, which doesn't need |
619 | compat handling. So all we have to do is fix up cmd... */ |
620 | if (cmd == COMPAT_ATM_ADDPARTY) |
621 | cmd = ATM_ADDPARTY; |
622 | |
623 | if (cmd == ATM_ADDPARTY || cmd == ATM_DROPPARTY) |
624 | return svc_ioctl(sock, cmd, arg); |
625 | else |
626 | return vcc_compat_ioctl(sock, cmd, arg); |
627 | } |
628 | #endif /* CONFIG_COMPAT */ |
629 | |
630 | static const struct proto_ops svc_proto_ops = { |
631 | .family = PF_ATMSVC, |
632 | .owner = THIS_MODULE, |
633 | |
634 | .release = svc_release, |
635 | .bind = svc_bind, |
636 | .connect = svc_connect, |
637 | .socketpair = sock_no_socketpair, |
638 | .accept = svc_accept, |
639 | .getname = svc_getname, |
640 | .poll = vcc_poll, |
641 | .ioctl = svc_ioctl, |
642 | #ifdef CONFIG_COMPAT |
643 | .compat_ioctl = svc_compat_ioctl, |
644 | #endif |
645 | .listen = svc_listen, |
646 | .shutdown = svc_shutdown, |
647 | .setsockopt = svc_setsockopt, |
648 | .getsockopt = svc_getsockopt, |
649 | .sendmsg = vcc_sendmsg, |
650 | .recvmsg = vcc_recvmsg, |
651 | .mmap = sock_no_mmap, |
652 | .sendpage = sock_no_sendpage, |
653 | }; |
654 | |
655 | |
656 | static int svc_create(struct net *net, struct socket *sock, int protocol, |
657 | int kern) |
658 | { |
659 | int error; |
660 | |
661 | if (!net_eq(net, &init_net)) |
662 | return -EAFNOSUPPORT; |
663 | |
664 | sock->ops = &svc_proto_ops; |
665 | error = vcc_create(net, sock, protocol, AF_ATMSVC); |
666 | if (error) |
667 | return error; |
668 | ATM_SD(sock)->local.sas_family = AF_ATMSVC; |
669 | ATM_SD(sock)->remote.sas_family = AF_ATMSVC; |
670 | return 0; |
671 | } |
672 | |
673 | static const struct net_proto_family svc_family_ops = { |
674 | .family = PF_ATMSVC, |
675 | .create = svc_create, |
676 | .owner = THIS_MODULE, |
677 | }; |
678 | |
679 | |
680 | /* |
681 | * Initialize the ATM SVC protocol family |
682 | */ |
683 | |
684 | int __init atmsvc_init(void) |
685 | { |
686 | return sock_register(&svc_family_ops); |
687 | } |
688 | |
689 | void atmsvc_exit(void) |
690 | { |
691 | sock_unregister(PF_ATMSVC); |
692 | } |
693 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9