~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/atm/svc.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp