Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* net/atm/svc.c - ATM SVC sockets */
0003 
0004 /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
0005 
0006 #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
0007 
0008 #include <linux/string.h>
0009 #include <linux/net.h>      /* struct socket, struct proto_ops */
0010 #include <linux/errno.h>    /* error codes */
0011 #include <linux/kernel.h>   /* printk */
0012 #include <linux/skbuff.h>
0013 #include <linux/wait.h>
0014 #include <linux/sched/signal.h>
0015 #include <linux/fcntl.h>    /* O_NONBLOCK */
0016 #include <linux/init.h>
0017 #include <linux/atm.h>      /* ATM stuff */
0018 #include <linux/atmsap.h>
0019 #include <linux/atmsvc.h>
0020 #include <linux/atmdev.h>
0021 #include <linux/bitops.h>
0022 #include <net/sock.h>       /* for sock_no_* */
0023 #include <linux/uaccess.h>
0024 #include <linux/export.h>
0025 
0026 #include "resources.h"
0027 #include "common.h"     /* common for PVCs and SVCs */
0028 #include "signaling.h"
0029 #include "addr.h"
0030 
0031 static int svc_create(struct net *net, struct socket *sock, int protocol,
0032               int kern);
0033 
0034 /*
0035  * Note: since all this is still nicely synchronized with the signaling demon,
0036  *       there's no need to protect sleep loops with clis. If signaling is
0037  *       moved into the kernel, that would change.
0038  */
0039 
0040 
0041 static int svc_shutdown(struct socket *sock, int how)
0042 {
0043     return 0;
0044 }
0045 
0046 static void svc_disconnect(struct atm_vcc *vcc)
0047 {
0048     DEFINE_WAIT(wait);
0049     struct sk_buff *skb;
0050     struct sock *sk = sk_atm(vcc);
0051 
0052     pr_debug("%p\n", vcc);
0053     if (test_bit(ATM_VF_REGIS, &vcc->flags)) {
0054         sigd_enq(vcc, as_close, NULL, NULL, NULL);
0055         for (;;) {
0056             prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
0057             if (test_bit(ATM_VF_RELEASED, &vcc->flags) || !sigd)
0058                 break;
0059             schedule();
0060         }
0061         finish_wait(sk_sleep(sk), &wait);
0062     }
0063     /* beware - socket is still in use by atmsigd until the last
0064        as_indicate has been answered */
0065     while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
0066         atm_return(vcc, skb->truesize);
0067         pr_debug("LISTEN REL\n");
0068         sigd_enq2(NULL, as_reject, vcc, NULL, NULL, &vcc->qos, 0);
0069         dev_kfree_skb(skb);
0070     }
0071     clear_bit(ATM_VF_REGIS, &vcc->flags);
0072     /* ... may retry later */
0073 }
0074 
0075 static int svc_release(struct socket *sock)
0076 {
0077     struct sock *sk = sock->sk;
0078     struct atm_vcc *vcc;
0079 
0080     if (sk) {
0081         vcc = ATM_SD(sock);
0082         pr_debug("%p\n", vcc);
0083         clear_bit(ATM_VF_READY, &vcc->flags);
0084         /*
0085          * VCC pointer is used as a reference,
0086          * so we must not free it (thereby subjecting it to re-use)
0087          * before all pending connections are closed
0088          */
0089         svc_disconnect(vcc);
0090         vcc_release(sock);
0091     }
0092     return 0;
0093 }
0094 
0095 static int svc_bind(struct socket *sock, struct sockaddr *sockaddr,
0096             int sockaddr_len)
0097 {
0098     DEFINE_WAIT(wait);
0099     struct sock *sk = sock->sk;
0100     struct sockaddr_atmsvc *addr;
0101     struct atm_vcc *vcc;
0102     int error;
0103 
0104     if (sockaddr_len != sizeof(struct sockaddr_atmsvc))
0105         return -EINVAL;
0106     lock_sock(sk);
0107     if (sock->state == SS_CONNECTED) {
0108         error = -EISCONN;
0109         goto out;
0110     }
0111     if (sock->state != SS_UNCONNECTED) {
0112         error = -EINVAL;
0113         goto out;
0114     }
0115     vcc = ATM_SD(sock);
0116     addr = (struct sockaddr_atmsvc *) sockaddr;
0117     if (addr->sas_family != AF_ATMSVC) {
0118         error = -EAFNOSUPPORT;
0119         goto out;
0120     }
0121     clear_bit(ATM_VF_BOUND, &vcc->flags);
0122         /* failing rebind will kill old binding */
0123     /* @@@ check memory (de)allocation on rebind */
0124     if (!test_bit(ATM_VF_HASQOS, &vcc->flags)) {
0125         error = -EBADFD;
0126         goto out;
0127     }
0128     vcc->local = *addr;
0129     set_bit(ATM_VF_WAITING, &vcc->flags);
0130     sigd_enq(vcc, as_bind, NULL, NULL, &vcc->local);
0131     for (;;) {
0132         prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
0133         if (!test_bit(ATM_VF_WAITING, &vcc->flags) || !sigd)
0134             break;
0135         schedule();
0136     }
0137     finish_wait(sk_sleep(sk), &wait);
0138     clear_bit(ATM_VF_REGIS, &vcc->flags); /* doesn't count */
0139     if (!sigd) {
0140         error = -EUNATCH;
0141         goto out;
0142     }
0143     if (!sk->sk_err)
0144         set_bit(ATM_VF_BOUND, &vcc->flags);
0145     error = -sk->sk_err;
0146 out:
0147     release_sock(sk);
0148     return error;
0149 }
0150 
0151 static int svc_connect(struct socket *sock, struct sockaddr *sockaddr,
0152                int sockaddr_len, int flags)
0153 {
0154     DEFINE_WAIT(wait);
0155     struct sock *sk = sock->sk;
0156     struct sockaddr_atmsvc *addr;
0157     struct atm_vcc *vcc = ATM_SD(sock);
0158     int error;
0159 
0160     pr_debug("%p\n", vcc);
0161     lock_sock(sk);
0162     if (sockaddr_len != sizeof(struct sockaddr_atmsvc)) {
0163         error = -EINVAL;
0164         goto out;
0165     }
0166 
0167     switch (sock->state) {
0168     default:
0169         error = -EINVAL;
0170         goto out;
0171     case SS_CONNECTED:
0172         error = -EISCONN;
0173         goto out;
0174     case SS_CONNECTING:
0175         if (test_bit(ATM_VF_WAITING, &vcc->flags)) {
0176             error = -EALREADY;
0177             goto out;
0178         }
0179         sock->state = SS_UNCONNECTED;
0180         if (sk->sk_err) {
0181             error = -sk->sk_err;
0182             goto out;
0183         }
0184         break;
0185     case SS_UNCONNECTED:
0186         addr = (struct sockaddr_atmsvc *) sockaddr;
0187         if (addr->sas_family != AF_ATMSVC) {
0188             error = -EAFNOSUPPORT;
0189             goto out;
0190         }
0191         if (!test_bit(ATM_VF_HASQOS, &vcc->flags)) {
0192             error = -EBADFD;
0193             goto out;
0194         }
0195         if (vcc->qos.txtp.traffic_class == ATM_ANYCLASS ||
0196             vcc->qos.rxtp.traffic_class == ATM_ANYCLASS) {
0197             error = -EINVAL;
0198             goto out;
0199         }
0200         if (!vcc->qos.txtp.traffic_class &&
0201             !vcc->qos.rxtp.traffic_class) {
0202             error = -EINVAL;
0203             goto out;
0204         }
0205         vcc->remote = *addr;
0206         set_bit(ATM_VF_WAITING, &vcc->flags);
0207         sigd_enq(vcc, as_connect, NULL, NULL, &vcc->remote);
0208         if (flags & O_NONBLOCK) {
0209             sock->state = SS_CONNECTING;
0210             error = -EINPROGRESS;
0211             goto out;
0212         }
0213         error = 0;
0214         prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
0215         while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
0216             schedule();
0217             if (!signal_pending(current)) {
0218                 prepare_to_wait(sk_sleep(sk), &wait,
0219                         TASK_INTERRUPTIBLE);
0220                 continue;
0221             }
0222             pr_debug("*ABORT*\n");
0223             /*
0224              * This is tricky:
0225              *   Kernel ---close--> Demon
0226              *   Kernel <--close--- Demon
0227              * or
0228              *   Kernel ---close--> Demon
0229              *   Kernel <--error--- Demon
0230              * or
0231              *   Kernel ---close--> Demon
0232              *   Kernel <--okay---- Demon
0233              *   Kernel <--close--- Demon
0234              */
0235             sigd_enq(vcc, as_close, NULL, NULL, NULL);
0236             while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
0237                 prepare_to_wait(sk_sleep(sk), &wait,
0238                         TASK_INTERRUPTIBLE);
0239                 schedule();
0240             }
0241             if (!sk->sk_err)
0242                 while (!test_bit(ATM_VF_RELEASED, &vcc->flags) &&
0243                        sigd) {
0244                     prepare_to_wait(sk_sleep(sk), &wait,
0245                             TASK_INTERRUPTIBLE);
0246                     schedule();
0247                 }
0248             clear_bit(ATM_VF_REGIS, &vcc->flags);
0249             clear_bit(ATM_VF_RELEASED, &vcc->flags);
0250             clear_bit(ATM_VF_CLOSE, &vcc->flags);
0251                 /* we're gone now but may connect later */
0252             error = -EINTR;
0253             break;
0254         }
0255         finish_wait(sk_sleep(sk), &wait);
0256         if (error)
0257             goto out;
0258         if (!sigd) {
0259             error = -EUNATCH;
0260             goto out;
0261         }
0262         if (sk->sk_err) {
0263             error = -sk->sk_err;
0264             goto out;
0265         }
0266     }
0267 
0268     vcc->qos.txtp.max_pcr = SELECT_TOP_PCR(vcc->qos.txtp);
0269     vcc->qos.txtp.pcr = 0;
0270     vcc->qos.txtp.min_pcr = 0;
0271 
0272     error = vcc_connect(sock, vcc->itf, vcc->vpi, vcc->vci);
0273     if (!error)
0274         sock->state = SS_CONNECTED;
0275     else
0276         (void)svc_disconnect(vcc);
0277 out:
0278     release_sock(sk);
0279     return error;
0280 }
0281 
0282 static int svc_listen(struct socket *sock, int backlog)
0283 {
0284     DEFINE_WAIT(wait);
0285     struct sock *sk = sock->sk;
0286     struct atm_vcc *vcc = ATM_SD(sock);
0287     int error;
0288 
0289     pr_debug("%p\n", vcc);
0290     lock_sock(sk);
0291     /* let server handle listen on unbound sockets */
0292     if (test_bit(ATM_VF_SESSION, &vcc->flags)) {
0293         error = -EINVAL;
0294         goto out;
0295     }
0296     if (test_bit(ATM_VF_LISTEN, &vcc->flags)) {
0297         error = -EADDRINUSE;
0298         goto out;
0299     }
0300     set_bit(ATM_VF_WAITING, &vcc->flags);
0301     sigd_enq(vcc, as_listen, NULL, NULL, &vcc->local);
0302     for (;;) {
0303         prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
0304         if (!test_bit(ATM_VF_WAITING, &vcc->flags) || !sigd)
0305             break;
0306         schedule();
0307     }
0308     finish_wait(sk_sleep(sk), &wait);
0309     if (!sigd) {
0310         error = -EUNATCH;
0311         goto out;
0312     }
0313     set_bit(ATM_VF_LISTEN, &vcc->flags);
0314     vcc_insert_socket(sk);
0315     sk->sk_max_ack_backlog = backlog > 0 ? backlog : ATM_BACKLOG_DEFAULT;
0316     error = -sk->sk_err;
0317 out:
0318     release_sock(sk);
0319     return error;
0320 }
0321 
0322 static int svc_accept(struct socket *sock, struct socket *newsock, int flags,
0323               bool kern)
0324 {
0325     struct sock *sk = sock->sk;
0326     struct sk_buff *skb;
0327     struct atmsvc_msg *msg;
0328     struct atm_vcc *old_vcc = ATM_SD(sock);
0329     struct atm_vcc *new_vcc;
0330     int error;
0331 
0332     lock_sock(sk);
0333 
0334     error = svc_create(sock_net(sk), newsock, 0, kern);
0335     if (error)
0336         goto out;
0337 
0338     new_vcc = ATM_SD(newsock);
0339 
0340     pr_debug("%p -> %p\n", old_vcc, new_vcc);
0341     while (1) {
0342         DEFINE_WAIT(wait);
0343 
0344         prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
0345         while (!(skb = skb_dequeue(&sk->sk_receive_queue)) &&
0346                sigd) {
0347             if (test_bit(ATM_VF_RELEASED, &old_vcc->flags))
0348                 break;
0349             if (test_bit(ATM_VF_CLOSE, &old_vcc->flags)) {
0350                 error = -sk->sk_err;
0351                 break;
0352             }
0353             if (flags & O_NONBLOCK) {
0354                 error = -EAGAIN;
0355                 break;
0356             }
0357             release_sock(sk);
0358             schedule();
0359             lock_sock(sk);
0360             if (signal_pending(current)) {
0361                 error = -ERESTARTSYS;
0362                 break;
0363             }
0364             prepare_to_wait(sk_sleep(sk), &wait,
0365                     TASK_INTERRUPTIBLE);
0366         }
0367         finish_wait(sk_sleep(sk), &wait);
0368         if (error)
0369             goto out;
0370         if (!skb) {
0371             error = -EUNATCH;
0372             goto out;
0373         }
0374         msg = (struct atmsvc_msg *)skb->data;
0375         new_vcc->qos = msg->qos;
0376         set_bit(ATM_VF_HASQOS, &new_vcc->flags);
0377         new_vcc->remote = msg->svc;
0378         new_vcc->local = msg->local;
0379         new_vcc->sap = msg->sap;
0380         error = vcc_connect(newsock, msg->pvc.sap_addr.itf,
0381                     msg->pvc.sap_addr.vpi,
0382                     msg->pvc.sap_addr.vci);
0383         dev_kfree_skb(skb);
0384         sk_acceptq_removed(sk);
0385         if (error) {
0386             sigd_enq2(NULL, as_reject, old_vcc, NULL, NULL,
0387                   &old_vcc->qos, error);
0388             error = error == -EAGAIN ? -EBUSY : error;
0389             goto out;
0390         }
0391         /* wait should be short, so we ignore the non-blocking flag */
0392         set_bit(ATM_VF_WAITING, &new_vcc->flags);
0393         sigd_enq(new_vcc, as_accept, old_vcc, NULL, NULL);
0394         for (;;) {
0395             prepare_to_wait(sk_sleep(sk_atm(new_vcc)), &wait,
0396                     TASK_UNINTERRUPTIBLE);
0397             if (!test_bit(ATM_VF_WAITING, &new_vcc->flags) || !sigd)
0398                 break;
0399             release_sock(sk);
0400             schedule();
0401             lock_sock(sk);
0402         }
0403         finish_wait(sk_sleep(sk_atm(new_vcc)), &wait);
0404         if (!sigd) {
0405             error = -EUNATCH;
0406             goto out;
0407         }
0408         if (!sk_atm(new_vcc)->sk_err)
0409             break;
0410         if (sk_atm(new_vcc)->sk_err != ERESTARTSYS) {
0411             error = -sk_atm(new_vcc)->sk_err;
0412             goto out;
0413         }
0414     }
0415     newsock->state = SS_CONNECTED;
0416 out:
0417     release_sock(sk);
0418     return error;
0419 }
0420 
0421 static int svc_getname(struct socket *sock, struct sockaddr *sockaddr,
0422                int peer)
0423 {
0424     struct sockaddr_atmsvc *addr;
0425 
0426     addr = (struct sockaddr_atmsvc *) sockaddr;
0427     memcpy(addr, peer ? &ATM_SD(sock)->remote : &ATM_SD(sock)->local,
0428            sizeof(struct sockaddr_atmsvc));
0429     return sizeof(struct sockaddr_atmsvc);
0430 }
0431 
0432 int svc_change_qos(struct atm_vcc *vcc, struct atm_qos *qos)
0433 {
0434     struct sock *sk = sk_atm(vcc);
0435     DEFINE_WAIT(wait);
0436 
0437     set_bit(ATM_VF_WAITING, &vcc->flags);
0438     sigd_enq2(vcc, as_modify, NULL, NULL, &vcc->local, qos, 0);
0439     for (;;) {
0440         prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
0441         if (!test_bit(ATM_VF_WAITING, &vcc->flags) ||
0442             test_bit(ATM_VF_RELEASED, &vcc->flags) || !sigd) {
0443             break;
0444         }
0445         schedule();
0446     }
0447     finish_wait(sk_sleep(sk), &wait);
0448     if (!sigd)
0449         return -EUNATCH;
0450     return -sk->sk_err;
0451 }
0452 
0453 static int svc_setsockopt(struct socket *sock, int level, int optname,
0454               sockptr_t optval, unsigned int optlen)
0455 {
0456     struct sock *sk = sock->sk;
0457     struct atm_vcc *vcc = ATM_SD(sock);
0458     int value, error = 0;
0459 
0460     lock_sock(sk);
0461     switch (optname) {
0462     case SO_ATMSAP:
0463         if (level != SOL_ATM || optlen != sizeof(struct atm_sap)) {
0464             error = -EINVAL;
0465             goto out;
0466         }
0467         if (copy_from_sockptr(&vcc->sap, optval, optlen)) {
0468             error = -EFAULT;
0469             goto out;
0470         }
0471         set_bit(ATM_VF_HASSAP, &vcc->flags);
0472         break;
0473     case SO_MULTIPOINT:
0474         if (level != SOL_ATM || optlen != sizeof(int)) {
0475             error = -EINVAL;
0476             goto out;
0477         }
0478         if (copy_from_sockptr(&value, optval, sizeof(int))) {
0479             error = -EFAULT;
0480             goto out;
0481         }
0482         if (value == 1)
0483             set_bit(ATM_VF_SESSION, &vcc->flags);
0484         else if (value == 0)
0485             clear_bit(ATM_VF_SESSION, &vcc->flags);
0486         else
0487             error = -EINVAL;
0488         break;
0489     default:
0490         error = vcc_setsockopt(sock, level, optname, optval, optlen);
0491     }
0492 
0493 out:
0494     release_sock(sk);
0495     return error;
0496 }
0497 
0498 static int svc_getsockopt(struct socket *sock, int level, int optname,
0499               char __user *optval, int __user *optlen)
0500 {
0501     struct sock *sk = sock->sk;
0502     int error = 0, len;
0503 
0504     lock_sock(sk);
0505     if (!__SO_LEVEL_MATCH(optname, level) || optname != SO_ATMSAP) {
0506         error = vcc_getsockopt(sock, level, optname, optval, optlen);
0507         goto out;
0508     }
0509     if (get_user(len, optlen)) {
0510         error = -EFAULT;
0511         goto out;
0512     }
0513     if (len != sizeof(struct atm_sap)) {
0514         error = -EINVAL;
0515         goto out;
0516     }
0517     if (copy_to_user(optval, &ATM_SD(sock)->sap, sizeof(struct atm_sap))) {
0518         error = -EFAULT;
0519         goto out;
0520     }
0521 out:
0522     release_sock(sk);
0523     return error;
0524 }
0525 
0526 static int svc_addparty(struct socket *sock, struct sockaddr *sockaddr,
0527             int sockaddr_len, int flags)
0528 {
0529     DEFINE_WAIT(wait);
0530     struct sock *sk = sock->sk;
0531     struct atm_vcc *vcc = ATM_SD(sock);
0532     int error;
0533 
0534     lock_sock(sk);
0535     set_bit(ATM_VF_WAITING, &vcc->flags);
0536     sigd_enq(vcc, as_addparty, NULL, NULL,
0537          (struct sockaddr_atmsvc *) sockaddr);
0538     if (flags & O_NONBLOCK) {
0539         error = -EINPROGRESS;
0540         goto out;
0541     }
0542     pr_debug("added wait queue\n");
0543     for (;;) {
0544         prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
0545         if (!test_bit(ATM_VF_WAITING, &vcc->flags) || !sigd)
0546             break;
0547         schedule();
0548     }
0549     finish_wait(sk_sleep(sk), &wait);
0550     error = -xchg(&sk->sk_err_soft, 0);
0551 out:
0552     release_sock(sk);
0553     return error;
0554 }
0555 
0556 static int svc_dropparty(struct socket *sock, int ep_ref)
0557 {
0558     DEFINE_WAIT(wait);
0559     struct sock *sk = sock->sk;
0560     struct atm_vcc *vcc = ATM_SD(sock);
0561     int error;
0562 
0563     lock_sock(sk);
0564     set_bit(ATM_VF_WAITING, &vcc->flags);
0565     sigd_enq2(vcc, as_dropparty, NULL, NULL, NULL, NULL, ep_ref);
0566     for (;;) {
0567         prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
0568         if (!test_bit(ATM_VF_WAITING, &vcc->flags) || !sigd)
0569             break;
0570         schedule();
0571     }
0572     finish_wait(sk_sleep(sk), &wait);
0573     if (!sigd) {
0574         error = -EUNATCH;
0575         goto out;
0576     }
0577     error = -xchg(&sk->sk_err_soft, 0);
0578 out:
0579     release_sock(sk);
0580     return error;
0581 }
0582 
0583 static int svc_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
0584 {
0585     int error, ep_ref;
0586     struct sockaddr_atmsvc sa;
0587     struct atm_vcc *vcc = ATM_SD(sock);
0588 
0589     switch (cmd) {
0590     case ATM_ADDPARTY:
0591         if (!test_bit(ATM_VF_SESSION, &vcc->flags))
0592             return -EINVAL;
0593         if (copy_from_user(&sa, (void __user *) arg, sizeof(sa)))
0594             return -EFAULT;
0595         error = svc_addparty(sock, (struct sockaddr *)&sa, sizeof(sa),
0596                      0);
0597         break;
0598     case ATM_DROPPARTY:
0599         if (!test_bit(ATM_VF_SESSION, &vcc->flags))
0600             return -EINVAL;
0601         if (copy_from_user(&ep_ref, (void __user *) arg, sizeof(int)))
0602             return -EFAULT;
0603         error = svc_dropparty(sock, ep_ref);
0604         break;
0605     default:
0606         error = vcc_ioctl(sock, cmd, arg);
0607     }
0608 
0609     return error;
0610 }
0611 
0612 #ifdef CONFIG_COMPAT
0613 static int svc_compat_ioctl(struct socket *sock, unsigned int cmd,
0614                 unsigned long arg)
0615 {
0616     /* The definition of ATM_ADDPARTY uses the size of struct atm_iobuf.
0617        But actually it takes a struct sockaddr_atmsvc, which doesn't need
0618        compat handling. So all we have to do is fix up cmd... */
0619     if (cmd == COMPAT_ATM_ADDPARTY)
0620         cmd = ATM_ADDPARTY;
0621 
0622     if (cmd == ATM_ADDPARTY || cmd == ATM_DROPPARTY)
0623         return svc_ioctl(sock, cmd, arg);
0624     else
0625         return vcc_compat_ioctl(sock, cmd, arg);
0626 }
0627 #endif /* CONFIG_COMPAT */
0628 
0629 static const struct proto_ops svc_proto_ops = {
0630     .family =   PF_ATMSVC,
0631     .owner =    THIS_MODULE,
0632 
0633     .release =  svc_release,
0634     .bind =     svc_bind,
0635     .connect =  svc_connect,
0636     .socketpair =   sock_no_socketpair,
0637     .accept =   svc_accept,
0638     .getname =  svc_getname,
0639     .poll =     vcc_poll,
0640     .ioctl =    svc_ioctl,
0641 #ifdef CONFIG_COMPAT
0642     .compat_ioctl = svc_compat_ioctl,
0643 #endif
0644     .gettstamp =    sock_gettstamp,
0645     .listen =   svc_listen,
0646     .shutdown = svc_shutdown,
0647     .setsockopt =   svc_setsockopt,
0648     .getsockopt =   svc_getsockopt,
0649     .sendmsg =  vcc_sendmsg,
0650     .recvmsg =  vcc_recvmsg,
0651     .mmap =     sock_no_mmap,
0652     .sendpage = sock_no_sendpage,
0653 };
0654 
0655 
0656 static int svc_create(struct net *net, struct socket *sock, int protocol,
0657               int kern)
0658 {
0659     int error;
0660 
0661     if (!net_eq(net, &init_net))
0662         return -EAFNOSUPPORT;
0663 
0664     sock->ops = &svc_proto_ops;
0665     error = vcc_create(net, sock, protocol, AF_ATMSVC, kern);
0666     if (error)
0667         return error;
0668     ATM_SD(sock)->local.sas_family = AF_ATMSVC;
0669     ATM_SD(sock)->remote.sas_family = AF_ATMSVC;
0670     return 0;
0671 }
0672 
0673 static const struct net_proto_family svc_family_ops = {
0674     .family = PF_ATMSVC,
0675     .create = svc_create,
0676     .owner = THIS_MODULE,
0677 };
0678 
0679 
0680 /*
0681  *  Initialize the ATM SVC protocol family
0682  */
0683 
0684 int __init atmsvc_init(void)
0685 {
0686     return sock_register(&svc_family_ops);
0687 }
0688 
0689 void atmsvc_exit(void)
0690 {
0691     sock_unregister(PF_ATMSVC);
0692 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!