Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  X.25 Packet Layer release 002
0004  *
0005  *  This is ALPHA test software. This code may break your machine,
0006  *  randomly fail to work with new releases, misbehave and/or generally
0007  *  screw up. It might even work.
0008  *
0009  *  This code REQUIRES 2.1.15 or higher
0010  *
0011  *  History
0012  *  X.25 001    Jonathan Naylor Started coding.
0013  *  X.25 002    Jonathan Naylor Centralised disconnect handling.
0014  *                  New timer architecture.
0015  *  2000-03-11  Henner Eisen    MSG_EOR handling more POSIX compliant.
0016  *  2000-03-22  Daniela Squassoni Allowed disabling/enabling of
0017  *                    facilities negotiation and increased
0018  *                    the throughput upper limit.
0019  *  2000-08-27  Arnaldo C. Melo s/suser/capable/ + micro cleanups
0020  *  2000-09-04  Henner Eisen    Set sock->state in x25_accept().
0021  *                  Fixed x25_output() related skb leakage.
0022  *  2000-10-02  Henner Eisen    Made x25_kick() single threaded per socket.
0023  *  2000-10-27  Henner Eisen    MSG_DONTWAIT for fragment allocation.
0024  *  2000-11-14  Henner Eisen    Closing datalink from NETDEV_GOING_DOWN
0025  *  2002-10-06  Arnaldo C. Melo Get rid of cli/sti, move proc stuff to
0026  *                  x25_proc.c, using seq_file
0027  *  2005-04-02  Shaun Pereira   Selective sub address matching
0028  *                  with call user data
0029  *  2005-04-15  Shaun Pereira   Fast select with no restriction on
0030  *                  response
0031  */
0032 
0033 #define pr_fmt(fmt) "X25: " fmt
0034 
0035 #include <linux/module.h>
0036 #include <linux/capability.h>
0037 #include <linux/errno.h>
0038 #include <linux/kernel.h>
0039 #include <linux/sched/signal.h>
0040 #include <linux/timer.h>
0041 #include <linux/string.h>
0042 #include <linux/net.h>
0043 #include <linux/netdevice.h>
0044 #include <linux/if_arp.h>
0045 #include <linux/skbuff.h>
0046 #include <linux/slab.h>
0047 #include <net/sock.h>
0048 #include <net/tcp_states.h>
0049 #include <linux/uaccess.h>
0050 #include <linux/fcntl.h>
0051 #include <linux/termios.h>  /* For TIOCINQ/OUTQ */
0052 #include <linux/notifier.h>
0053 #include <linux/init.h>
0054 #include <linux/compat.h>
0055 #include <linux/ctype.h>
0056 
0057 #include <net/x25.h>
0058 #include <net/compat.h>
0059 
0060 int sysctl_x25_restart_request_timeout = X25_DEFAULT_T20;
0061 int sysctl_x25_call_request_timeout    = X25_DEFAULT_T21;
0062 int sysctl_x25_reset_request_timeout   = X25_DEFAULT_T22;
0063 int sysctl_x25_clear_request_timeout   = X25_DEFAULT_T23;
0064 int sysctl_x25_ack_holdback_timeout    = X25_DEFAULT_T2;
0065 int sysctl_x25_forward                 = 0;
0066 
0067 HLIST_HEAD(x25_list);
0068 DEFINE_RWLOCK(x25_list_lock);
0069 
0070 static const struct proto_ops x25_proto_ops;
0071 
0072 static const struct x25_address null_x25_address = {"               "};
0073 
0074 #ifdef CONFIG_COMPAT
0075 struct compat_x25_subscrip_struct {
0076     char device[200-sizeof(compat_ulong_t)];
0077     compat_ulong_t global_facil_mask;
0078     compat_uint_t extended;
0079 };
0080 #endif
0081 
0082 
0083 int x25_parse_address_block(struct sk_buff *skb,
0084         struct x25_address *called_addr,
0085         struct x25_address *calling_addr)
0086 {
0087     unsigned char len;
0088     int needed;
0089     int rc;
0090 
0091     if (!pskb_may_pull(skb, 1)) {
0092         /* packet has no address block */
0093         rc = 0;
0094         goto empty;
0095     }
0096 
0097     len = *skb->data;
0098     needed = 1 + ((len >> 4) + (len & 0x0f) + 1) / 2;
0099 
0100     if (!pskb_may_pull(skb, needed)) {
0101         /* packet is too short to hold the addresses it claims
0102            to hold */
0103         rc = -1;
0104         goto empty;
0105     }
0106 
0107     return x25_addr_ntoa(skb->data, called_addr, calling_addr);
0108 
0109 empty:
0110     *called_addr->x25_addr = 0;
0111     *calling_addr->x25_addr = 0;
0112 
0113     return rc;
0114 }
0115 
0116 
0117 int x25_addr_ntoa(unsigned char *p, struct x25_address *called_addr,
0118           struct x25_address *calling_addr)
0119 {
0120     unsigned int called_len, calling_len;
0121     char *called, *calling;
0122     unsigned int i;
0123 
0124     called_len  = (*p >> 0) & 0x0F;
0125     calling_len = (*p >> 4) & 0x0F;
0126 
0127     called  = called_addr->x25_addr;
0128     calling = calling_addr->x25_addr;
0129     p++;
0130 
0131     for (i = 0; i < (called_len + calling_len); i++) {
0132         if (i < called_len) {
0133             if (i % 2 != 0) {
0134                 *called++ = ((*p >> 0) & 0x0F) + '0';
0135                 p++;
0136             } else {
0137                 *called++ = ((*p >> 4) & 0x0F) + '0';
0138             }
0139         } else {
0140             if (i % 2 != 0) {
0141                 *calling++ = ((*p >> 0) & 0x0F) + '0';
0142                 p++;
0143             } else {
0144                 *calling++ = ((*p >> 4) & 0x0F) + '0';
0145             }
0146         }
0147     }
0148 
0149     *called = *calling = '\0';
0150 
0151     return 1 + (called_len + calling_len + 1) / 2;
0152 }
0153 
0154 int x25_addr_aton(unsigned char *p, struct x25_address *called_addr,
0155           struct x25_address *calling_addr)
0156 {
0157     unsigned int called_len, calling_len;
0158     char *called, *calling;
0159     int i;
0160 
0161     called  = called_addr->x25_addr;
0162     calling = calling_addr->x25_addr;
0163 
0164     called_len  = strlen(called);
0165     calling_len = strlen(calling);
0166 
0167     *p++ = (calling_len << 4) | (called_len << 0);
0168 
0169     for (i = 0; i < (called_len + calling_len); i++) {
0170         if (i < called_len) {
0171             if (i % 2 != 0) {
0172                 *p |= (*called++ - '0') << 0;
0173                 p++;
0174             } else {
0175                 *p = 0x00;
0176                 *p |= (*called++ - '0') << 4;
0177             }
0178         } else {
0179             if (i % 2 != 0) {
0180                 *p |= (*calling++ - '0') << 0;
0181                 p++;
0182             } else {
0183                 *p = 0x00;
0184                 *p |= (*calling++ - '0') << 4;
0185             }
0186         }
0187     }
0188 
0189     return 1 + (called_len + calling_len + 1) / 2;
0190 }
0191 
0192 /*
0193  *  Socket removal during an interrupt is now safe.
0194  */
0195 static void x25_remove_socket(struct sock *sk)
0196 {
0197     write_lock_bh(&x25_list_lock);
0198     sk_del_node_init(sk);
0199     write_unlock_bh(&x25_list_lock);
0200 }
0201 
0202 /*
0203  *  Handle device status changes.
0204  */
0205 static int x25_device_event(struct notifier_block *this, unsigned long event,
0206                 void *ptr)
0207 {
0208     struct net_device *dev = netdev_notifier_info_to_dev(ptr);
0209     struct x25_neigh *nb;
0210 
0211     if (!net_eq(dev_net(dev), &init_net))
0212         return NOTIFY_DONE;
0213 
0214     if (dev->type == ARPHRD_X25) {
0215         switch (event) {
0216         case NETDEV_REGISTER:
0217         case NETDEV_POST_TYPE_CHANGE:
0218             x25_link_device_up(dev);
0219             break;
0220         case NETDEV_DOWN:
0221             nb = x25_get_neigh(dev);
0222             if (nb) {
0223                 x25_link_terminated(nb);
0224                 x25_neigh_put(nb);
0225             }
0226             x25_route_device_down(dev);
0227             break;
0228         case NETDEV_PRE_TYPE_CHANGE:
0229         case NETDEV_UNREGISTER:
0230             x25_link_device_down(dev);
0231             break;
0232         case NETDEV_CHANGE:
0233             if (!netif_carrier_ok(dev)) {
0234                 nb = x25_get_neigh(dev);
0235                 if (nb) {
0236                     x25_link_terminated(nb);
0237                     x25_neigh_put(nb);
0238                 }
0239             }
0240             break;
0241         }
0242     }
0243 
0244     return NOTIFY_DONE;
0245 }
0246 
0247 /*
0248  *  Add a socket to the bound sockets list.
0249  */
0250 static void x25_insert_socket(struct sock *sk)
0251 {
0252     write_lock_bh(&x25_list_lock);
0253     sk_add_node(sk, &x25_list);
0254     write_unlock_bh(&x25_list_lock);
0255 }
0256 
0257 /*
0258  *  Find a socket that wants to accept the Call Request we just
0259  *  received. Check the full list for an address/cud match.
0260  *  If no cuds match return the next_best thing, an address match.
0261  *  Note: if a listening socket has cud set it must only get calls
0262  *  with matching cud.
0263  */
0264 static struct sock *x25_find_listener(struct x25_address *addr,
0265                     struct sk_buff *skb)
0266 {
0267     struct sock *s;
0268     struct sock *next_best;
0269 
0270     read_lock_bh(&x25_list_lock);
0271     next_best = NULL;
0272 
0273     sk_for_each(s, &x25_list)
0274         if ((!strcmp(addr->x25_addr,
0275             x25_sk(s)->source_addr.x25_addr) ||
0276                 !strcmp(x25_sk(s)->source_addr.x25_addr,
0277                     null_x25_address.x25_addr)) &&
0278                     s->sk_state == TCP_LISTEN) {
0279             /*
0280              * Found a listening socket, now check the incoming
0281              * call user data vs this sockets call user data
0282              */
0283             if (x25_sk(s)->cudmatchlength > 0 &&
0284                 skb->len >= x25_sk(s)->cudmatchlength) {
0285                 if((memcmp(x25_sk(s)->calluserdata.cuddata,
0286                     skb->data,
0287                     x25_sk(s)->cudmatchlength)) == 0) {
0288                     sock_hold(s);
0289                     goto found;
0290                  }
0291             } else
0292                 next_best = s;
0293         }
0294     if (next_best) {
0295         s = next_best;
0296         sock_hold(s);
0297         goto found;
0298     }
0299     s = NULL;
0300 found:
0301     read_unlock_bh(&x25_list_lock);
0302     return s;
0303 }
0304 
0305 /*
0306  *  Find a connected X.25 socket given my LCI and neighbour.
0307  */
0308 static struct sock *__x25_find_socket(unsigned int lci, struct x25_neigh *nb)
0309 {
0310     struct sock *s;
0311 
0312     sk_for_each(s, &x25_list)
0313         if (x25_sk(s)->lci == lci && x25_sk(s)->neighbour == nb) {
0314             sock_hold(s);
0315             goto found;
0316         }
0317     s = NULL;
0318 found:
0319     return s;
0320 }
0321 
0322 struct sock *x25_find_socket(unsigned int lci, struct x25_neigh *nb)
0323 {
0324     struct sock *s;
0325 
0326     read_lock_bh(&x25_list_lock);
0327     s = __x25_find_socket(lci, nb);
0328     read_unlock_bh(&x25_list_lock);
0329     return s;
0330 }
0331 
0332 /*
0333  *  Find a unique LCI for a given device.
0334  */
0335 static unsigned int x25_new_lci(struct x25_neigh *nb)
0336 {
0337     unsigned int lci = 1;
0338     struct sock *sk;
0339 
0340     while ((sk = x25_find_socket(lci, nb)) != NULL) {
0341         sock_put(sk);
0342         if (++lci == 4096) {
0343             lci = 0;
0344             break;
0345         }
0346         cond_resched();
0347     }
0348 
0349     return lci;
0350 }
0351 
0352 /*
0353  *  Deferred destroy.
0354  */
0355 static void __x25_destroy_socket(struct sock *);
0356 
0357 /*
0358  *  handler for deferred kills.
0359  */
0360 static void x25_destroy_timer(struct timer_list *t)
0361 {
0362     struct sock *sk = from_timer(sk, t, sk_timer);
0363 
0364     x25_destroy_socket_from_timer(sk);
0365 }
0366 
0367 /*
0368  *  This is called from user mode and the timers. Thus it protects itself
0369  *  against interrupting users but doesn't worry about being called during
0370  *  work. Once it is removed from the queue no interrupt or bottom half
0371  *  will touch it and we are (fairly 8-) ) safe.
0372  *  Not static as it's used by the timer
0373  */
0374 static void __x25_destroy_socket(struct sock *sk)
0375 {
0376     struct sk_buff *skb;
0377 
0378     x25_stop_heartbeat(sk);
0379     x25_stop_timer(sk);
0380 
0381     x25_remove_socket(sk);
0382     x25_clear_queues(sk);       /* Flush the queues */
0383 
0384     while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
0385         if (skb->sk != sk) {        /* A pending connection */
0386             /*
0387              * Queue the unaccepted socket for death
0388              */
0389             skb->sk->sk_state = TCP_LISTEN;
0390             sock_set_flag(skb->sk, SOCK_DEAD);
0391             x25_start_heartbeat(skb->sk);
0392             x25_sk(skb->sk)->state = X25_STATE_0;
0393         }
0394 
0395         kfree_skb(skb);
0396     }
0397 
0398     if (sk_has_allocations(sk)) {
0399         /* Defer: outstanding buffers */
0400         sk->sk_timer.expires  = jiffies + 10 * HZ;
0401         sk->sk_timer.function = x25_destroy_timer;
0402         add_timer(&sk->sk_timer);
0403     } else {
0404         /* drop last reference so sock_put will free */
0405         __sock_put(sk);
0406     }
0407 }
0408 
0409 void x25_destroy_socket_from_timer(struct sock *sk)
0410 {
0411     sock_hold(sk);
0412     bh_lock_sock(sk);
0413     __x25_destroy_socket(sk);
0414     bh_unlock_sock(sk);
0415     sock_put(sk);
0416 }
0417 
0418 /*
0419  *  Handling for system calls applied via the various interfaces to a
0420  *  X.25 socket object.
0421  */
0422 
0423 static int x25_setsockopt(struct socket *sock, int level, int optname,
0424               sockptr_t optval, unsigned int optlen)
0425 {
0426     int opt;
0427     struct sock *sk = sock->sk;
0428     int rc = -ENOPROTOOPT;
0429 
0430     if (level != SOL_X25 || optname != X25_QBITINCL)
0431         goto out;
0432 
0433     rc = -EINVAL;
0434     if (optlen < sizeof(int))
0435         goto out;
0436 
0437     rc = -EFAULT;
0438     if (copy_from_sockptr(&opt, optval, sizeof(int)))
0439         goto out;
0440 
0441     if (opt)
0442         set_bit(X25_Q_BIT_FLAG, &x25_sk(sk)->flags);
0443     else
0444         clear_bit(X25_Q_BIT_FLAG, &x25_sk(sk)->flags);
0445     rc = 0;
0446 out:
0447     return rc;
0448 }
0449 
0450 static int x25_getsockopt(struct socket *sock, int level, int optname,
0451               char __user *optval, int __user *optlen)
0452 {
0453     struct sock *sk = sock->sk;
0454     int val, len, rc = -ENOPROTOOPT;
0455 
0456     if (level != SOL_X25 || optname != X25_QBITINCL)
0457         goto out;
0458 
0459     rc = -EFAULT;
0460     if (get_user(len, optlen))
0461         goto out;
0462 
0463     len = min_t(unsigned int, len, sizeof(int));
0464 
0465     rc = -EINVAL;
0466     if (len < 0)
0467         goto out;
0468 
0469     rc = -EFAULT;
0470     if (put_user(len, optlen))
0471         goto out;
0472 
0473     val = test_bit(X25_Q_BIT_FLAG, &x25_sk(sk)->flags);
0474     rc = copy_to_user(optval, &val, len) ? -EFAULT : 0;
0475 out:
0476     return rc;
0477 }
0478 
0479 static int x25_listen(struct socket *sock, int backlog)
0480 {
0481     struct sock *sk = sock->sk;
0482     int rc = -EOPNOTSUPP;
0483 
0484     lock_sock(sk);
0485     if (sk->sk_state != TCP_LISTEN) {
0486         memset(&x25_sk(sk)->dest_addr, 0, X25_ADDR_LEN);
0487         sk->sk_max_ack_backlog = backlog;
0488         sk->sk_state           = TCP_LISTEN;
0489         rc = 0;
0490     }
0491     release_sock(sk);
0492 
0493     return rc;
0494 }
0495 
0496 static struct proto x25_proto = {
0497     .name     = "X25",
0498     .owner    = THIS_MODULE,
0499     .obj_size = sizeof(struct x25_sock),
0500 };
0501 
0502 static struct sock *x25_alloc_socket(struct net *net, int kern)
0503 {
0504     struct x25_sock *x25;
0505     struct sock *sk = sk_alloc(net, AF_X25, GFP_ATOMIC, &x25_proto, kern);
0506 
0507     if (!sk)
0508         goto out;
0509 
0510     sock_init_data(NULL, sk);
0511 
0512     x25 = x25_sk(sk);
0513     skb_queue_head_init(&x25->ack_queue);
0514     skb_queue_head_init(&x25->fragment_queue);
0515     skb_queue_head_init(&x25->interrupt_in_queue);
0516     skb_queue_head_init(&x25->interrupt_out_queue);
0517 out:
0518     return sk;
0519 }
0520 
0521 static int x25_create(struct net *net, struct socket *sock, int protocol,
0522               int kern)
0523 {
0524     struct sock *sk;
0525     struct x25_sock *x25;
0526     int rc = -EAFNOSUPPORT;
0527 
0528     if (!net_eq(net, &init_net))
0529         goto out;
0530 
0531     rc = -ESOCKTNOSUPPORT;
0532     if (sock->type != SOCK_SEQPACKET)
0533         goto out;
0534 
0535     rc = -EINVAL;
0536     if (protocol)
0537         goto out;
0538 
0539     rc = -ENOMEM;
0540     if ((sk = x25_alloc_socket(net, kern)) == NULL)
0541         goto out;
0542 
0543     x25 = x25_sk(sk);
0544 
0545     sock_init_data(sock, sk);
0546 
0547     x25_init_timers(sk);
0548 
0549     sock->ops    = &x25_proto_ops;
0550     sk->sk_protocol = protocol;
0551     sk->sk_backlog_rcv = x25_backlog_rcv;
0552 
0553     x25->t21   = sysctl_x25_call_request_timeout;
0554     x25->t22   = sysctl_x25_reset_request_timeout;
0555     x25->t23   = sysctl_x25_clear_request_timeout;
0556     x25->t2    = sysctl_x25_ack_holdback_timeout;
0557     x25->state = X25_STATE_0;
0558     x25->cudmatchlength = 0;
0559     set_bit(X25_ACCPT_APPRV_FLAG, &x25->flags); /* normally no cud  */
0560                             /* on call accept   */
0561 
0562     x25->facilities.winsize_in  = X25_DEFAULT_WINDOW_SIZE;
0563     x25->facilities.winsize_out = X25_DEFAULT_WINDOW_SIZE;
0564     x25->facilities.pacsize_in  = X25_DEFAULT_PACKET_SIZE;
0565     x25->facilities.pacsize_out = X25_DEFAULT_PACKET_SIZE;
0566     x25->facilities.throughput  = 0;    /* by default don't negotiate
0567                            throughput */
0568     x25->facilities.reverse     = X25_DEFAULT_REVERSE;
0569     x25->dte_facilities.calling_len = 0;
0570     x25->dte_facilities.called_len = 0;
0571     memset(x25->dte_facilities.called_ae, '\0',
0572             sizeof(x25->dte_facilities.called_ae));
0573     memset(x25->dte_facilities.calling_ae, '\0',
0574             sizeof(x25->dte_facilities.calling_ae));
0575 
0576     rc = 0;
0577 out:
0578     return rc;
0579 }
0580 
0581 static struct sock *x25_make_new(struct sock *osk)
0582 {
0583     struct sock *sk = NULL;
0584     struct x25_sock *x25, *ox25;
0585 
0586     if (osk->sk_type != SOCK_SEQPACKET)
0587         goto out;
0588 
0589     if ((sk = x25_alloc_socket(sock_net(osk), 0)) == NULL)
0590         goto out;
0591 
0592     x25 = x25_sk(sk);
0593 
0594     sk->sk_type        = osk->sk_type;
0595     sk->sk_priority    = osk->sk_priority;
0596     sk->sk_protocol    = osk->sk_protocol;
0597     sk->sk_rcvbuf      = osk->sk_rcvbuf;
0598     sk->sk_sndbuf      = osk->sk_sndbuf;
0599     sk->sk_state       = TCP_ESTABLISHED;
0600     sk->sk_backlog_rcv = osk->sk_backlog_rcv;
0601     sock_copy_flags(sk, osk);
0602 
0603     ox25 = x25_sk(osk);
0604     x25->t21        = ox25->t21;
0605     x25->t22        = ox25->t22;
0606     x25->t23        = ox25->t23;
0607     x25->t2         = ox25->t2;
0608     x25->flags  = ox25->flags;
0609     x25->facilities = ox25->facilities;
0610     x25->dte_facilities = ox25->dte_facilities;
0611     x25->cudmatchlength = ox25->cudmatchlength;
0612 
0613     clear_bit(X25_INTERRUPT_FLAG, &x25->flags);
0614     x25_init_timers(sk);
0615 out:
0616     return sk;
0617 }
0618 
0619 static int x25_release(struct socket *sock)
0620 {
0621     struct sock *sk = sock->sk;
0622     struct x25_sock *x25;
0623 
0624     if (!sk)
0625         return 0;
0626 
0627     x25 = x25_sk(sk);
0628 
0629     sock_hold(sk);
0630     lock_sock(sk);
0631     switch (x25->state) {
0632 
0633         case X25_STATE_0:
0634         case X25_STATE_2:
0635             x25_disconnect(sk, 0, 0, 0);
0636             __x25_destroy_socket(sk);
0637             goto out;
0638 
0639         case X25_STATE_1:
0640         case X25_STATE_3:
0641         case X25_STATE_4:
0642             x25_clear_queues(sk);
0643             x25_write_internal(sk, X25_CLEAR_REQUEST);
0644             x25_start_t23timer(sk);
0645             x25->state = X25_STATE_2;
0646             sk->sk_state    = TCP_CLOSE;
0647             sk->sk_shutdown |= SEND_SHUTDOWN;
0648             sk->sk_state_change(sk);
0649             sock_set_flag(sk, SOCK_DEAD);
0650             sock_set_flag(sk, SOCK_DESTROY);
0651             break;
0652 
0653         case X25_STATE_5:
0654             x25_write_internal(sk, X25_CLEAR_REQUEST);
0655             x25_disconnect(sk, 0, 0, 0);
0656             __x25_destroy_socket(sk);
0657             goto out;
0658     }
0659 
0660     sock_orphan(sk);
0661 out:
0662     release_sock(sk);
0663     sock_put(sk);
0664     return 0;
0665 }
0666 
0667 static int x25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
0668 {
0669     struct sock *sk = sock->sk;
0670     struct sockaddr_x25 *addr = (struct sockaddr_x25 *)uaddr;
0671     int len, i, rc = 0;
0672 
0673     if (addr_len != sizeof(struct sockaddr_x25) ||
0674         addr->sx25_family != AF_X25 ||
0675         strnlen(addr->sx25_addr.x25_addr, X25_ADDR_LEN) == X25_ADDR_LEN) {
0676         rc = -EINVAL;
0677         goto out;
0678     }
0679 
0680     /* check for the null_x25_address */
0681     if (strcmp(addr->sx25_addr.x25_addr, null_x25_address.x25_addr)) {
0682 
0683         len = strlen(addr->sx25_addr.x25_addr);
0684         for (i = 0; i < len; i++) {
0685             if (!isdigit(addr->sx25_addr.x25_addr[i])) {
0686                 rc = -EINVAL;
0687                 goto out;
0688             }
0689         }
0690     }
0691 
0692     lock_sock(sk);
0693     if (sock_flag(sk, SOCK_ZAPPED)) {
0694         x25_sk(sk)->source_addr = addr->sx25_addr;
0695         x25_insert_socket(sk);
0696         sock_reset_flag(sk, SOCK_ZAPPED);
0697     } else {
0698         rc = -EINVAL;
0699     }
0700     release_sock(sk);
0701     SOCK_DEBUG(sk, "x25_bind: socket is bound\n");
0702 out:
0703     return rc;
0704 }
0705 
0706 static int x25_wait_for_connection_establishment(struct sock *sk)
0707 {
0708     DECLARE_WAITQUEUE(wait, current);
0709     int rc;
0710 
0711     add_wait_queue_exclusive(sk_sleep(sk), &wait);
0712     for (;;) {
0713         __set_current_state(TASK_INTERRUPTIBLE);
0714         rc = -ERESTARTSYS;
0715         if (signal_pending(current))
0716             break;
0717         rc = sock_error(sk);
0718         if (rc) {
0719             sk->sk_socket->state = SS_UNCONNECTED;
0720             break;
0721         }
0722         rc = -ENOTCONN;
0723         if (sk->sk_state == TCP_CLOSE) {
0724             sk->sk_socket->state = SS_UNCONNECTED;
0725             break;
0726         }
0727         rc = 0;
0728         if (sk->sk_state != TCP_ESTABLISHED) {
0729             release_sock(sk);
0730             schedule();
0731             lock_sock(sk);
0732         } else
0733             break;
0734     }
0735     __set_current_state(TASK_RUNNING);
0736     remove_wait_queue(sk_sleep(sk), &wait);
0737     return rc;
0738 }
0739 
0740 static int x25_connect(struct socket *sock, struct sockaddr *uaddr,
0741                int addr_len, int flags)
0742 {
0743     struct sock *sk = sock->sk;
0744     struct x25_sock *x25 = x25_sk(sk);
0745     struct sockaddr_x25 *addr = (struct sockaddr_x25 *)uaddr;
0746     struct x25_route *rt;
0747     int rc = 0;
0748 
0749     lock_sock(sk);
0750     if (sk->sk_state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
0751         sock->state = SS_CONNECTED;
0752         goto out; /* Connect completed during a ERESTARTSYS event */
0753     }
0754 
0755     rc = -ECONNREFUSED;
0756     if (sk->sk_state == TCP_CLOSE && sock->state == SS_CONNECTING) {
0757         sock->state = SS_UNCONNECTED;
0758         goto out;
0759     }
0760 
0761     rc = -EISCONN;  /* No reconnect on a seqpacket socket */
0762     if (sk->sk_state == TCP_ESTABLISHED)
0763         goto out;
0764 
0765     rc = -EALREADY; /* Do nothing if call is already in progress */
0766     if (sk->sk_state == TCP_SYN_SENT)
0767         goto out;
0768 
0769     sk->sk_state   = TCP_CLOSE;
0770     sock->state = SS_UNCONNECTED;
0771 
0772     rc = -EINVAL;
0773     if (addr_len != sizeof(struct sockaddr_x25) ||
0774         addr->sx25_family != AF_X25 ||
0775         strnlen(addr->sx25_addr.x25_addr, X25_ADDR_LEN) == X25_ADDR_LEN)
0776         goto out;
0777 
0778     rc = -ENETUNREACH;
0779     rt = x25_get_route(&addr->sx25_addr);
0780     if (!rt)
0781         goto out;
0782 
0783     x25->neighbour = x25_get_neigh(rt->dev);
0784     if (!x25->neighbour)
0785         goto out_put_route;
0786 
0787     x25_limit_facilities(&x25->facilities, x25->neighbour);
0788 
0789     x25->lci = x25_new_lci(x25->neighbour);
0790     if (!x25->lci)
0791         goto out_put_neigh;
0792 
0793     rc = -EINVAL;
0794     if (sock_flag(sk, SOCK_ZAPPED)) /* Must bind first - autobinding does not work */
0795         goto out_put_neigh;
0796 
0797     if (!strcmp(x25->source_addr.x25_addr, null_x25_address.x25_addr))
0798         memset(&x25->source_addr, '\0', X25_ADDR_LEN);
0799 
0800     x25->dest_addr = addr->sx25_addr;
0801 
0802     /* Move to connecting socket, start sending Connect Requests */
0803     sock->state   = SS_CONNECTING;
0804     sk->sk_state  = TCP_SYN_SENT;
0805 
0806     x25->state = X25_STATE_1;
0807 
0808     x25_write_internal(sk, X25_CALL_REQUEST);
0809 
0810     x25_start_heartbeat(sk);
0811     x25_start_t21timer(sk);
0812 
0813     /* Now the loop */
0814     rc = -EINPROGRESS;
0815     if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
0816         goto out;
0817 
0818     rc = x25_wait_for_connection_establishment(sk);
0819     if (rc)
0820         goto out_put_neigh;
0821 
0822     sock->state = SS_CONNECTED;
0823     rc = 0;
0824 out_put_neigh:
0825     if (rc && x25->neighbour) {
0826         read_lock_bh(&x25_list_lock);
0827         x25_neigh_put(x25->neighbour);
0828         x25->neighbour = NULL;
0829         read_unlock_bh(&x25_list_lock);
0830         x25->state = X25_STATE_0;
0831     }
0832 out_put_route:
0833     x25_route_put(rt);
0834 out:
0835     release_sock(sk);
0836     return rc;
0837 }
0838 
0839 static int x25_wait_for_data(struct sock *sk, long timeout)
0840 {
0841     DECLARE_WAITQUEUE(wait, current);
0842     int rc = 0;
0843 
0844     add_wait_queue_exclusive(sk_sleep(sk), &wait);
0845     for (;;) {
0846         __set_current_state(TASK_INTERRUPTIBLE);
0847         if (sk->sk_shutdown & RCV_SHUTDOWN)
0848             break;
0849         rc = -ERESTARTSYS;
0850         if (signal_pending(current))
0851             break;
0852         rc = -EAGAIN;
0853         if (!timeout)
0854             break;
0855         rc = 0;
0856         if (skb_queue_empty(&sk->sk_receive_queue)) {
0857             release_sock(sk);
0858             timeout = schedule_timeout(timeout);
0859             lock_sock(sk);
0860         } else
0861             break;
0862     }
0863     __set_current_state(TASK_RUNNING);
0864     remove_wait_queue(sk_sleep(sk), &wait);
0865     return rc;
0866 }
0867 
0868 static int x25_accept(struct socket *sock, struct socket *newsock, int flags,
0869               bool kern)
0870 {
0871     struct sock *sk = sock->sk;
0872     struct sock *newsk;
0873     struct sk_buff *skb;
0874     int rc = -EINVAL;
0875 
0876     if (!sk)
0877         goto out;
0878 
0879     rc = -EOPNOTSUPP;
0880     if (sk->sk_type != SOCK_SEQPACKET)
0881         goto out;
0882 
0883     lock_sock(sk);
0884     rc = -EINVAL;
0885     if (sk->sk_state != TCP_LISTEN)
0886         goto out2;
0887 
0888     rc = x25_wait_for_data(sk, sk->sk_rcvtimeo);
0889     if (rc)
0890         goto out2;
0891     skb = skb_dequeue(&sk->sk_receive_queue);
0892     rc = -EINVAL;
0893     if (!skb->sk)
0894         goto out2;
0895     newsk        = skb->sk;
0896     sock_graft(newsk, newsock);
0897 
0898     /* Now attach up the new socket */
0899     skb->sk = NULL;
0900     kfree_skb(skb);
0901     sk_acceptq_removed(sk);
0902     newsock->state = SS_CONNECTED;
0903     rc = 0;
0904 out2:
0905     release_sock(sk);
0906 out:
0907     return rc;
0908 }
0909 
0910 static int x25_getname(struct socket *sock, struct sockaddr *uaddr,
0911                int peer)
0912 {
0913     struct sockaddr_x25 *sx25 = (struct sockaddr_x25 *)uaddr;
0914     struct sock *sk = sock->sk;
0915     struct x25_sock *x25 = x25_sk(sk);
0916     int rc = 0;
0917 
0918     if (peer) {
0919         if (sk->sk_state != TCP_ESTABLISHED) {
0920             rc = -ENOTCONN;
0921             goto out;
0922         }
0923         sx25->sx25_addr = x25->dest_addr;
0924     } else
0925         sx25->sx25_addr = x25->source_addr;
0926 
0927     sx25->sx25_family = AF_X25;
0928     rc = sizeof(*sx25);
0929 
0930 out:
0931     return rc;
0932 }
0933 
0934 int x25_rx_call_request(struct sk_buff *skb, struct x25_neigh *nb,
0935             unsigned int lci)
0936 {
0937     struct sock *sk;
0938     struct sock *make;
0939     struct x25_sock *makex25;
0940     struct x25_address source_addr, dest_addr;
0941     struct x25_facilities facilities;
0942     struct x25_dte_facilities dte_facilities;
0943     int len, addr_len, rc;
0944 
0945     /*
0946      *  Remove the LCI and frame type.
0947      */
0948     skb_pull(skb, X25_STD_MIN_LEN);
0949 
0950     /*
0951      *  Extract the X.25 addresses and convert them to ASCII strings,
0952      *  and remove them.
0953      *
0954      *  Address block is mandatory in call request packets
0955      */
0956     addr_len = x25_parse_address_block(skb, &source_addr, &dest_addr);
0957     if (addr_len <= 0)
0958         goto out_clear_request;
0959     skb_pull(skb, addr_len);
0960 
0961     /*
0962      *  Get the length of the facilities, skip past them for the moment
0963      *  get the call user data because this is needed to determine
0964      *  the correct listener
0965      *
0966      *  Facilities length is mandatory in call request packets
0967      */
0968     if (!pskb_may_pull(skb, 1))
0969         goto out_clear_request;
0970     len = skb->data[0] + 1;
0971     if (!pskb_may_pull(skb, len))
0972         goto out_clear_request;
0973     skb_pull(skb,len);
0974 
0975     /*
0976      *  Ensure that the amount of call user data is valid.
0977      */
0978     if (skb->len > X25_MAX_CUD_LEN)
0979         goto out_clear_request;
0980 
0981     /*
0982      *  Get all the call user data so it can be used in
0983      *  x25_find_listener and skb_copy_from_linear_data up ahead.
0984      */
0985     if (!pskb_may_pull(skb, skb->len))
0986         goto out_clear_request;
0987 
0988     /*
0989      *  Find a listener for the particular address/cud pair.
0990      */
0991     sk = x25_find_listener(&source_addr,skb);
0992     skb_push(skb,len);
0993 
0994     if (sk != NULL && sk_acceptq_is_full(sk)) {
0995         goto out_sock_put;
0996     }
0997 
0998     /*
0999      *  We dont have any listeners for this incoming call.
1000      *  Try forwarding it.
1001      */
1002     if (sk == NULL) {
1003         skb_push(skb, addr_len + X25_STD_MIN_LEN);
1004         if (sysctl_x25_forward &&
1005                 x25_forward_call(&dest_addr, nb, skb, lci) > 0)
1006         {
1007             /* Call was forwarded, dont process it any more */
1008             kfree_skb(skb);
1009             rc = 1;
1010             goto out;
1011         } else {
1012             /* No listeners, can't forward, clear the call */
1013             goto out_clear_request;
1014         }
1015     }
1016 
1017     /*
1018      *  Try to reach a compromise on the requested facilities.
1019      */
1020     len = x25_negotiate_facilities(skb, sk, &facilities, &dte_facilities);
1021     if (len == -1)
1022         goto out_sock_put;
1023 
1024     /*
1025      * current neighbour/link might impose additional limits
1026      * on certain facilities
1027      */
1028 
1029     x25_limit_facilities(&facilities, nb);
1030 
1031     /*
1032      *  Try to create a new socket.
1033      */
1034     make = x25_make_new(sk);
1035     if (!make)
1036         goto out_sock_put;
1037 
1038     /*
1039      *  Remove the facilities
1040      */
1041     skb_pull(skb, len);
1042 
1043     skb->sk     = make;
1044     make->sk_state = TCP_ESTABLISHED;
1045 
1046     makex25 = x25_sk(make);
1047     makex25->lci           = lci;
1048     makex25->dest_addr     = dest_addr;
1049     makex25->source_addr   = source_addr;
1050     x25_neigh_hold(nb);
1051     makex25->neighbour     = nb;
1052     makex25->facilities    = facilities;
1053     makex25->dte_facilities= dte_facilities;
1054     makex25->vc_facil_mask = x25_sk(sk)->vc_facil_mask;
1055     /* ensure no reverse facil on accept */
1056     makex25->vc_facil_mask &= ~X25_MASK_REVERSE;
1057     /* ensure no calling address extension on accept */
1058     makex25->vc_facil_mask &= ~X25_MASK_CALLING_AE;
1059     makex25->cudmatchlength = x25_sk(sk)->cudmatchlength;
1060 
1061     /* Normally all calls are accepted immediately */
1062     if (test_bit(X25_ACCPT_APPRV_FLAG, &makex25->flags)) {
1063         x25_write_internal(make, X25_CALL_ACCEPTED);
1064         makex25->state = X25_STATE_3;
1065     } else {
1066         makex25->state = X25_STATE_5;
1067     }
1068 
1069     /*
1070      *  Incoming Call User Data.
1071      */
1072     skb_copy_from_linear_data(skb, makex25->calluserdata.cuddata, skb->len);
1073     makex25->calluserdata.cudlength = skb->len;
1074 
1075     sk_acceptq_added(sk);
1076 
1077     x25_insert_socket(make);
1078 
1079     skb_queue_head(&sk->sk_receive_queue, skb);
1080 
1081     x25_start_heartbeat(make);
1082 
1083     if (!sock_flag(sk, SOCK_DEAD))
1084         sk->sk_data_ready(sk);
1085     rc = 1;
1086     sock_put(sk);
1087 out:
1088     return rc;
1089 out_sock_put:
1090     sock_put(sk);
1091 out_clear_request:
1092     rc = 0;
1093     x25_transmit_clear_request(nb, lci, 0x01);
1094     goto out;
1095 }
1096 
1097 static int x25_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
1098 {
1099     struct sock *sk = sock->sk;
1100     struct x25_sock *x25 = x25_sk(sk);
1101     DECLARE_SOCKADDR(struct sockaddr_x25 *, usx25, msg->msg_name);
1102     struct sockaddr_x25 sx25;
1103     struct sk_buff *skb;
1104     unsigned char *asmptr;
1105     int noblock = msg->msg_flags & MSG_DONTWAIT;
1106     size_t size;
1107     int qbit = 0, rc = -EINVAL;
1108 
1109     lock_sock(sk);
1110     if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_OOB|MSG_EOR|MSG_CMSG_COMPAT))
1111         goto out;
1112 
1113     /* we currently don't support segmented records at the user interface */
1114     if (!(msg->msg_flags & (MSG_EOR|MSG_OOB)))
1115         goto out;
1116 
1117     rc = -EADDRNOTAVAIL;
1118     if (sock_flag(sk, SOCK_ZAPPED))
1119         goto out;
1120 
1121     rc = -EPIPE;
1122     if (sk->sk_shutdown & SEND_SHUTDOWN) {
1123         send_sig(SIGPIPE, current, 0);
1124         goto out;
1125     }
1126 
1127     rc = -ENETUNREACH;
1128     if (!x25->neighbour)
1129         goto out;
1130 
1131     if (usx25) {
1132         rc = -EINVAL;
1133         if (msg->msg_namelen < sizeof(sx25))
1134             goto out;
1135         memcpy(&sx25, usx25, sizeof(sx25));
1136         rc = -EISCONN;
1137         if (strcmp(x25->dest_addr.x25_addr, sx25.sx25_addr.x25_addr))
1138             goto out;
1139         rc = -EINVAL;
1140         if (sx25.sx25_family != AF_X25)
1141             goto out;
1142     } else {
1143         /*
1144          *  FIXME 1003.1g - if the socket is like this because
1145          *  it has become closed (not started closed) we ought
1146          *  to SIGPIPE, EPIPE;
1147          */
1148         rc = -ENOTCONN;
1149         if (sk->sk_state != TCP_ESTABLISHED)
1150             goto out;
1151 
1152         sx25.sx25_family = AF_X25;
1153         sx25.sx25_addr   = x25->dest_addr;
1154     }
1155 
1156     /* Sanity check the packet size */
1157     if (len > 65535) {
1158         rc = -EMSGSIZE;
1159         goto out;
1160     }
1161 
1162     SOCK_DEBUG(sk, "x25_sendmsg: sendto: Addresses built.\n");
1163 
1164     /* Build a packet */
1165     SOCK_DEBUG(sk, "x25_sendmsg: sendto: building packet.\n");
1166 
1167     if ((msg->msg_flags & MSG_OOB) && len > 32)
1168         len = 32;
1169 
1170     size = len + X25_MAX_L2_LEN + X25_EXT_MIN_LEN;
1171 
1172     release_sock(sk);
1173     skb = sock_alloc_send_skb(sk, size, noblock, &rc);
1174     lock_sock(sk);
1175     if (!skb)
1176         goto out;
1177     X25_SKB_CB(skb)->flags = msg->msg_flags;
1178 
1179     skb_reserve(skb, X25_MAX_L2_LEN + X25_EXT_MIN_LEN);
1180 
1181     /*
1182      *  Put the data on the end
1183      */
1184     SOCK_DEBUG(sk, "x25_sendmsg: Copying user data\n");
1185 
1186     skb_reset_transport_header(skb);
1187     skb_put(skb, len);
1188 
1189     rc = memcpy_from_msg(skb_transport_header(skb), msg, len);
1190     if (rc)
1191         goto out_kfree_skb;
1192 
1193     /*
1194      *  If the Q BIT Include socket option is in force, the first
1195      *  byte of the user data is the logical value of the Q Bit.
1196      */
1197     if (test_bit(X25_Q_BIT_FLAG, &x25->flags)) {
1198         if (!pskb_may_pull(skb, 1))
1199             goto out_kfree_skb;
1200 
1201         qbit = skb->data[0];
1202         skb_pull(skb, 1);
1203     }
1204 
1205     /*
1206      *  Push down the X.25 header
1207      */
1208     SOCK_DEBUG(sk, "x25_sendmsg: Building X.25 Header.\n");
1209 
1210     if (msg->msg_flags & MSG_OOB) {
1211         if (x25->neighbour->extended) {
1212             asmptr    = skb_push(skb, X25_STD_MIN_LEN);
1213             *asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_EXTSEQ;
1214             *asmptr++ = (x25->lci >> 0) & 0xFF;
1215             *asmptr++ = X25_INTERRUPT;
1216         } else {
1217             asmptr    = skb_push(skb, X25_STD_MIN_LEN);
1218             *asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_STDSEQ;
1219             *asmptr++ = (x25->lci >> 0) & 0xFF;
1220             *asmptr++ = X25_INTERRUPT;
1221         }
1222     } else {
1223         if (x25->neighbour->extended) {
1224             /* Build an Extended X.25 header */
1225             asmptr    = skb_push(skb, X25_EXT_MIN_LEN);
1226             *asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_EXTSEQ;
1227             *asmptr++ = (x25->lci >> 0) & 0xFF;
1228             *asmptr++ = X25_DATA;
1229             *asmptr++ = X25_DATA;
1230         } else {
1231             /* Build an Standard X.25 header */
1232             asmptr    = skb_push(skb, X25_STD_MIN_LEN);
1233             *asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_STDSEQ;
1234             *asmptr++ = (x25->lci >> 0) & 0xFF;
1235             *asmptr++ = X25_DATA;
1236         }
1237 
1238         if (qbit)
1239             skb->data[0] |= X25_Q_BIT;
1240     }
1241 
1242     SOCK_DEBUG(sk, "x25_sendmsg: Built header.\n");
1243     SOCK_DEBUG(sk, "x25_sendmsg: Transmitting buffer\n");
1244 
1245     rc = -ENOTCONN;
1246     if (sk->sk_state != TCP_ESTABLISHED)
1247         goto out_kfree_skb;
1248 
1249     if (msg->msg_flags & MSG_OOB)
1250         skb_queue_tail(&x25->interrupt_out_queue, skb);
1251     else {
1252         rc = x25_output(sk, skb);
1253         len = rc;
1254         if (rc < 0)
1255             kfree_skb(skb);
1256         else if (test_bit(X25_Q_BIT_FLAG, &x25->flags))
1257             len++;
1258     }
1259 
1260     x25_kick(sk);
1261     rc = len;
1262 out:
1263     release_sock(sk);
1264     return rc;
1265 out_kfree_skb:
1266     kfree_skb(skb);
1267     goto out;
1268 }
1269 
1270 
1271 static int x25_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1272                int flags)
1273 {
1274     struct sock *sk = sock->sk;
1275     struct x25_sock *x25 = x25_sk(sk);
1276     DECLARE_SOCKADDR(struct sockaddr_x25 *, sx25, msg->msg_name);
1277     size_t copied;
1278     int qbit, header_len;
1279     struct sk_buff *skb;
1280     unsigned char *asmptr;
1281     int rc = -ENOTCONN;
1282 
1283     lock_sock(sk);
1284 
1285     if (x25->neighbour == NULL)
1286         goto out;
1287 
1288     header_len = x25->neighbour->extended ?
1289         X25_EXT_MIN_LEN : X25_STD_MIN_LEN;
1290 
1291     /*
1292      * This works for seqpacket too. The receiver has ordered the queue for
1293      * us! We do one quick check first though
1294      */
1295     if (sk->sk_state != TCP_ESTABLISHED)
1296         goto out;
1297 
1298     if (flags & MSG_OOB) {
1299         rc = -EINVAL;
1300         if (sock_flag(sk, SOCK_URGINLINE) ||
1301             !skb_peek(&x25->interrupt_in_queue))
1302             goto out;
1303 
1304         skb = skb_dequeue(&x25->interrupt_in_queue);
1305 
1306         if (!pskb_may_pull(skb, X25_STD_MIN_LEN))
1307             goto out_free_dgram;
1308 
1309         skb_pull(skb, X25_STD_MIN_LEN);
1310 
1311         /*
1312          *  No Q bit information on Interrupt data.
1313          */
1314         if (test_bit(X25_Q_BIT_FLAG, &x25->flags)) {
1315             asmptr  = skb_push(skb, 1);
1316             *asmptr = 0x00;
1317         }
1318 
1319         msg->msg_flags |= MSG_OOB;
1320     } else {
1321         /* Now we can treat all alike */
1322         release_sock(sk);
1323         skb = skb_recv_datagram(sk, flags, &rc);
1324         lock_sock(sk);
1325         if (!skb)
1326             goto out;
1327 
1328         if (!pskb_may_pull(skb, header_len))
1329             goto out_free_dgram;
1330 
1331         qbit = (skb->data[0] & X25_Q_BIT) == X25_Q_BIT;
1332 
1333         skb_pull(skb, header_len);
1334 
1335         if (test_bit(X25_Q_BIT_FLAG, &x25->flags)) {
1336             asmptr  = skb_push(skb, 1);
1337             *asmptr = qbit;
1338         }
1339     }
1340 
1341     skb_reset_transport_header(skb);
1342     copied = skb->len;
1343 
1344     if (copied > size) {
1345         copied = size;
1346         msg->msg_flags |= MSG_TRUNC;
1347     }
1348 
1349     /* Currently, each datagram always contains a complete record */
1350     msg->msg_flags |= MSG_EOR;
1351 
1352     rc = skb_copy_datagram_msg(skb, 0, msg, copied);
1353     if (rc)
1354         goto out_free_dgram;
1355 
1356     if (sx25) {
1357         sx25->sx25_family = AF_X25;
1358         sx25->sx25_addr   = x25->dest_addr;
1359         msg->msg_namelen = sizeof(*sx25);
1360     }
1361 
1362     x25_check_rbuf(sk);
1363     rc = copied;
1364 out_free_dgram:
1365     skb_free_datagram(sk, skb);
1366 out:
1367     release_sock(sk);
1368     return rc;
1369 }
1370 
1371 
1372 static int x25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1373 {
1374     struct sock *sk = sock->sk;
1375     struct x25_sock *x25 = x25_sk(sk);
1376     void __user *argp = (void __user *)arg;
1377     int rc;
1378 
1379     switch (cmd) {
1380     case TIOCOUTQ: {
1381         int amount;
1382 
1383         amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1384         if (amount < 0)
1385             amount = 0;
1386         rc = put_user(amount, (unsigned int __user *)argp);
1387         break;
1388     }
1389 
1390     case TIOCINQ: {
1391         struct sk_buff *skb;
1392         int amount = 0;
1393         /*
1394          * These two are safe on a single CPU system as
1395          * only user tasks fiddle here
1396          */
1397         lock_sock(sk);
1398         if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1399             amount = skb->len;
1400         release_sock(sk);
1401         rc = put_user(amount, (unsigned int __user *)argp);
1402         break;
1403     }
1404 
1405     case SIOCGIFADDR:
1406     case SIOCSIFADDR:
1407     case SIOCGIFDSTADDR:
1408     case SIOCSIFDSTADDR:
1409     case SIOCGIFBRDADDR:
1410     case SIOCSIFBRDADDR:
1411     case SIOCGIFNETMASK:
1412     case SIOCSIFNETMASK:
1413     case SIOCGIFMETRIC:
1414     case SIOCSIFMETRIC:
1415         rc = -EINVAL;
1416         break;
1417     case SIOCADDRT:
1418     case SIOCDELRT:
1419         rc = -EPERM;
1420         if (!capable(CAP_NET_ADMIN))
1421             break;
1422         rc = x25_route_ioctl(cmd, argp);
1423         break;
1424     case SIOCX25GSUBSCRIP:
1425         rc = x25_subscr_ioctl(cmd, argp);
1426         break;
1427     case SIOCX25SSUBSCRIP:
1428         rc = -EPERM;
1429         if (!capable(CAP_NET_ADMIN))
1430             break;
1431         rc = x25_subscr_ioctl(cmd, argp);
1432         break;
1433     case SIOCX25GFACILITIES: {
1434         lock_sock(sk);
1435         rc = copy_to_user(argp, &x25->facilities,
1436                   sizeof(x25->facilities))
1437             ? -EFAULT : 0;
1438         release_sock(sk);
1439         break;
1440     }
1441 
1442     case SIOCX25SFACILITIES: {
1443         struct x25_facilities facilities;
1444         rc = -EFAULT;
1445         if (copy_from_user(&facilities, argp, sizeof(facilities)))
1446             break;
1447         rc = -EINVAL;
1448         lock_sock(sk);
1449         if (sk->sk_state != TCP_LISTEN &&
1450             sk->sk_state != TCP_CLOSE)
1451             goto out_fac_release;
1452         if (facilities.pacsize_in < X25_PS16 ||
1453             facilities.pacsize_in > X25_PS4096)
1454             goto out_fac_release;
1455         if (facilities.pacsize_out < X25_PS16 ||
1456             facilities.pacsize_out > X25_PS4096)
1457             goto out_fac_release;
1458         if (facilities.winsize_in < 1 ||
1459             facilities.winsize_in > 127)
1460             goto out_fac_release;
1461         if (facilities.throughput) {
1462             int out = facilities.throughput & 0xf0;
1463             int in  = facilities.throughput & 0x0f;
1464             if (!out)
1465                 facilities.throughput |=
1466                     X25_DEFAULT_THROUGHPUT << 4;
1467             else if (out < 0x30 || out > 0xD0)
1468                 goto out_fac_release;
1469             if (!in)
1470                 facilities.throughput |=
1471                     X25_DEFAULT_THROUGHPUT;
1472             else if (in < 0x03 || in > 0x0D)
1473                 goto out_fac_release;
1474         }
1475         if (facilities.reverse &&
1476             (facilities.reverse & 0x81) != 0x81)
1477             goto out_fac_release;
1478         x25->facilities = facilities;
1479         rc = 0;
1480 out_fac_release:
1481         release_sock(sk);
1482         break;
1483     }
1484 
1485     case SIOCX25GDTEFACILITIES: {
1486         lock_sock(sk);
1487         rc = copy_to_user(argp, &x25->dte_facilities,
1488                   sizeof(x25->dte_facilities));
1489         release_sock(sk);
1490         if (rc)
1491             rc = -EFAULT;
1492         break;
1493     }
1494 
1495     case SIOCX25SDTEFACILITIES: {
1496         struct x25_dte_facilities dtefacs;
1497         rc = -EFAULT;
1498         if (copy_from_user(&dtefacs, argp, sizeof(dtefacs)))
1499             break;
1500         rc = -EINVAL;
1501         lock_sock(sk);
1502         if (sk->sk_state != TCP_LISTEN &&
1503             sk->sk_state != TCP_CLOSE)
1504             goto out_dtefac_release;
1505         if (dtefacs.calling_len > X25_MAX_AE_LEN)
1506             goto out_dtefac_release;
1507         if (dtefacs.called_len > X25_MAX_AE_LEN)
1508             goto out_dtefac_release;
1509         x25->dte_facilities = dtefacs;
1510         rc = 0;
1511 out_dtefac_release:
1512         release_sock(sk);
1513         break;
1514     }
1515 
1516     case SIOCX25GCALLUSERDATA: {
1517         lock_sock(sk);
1518         rc = copy_to_user(argp, &x25->calluserdata,
1519                   sizeof(x25->calluserdata))
1520             ? -EFAULT : 0;
1521         release_sock(sk);
1522         break;
1523     }
1524 
1525     case SIOCX25SCALLUSERDATA: {
1526         struct x25_calluserdata calluserdata;
1527 
1528         rc = -EFAULT;
1529         if (copy_from_user(&calluserdata, argp, sizeof(calluserdata)))
1530             break;
1531         rc = -EINVAL;
1532         if (calluserdata.cudlength > X25_MAX_CUD_LEN)
1533             break;
1534         lock_sock(sk);
1535         x25->calluserdata = calluserdata;
1536         release_sock(sk);
1537         rc = 0;
1538         break;
1539     }
1540 
1541     case SIOCX25GCAUSEDIAG: {
1542         lock_sock(sk);
1543         rc = copy_to_user(argp, &x25->causediag, sizeof(x25->causediag))
1544             ? -EFAULT : 0;
1545         release_sock(sk);
1546         break;
1547     }
1548 
1549     case SIOCX25SCAUSEDIAG: {
1550         struct x25_causediag causediag;
1551         rc = -EFAULT;
1552         if (copy_from_user(&causediag, argp, sizeof(causediag)))
1553             break;
1554         lock_sock(sk);
1555         x25->causediag = causediag;
1556         release_sock(sk);
1557         rc = 0;
1558         break;
1559 
1560     }
1561 
1562     case SIOCX25SCUDMATCHLEN: {
1563         struct x25_subaddr sub_addr;
1564         rc = -EINVAL;
1565         lock_sock(sk);
1566         if(sk->sk_state != TCP_CLOSE)
1567             goto out_cud_release;
1568         rc = -EFAULT;
1569         if (copy_from_user(&sub_addr, argp,
1570                    sizeof(sub_addr)))
1571             goto out_cud_release;
1572         rc = -EINVAL;
1573         if (sub_addr.cudmatchlength > X25_MAX_CUD_LEN)
1574             goto out_cud_release;
1575         x25->cudmatchlength = sub_addr.cudmatchlength;
1576         rc = 0;
1577 out_cud_release:
1578         release_sock(sk);
1579         break;
1580     }
1581 
1582     case SIOCX25CALLACCPTAPPRV: {
1583         rc = -EINVAL;
1584         lock_sock(sk);
1585         if (sk->sk_state == TCP_CLOSE) {
1586             clear_bit(X25_ACCPT_APPRV_FLAG, &x25->flags);
1587             rc = 0;
1588         }
1589         release_sock(sk);
1590         break;
1591     }
1592 
1593     case SIOCX25SENDCALLACCPT:  {
1594         rc = -EINVAL;
1595         lock_sock(sk);
1596         if (sk->sk_state != TCP_ESTABLISHED)
1597             goto out_sendcallaccpt_release;
1598         /* must call accptapprv above */
1599         if (test_bit(X25_ACCPT_APPRV_FLAG, &x25->flags))
1600             goto out_sendcallaccpt_release;
1601         x25_write_internal(sk, X25_CALL_ACCEPTED);
1602         x25->state = X25_STATE_3;
1603         rc = 0;
1604 out_sendcallaccpt_release:
1605         release_sock(sk);
1606         break;
1607     }
1608 
1609     default:
1610         rc = -ENOIOCTLCMD;
1611         break;
1612     }
1613 
1614     return rc;
1615 }
1616 
1617 static const struct net_proto_family x25_family_ops = {
1618     .family =   AF_X25,
1619     .create =   x25_create,
1620     .owner  =   THIS_MODULE,
1621 };
1622 
1623 #ifdef CONFIG_COMPAT
1624 static int compat_x25_subscr_ioctl(unsigned int cmd,
1625         struct compat_x25_subscrip_struct __user *x25_subscr32)
1626 {
1627     struct compat_x25_subscrip_struct x25_subscr;
1628     struct x25_neigh *nb;
1629     struct net_device *dev;
1630     int rc = -EINVAL;
1631 
1632     rc = -EFAULT;
1633     if (copy_from_user(&x25_subscr, x25_subscr32, sizeof(*x25_subscr32)))
1634         goto out;
1635 
1636     rc = -EINVAL;
1637     dev = x25_dev_get(x25_subscr.device);
1638     if (dev == NULL)
1639         goto out;
1640 
1641     nb = x25_get_neigh(dev);
1642     if (nb == NULL)
1643         goto out_dev_put;
1644 
1645     dev_put(dev);
1646 
1647     if (cmd == SIOCX25GSUBSCRIP) {
1648         read_lock_bh(&x25_neigh_list_lock);
1649         x25_subscr.extended = nb->extended;
1650         x25_subscr.global_facil_mask = nb->global_facil_mask;
1651         read_unlock_bh(&x25_neigh_list_lock);
1652         rc = copy_to_user(x25_subscr32, &x25_subscr,
1653                 sizeof(*x25_subscr32)) ? -EFAULT : 0;
1654     } else {
1655         rc = -EINVAL;
1656         if (x25_subscr.extended == 0 || x25_subscr.extended == 1) {
1657             rc = 0;
1658             write_lock_bh(&x25_neigh_list_lock);
1659             nb->extended = x25_subscr.extended;
1660             nb->global_facil_mask = x25_subscr.global_facil_mask;
1661             write_unlock_bh(&x25_neigh_list_lock);
1662         }
1663     }
1664     x25_neigh_put(nb);
1665 out:
1666     return rc;
1667 out_dev_put:
1668     dev_put(dev);
1669     goto out;
1670 }
1671 
1672 static int compat_x25_ioctl(struct socket *sock, unsigned int cmd,
1673                 unsigned long arg)
1674 {
1675     void __user *argp = compat_ptr(arg);
1676     int rc = -ENOIOCTLCMD;
1677 
1678     switch(cmd) {
1679     case TIOCOUTQ:
1680     case TIOCINQ:
1681         rc = x25_ioctl(sock, cmd, (unsigned long)argp);
1682         break;
1683     case SIOCGIFADDR:
1684     case SIOCSIFADDR:
1685     case SIOCGIFDSTADDR:
1686     case SIOCSIFDSTADDR:
1687     case SIOCGIFBRDADDR:
1688     case SIOCSIFBRDADDR:
1689     case SIOCGIFNETMASK:
1690     case SIOCSIFNETMASK:
1691     case SIOCGIFMETRIC:
1692     case SIOCSIFMETRIC:
1693         rc = -EINVAL;
1694         break;
1695     case SIOCADDRT:
1696     case SIOCDELRT:
1697         rc = -EPERM;
1698         if (!capable(CAP_NET_ADMIN))
1699             break;
1700         rc = x25_route_ioctl(cmd, argp);
1701         break;
1702     case SIOCX25GSUBSCRIP:
1703         rc = compat_x25_subscr_ioctl(cmd, argp);
1704         break;
1705     case SIOCX25SSUBSCRIP:
1706         rc = -EPERM;
1707         if (!capable(CAP_NET_ADMIN))
1708             break;
1709         rc = compat_x25_subscr_ioctl(cmd, argp);
1710         break;
1711     case SIOCX25GFACILITIES:
1712     case SIOCX25SFACILITIES:
1713     case SIOCX25GDTEFACILITIES:
1714     case SIOCX25SDTEFACILITIES:
1715     case SIOCX25GCALLUSERDATA:
1716     case SIOCX25SCALLUSERDATA:
1717     case SIOCX25GCAUSEDIAG:
1718     case SIOCX25SCAUSEDIAG:
1719     case SIOCX25SCUDMATCHLEN:
1720     case SIOCX25CALLACCPTAPPRV:
1721     case SIOCX25SENDCALLACCPT:
1722         rc = x25_ioctl(sock, cmd, (unsigned long)argp);
1723         break;
1724     default:
1725         rc = -ENOIOCTLCMD;
1726         break;
1727     }
1728     return rc;
1729 }
1730 #endif
1731 
1732 static const struct proto_ops x25_proto_ops = {
1733     .family =   AF_X25,
1734     .owner =    THIS_MODULE,
1735     .release =  x25_release,
1736     .bind =     x25_bind,
1737     .connect =  x25_connect,
1738     .socketpair =   sock_no_socketpair,
1739     .accept =   x25_accept,
1740     .getname =  x25_getname,
1741     .poll =     datagram_poll,
1742     .ioctl =    x25_ioctl,
1743 #ifdef CONFIG_COMPAT
1744     .compat_ioctl = compat_x25_ioctl,
1745 #endif
1746     .gettstamp =    sock_gettstamp,
1747     .listen =   x25_listen,
1748     .shutdown = sock_no_shutdown,
1749     .setsockopt =   x25_setsockopt,
1750     .getsockopt =   x25_getsockopt,
1751     .sendmsg =  x25_sendmsg,
1752     .recvmsg =  x25_recvmsg,
1753     .mmap =     sock_no_mmap,
1754     .sendpage = sock_no_sendpage,
1755 };
1756 
1757 static struct packet_type x25_packet_type __read_mostly = {
1758     .type = cpu_to_be16(ETH_P_X25),
1759     .func = x25_lapb_receive_frame,
1760 };
1761 
1762 static struct notifier_block x25_dev_notifier = {
1763     .notifier_call = x25_device_event,
1764 };
1765 
1766 void x25_kill_by_neigh(struct x25_neigh *nb)
1767 {
1768     struct sock *s;
1769 
1770     write_lock_bh(&x25_list_lock);
1771 
1772     sk_for_each(s, &x25_list) {
1773         if (x25_sk(s)->neighbour == nb) {
1774             write_unlock_bh(&x25_list_lock);
1775             lock_sock(s);
1776             x25_disconnect(s, ENETUNREACH, 0, 0);
1777             release_sock(s);
1778             write_lock_bh(&x25_list_lock);
1779         }
1780     }
1781     write_unlock_bh(&x25_list_lock);
1782 
1783     /* Remove any related forwards */
1784     x25_clear_forward_by_dev(nb->dev);
1785 }
1786 
1787 static int __init x25_init(void)
1788 {
1789     int rc;
1790 
1791     rc = proto_register(&x25_proto, 0);
1792     if (rc)
1793         goto out;
1794 
1795     rc = sock_register(&x25_family_ops);
1796     if (rc)
1797         goto out_proto;
1798 
1799     dev_add_pack(&x25_packet_type);
1800 
1801     rc = register_netdevice_notifier(&x25_dev_notifier);
1802     if (rc)
1803         goto out_sock;
1804 
1805     rc = x25_register_sysctl();
1806     if (rc)
1807         goto out_dev;
1808 
1809     rc = x25_proc_init();
1810     if (rc)
1811         goto out_sysctl;
1812 
1813     pr_info("Linux Version 0.2\n");
1814 
1815 out:
1816     return rc;
1817 out_sysctl:
1818     x25_unregister_sysctl();
1819 out_dev:
1820     unregister_netdevice_notifier(&x25_dev_notifier);
1821 out_sock:
1822     dev_remove_pack(&x25_packet_type);
1823     sock_unregister(AF_X25);
1824 out_proto:
1825     proto_unregister(&x25_proto);
1826     goto out;
1827 }
1828 module_init(x25_init);
1829 
1830 static void __exit x25_exit(void)
1831 {
1832     x25_proc_exit();
1833     x25_link_free();
1834     x25_route_free();
1835 
1836     x25_unregister_sysctl();
1837 
1838     unregister_netdevice_notifier(&x25_dev_notifier);
1839 
1840     dev_remove_pack(&x25_packet_type);
1841 
1842     sock_unregister(AF_X25);
1843     proto_unregister(&x25_proto);
1844 }
1845 module_exit(x25_exit);
1846 
1847 MODULE_AUTHOR("Jonathan Naylor <g4klx@g4klx.demon.co.uk>");
1848 MODULE_DESCRIPTION("The X.25 Packet Layer network layer protocol");
1849 MODULE_LICENSE("GPL");
1850 MODULE_ALIAS_NETPROTO(PF_X25);
[ 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!