net/x25/af_x25.c

   1 /*
   2  *      X.25 Packet Layer release 002
   3  *
   4  *      This is ALPHA test software. This code may break your machine,
   5  *      randomly fail to work with new releases, misbehave and/or generally
   6  *      screw up. It might even work.
   7  *
   8  *      This code REQUIRES 2.1.15 or higher
   9  *
  10  *      This module:
  11  *              This module is free software; you can redistribute it and/or
  12  *              modify it under the terms of the GNU General Public License
  13  *              as published by the Free Software Foundation; either version
  14  *              2 of the License, or (at your option) any later version.
  15  *
  16  *      History
  17  *      X.25 001        Jonathan Naylor Started coding.
  18  *      X.25 002        Jonathan Naylor Centralised disconnect handling.
  19  *                                      New timer architecture.
  20  *      2000-03-11      Henner Eisen    MSG_EOR handling more POSIX compliant.
  21  *      2000-03-22      Daniela Squassoni Allowed disabling/enabling of
  22  *                                        facilities negotiation and increased
  23  *                                        the throughput upper limit.
  24  *      2000-08-27      Arnaldo C. Melo s/suser/capable/ + micro cleanups
  25  *      2000-09-04      Henner Eisen    Set sock->state in x25_accept().
  26  *                                      Fixed x25_output() related skb leakage.
  27  *      2000-10-02      Henner Eisen    Made x25_kick() single threaded per socket.
  28  *      2000-10-27      Henner Eisen    MSG_DONTWAIT for fragment allocation.
  29  *      2000-11-14      Henner Eisen    Closing datalink from NETDEV_GOING_DOWN
  30  *      2002-10-06      Arnaldo C. Melo Get rid of cli/sti, move proc stuff to
  31  *                                      x25_proc.c, using seq_file
  32  */
  33
  34 #include <linux/config.h>
  35 #include <linux/module.h>
  36 #include <linux/errno.h>
  37 #include <linux/kernel.h>
  38 #include <linux/sched.h>
  39 #include <linux/timer.h>
  40 #include <linux/string.h>
  41 #include <linux/net.h>
  42 #include <linux/netdevice.h>
  43 #include <linux/if_arp.h>
  44 #include <linux/skbuff.h>
  45 #include <net/sock.h>
  46 #include <net/tcp.h>
  47 #include <asm/uaccess.h>
  48 #include <linux/fcntl.h>
  49 #include <linux/termios.h>      /* For TIOCINQ/OUTQ */
  50 #include <linux/notifier.h>
  51 #include <linux/init.h>
  52 #include <net/x25.h>
  53
  54 int sysctl_x25_restart_request_timeout = X25_DEFAULT_T20;
  55 int sysctl_x25_call_request_timeout    = X25_DEFAULT_T21;
  56 int sysctl_x25_reset_request_timeout   = X25_DEFAULT_T22;
  57 int sysctl_x25_clear_request_timeout   = X25_DEFAULT_T23;
  58 int sysctl_x25_ack_holdback_timeout    = X25_DEFAULT_T2;
  59
  60 HLIST_HEAD(x25_list);
  61 DEFINE_RWLOCK(x25_list_lock);
  62
  63 static struct proto_ops x25_proto_ops;
  64
  65 static struct x25_address null_x25_address = {"               "};
  66
  67 int x25_addr_ntoa(unsigned char *p, struct x25_address *called_addr,
  68                   struct x25_address *calling_addr)
  69 {
  70         int called_len, calling_len;
  71         char *called, *calling;
  72         int i;
  73
  74         called_len  = (*p >> 0) & 0x0F;
  75         calling_len = (*p >> 4) & 0x0F;
  76
  77         called  = called_addr->x25_addr;
  78         calling = calling_addr->x25_addr;
  79         p++;
  80
  81         for (i = 0; i < (called_len + calling_len); i++) {
  82                 if (i < called_len) {
  83                         if (i % 2 != 0) {
  84                                 *called++ = ((*p >> 0) & 0x0F) + '0';
  85                                 p++;
  86                         } else {
  87                                 *called++ = ((*p >> 4) & 0x0F) + '0';
  88                         }
  89                 } else {
  90                         if (i % 2 != 0) {
  91                                 *calling++ = ((*p >> 0) & 0x0F) + '0';
  92                                 p++;
  93                         } else {
  94                                 *calling++ = ((*p >> 4) & 0x0F) + '0';
  95                         }
  96                 }
  97         }
  98
  99         *called = *calling = '\0';
 100
 101         return 1 + (called_len + calling_len + 1) / 2;
 102 }
 103
 104 int x25_addr_aton(unsigned char *p, struct x25_address *called_addr,
 105                   struct x25_address *calling_addr)
 106 {
 107         unsigned int called_len, calling_len;
 108         char *called, *calling;
 109         int i;
 110
 111         called  = called_addr->x25_addr;
 112         calling = calling_addr->x25_addr;
 113
 114         called_len  = strlen(called);
 115         calling_len = strlen(calling);
 116
 117         *p++ = (calling_len << 4) | (called_len << 0);
 118
 119         for (i = 0; i < (called_len + calling_len); i++) {
 120                 if (i < called_len) {
 121                         if (i % 2 != 0) {
 122                                 *p |= (*called++ - '0') << 0;
 123                                 p++;
 124                         } else {
 125                                 *p = 0x00;
 126                                 *p |= (*called++ - '0') << 4;
 127                         }
 128                 } else {
 129                         if (i % 2 != 0) {
 130                                 *p |= (*calling++ - '0') << 0;
 131                                 p++;
 132                         } else {
 133                                 *p = 0x00;
 134                                 *p |= (*calling++ - '0') << 4;
 135                         }
 136                 }
 137         }
 138
 139         return 1 + (called_len + calling_len + 1) / 2;
 140 }
 141
 142 /*
 143  *      Socket removal during an interrupt is now safe.
 144  */
 145 static void x25_remove_socket(struct sock *sk)
 146 {
 147         write_lock_bh(&x25_list_lock);
 148         sk_del_node_init(sk);
 149         write_unlock_bh(&x25_list_lock);
 150 }
 151
 152 /*
 153  *      Kill all bound sockets on a dropped device.
 154  */
 155 static void x25_kill_by_device(struct net_device *dev)
 156 {
 157         struct sock *s;
 158         struct hlist_node *node;
 159
 160         write_lock_bh(&x25_list_lock);
 161
 162         sk_for_each(s, node, &x25_list)
 163                 if (x25_sk(s)->neighbour && x25_sk(s)->neighbour->dev == dev)
 164                         x25_disconnect(s, ENETUNREACH, 0, 0);
 165
 166         write_unlock_bh(&x25_list_lock);
 167 }
 168
 169 /*
 170  *      Handle device status changes.
 171  */
 172 static int x25_device_event(struct notifier_block *this, unsigned long event,
 173                             void *ptr)
 174 {
 175         struct net_device *dev = ptr;
 176         struct x25_neigh *nb;
 177
 178         if (dev->type == ARPHRD_X25
 179 #if defined(CONFIG_LLC) || defined(CONFIG_LLC_MODULE)
 180          || dev->type == ARPHRD_ETHER
 181 #endif
 182          ) {
 183                 switch (event) {
 184                         case NETDEV_UP:
 185                                 x25_link_device_up(dev);
 186                                 break;
 187                         case NETDEV_GOING_DOWN:
 188                                 nb = x25_get_neigh(dev);
 189                                 if (nb) {
 190                                         x25_terminate_link(nb);
 191                                         x25_neigh_put(nb);
 192                                 }
 193                                 break;
 194                         case NETDEV_DOWN:
 195                                 x25_kill_by_device(dev);
 196                                 x25_route_device_down(dev);
 197                                 x25_link_device_down(dev);
 198                                 break;
 199                 }
 200         }
 201
 202         return NOTIFY_DONE;
 203 }
 204
 205 /*
 206  *      Add a socket to the bound sockets list.
 207  */
 208 static void x25_insert_socket(struct sock *sk)
 209 {
 210         write_lock_bh(&x25_list_lock);
 211         sk_add_node(sk, &x25_list);
 212         write_unlock_bh(&x25_list_lock);
 213 }
 214
 215 /*
 216  *      Find a socket that wants to accept the Call Request we just
 217  *      received. Check the full list for an address/cud match.
 218  *      If no cuds match return the next_best thing, an address match.
 219  *      Note: if a listening socket has cud set it must only get calls
 220  *      with matching cud.
 221  */
 222 static struct sock *x25_find_listener(struct x25_address *addr, struct x25_calluserdata *calluserdata)
 223 {
 224         struct sock *s;
 225         struct sock *next_best;
 226         struct hlist_node *node;
 227
 228         read_lock_bh(&x25_list_lock);
 229         next_best = NULL;
 230
 231         sk_for_each(s, node, &x25_list)
 232                 if ((!strcmp(addr->x25_addr,
 233                              x25_sk(s)->source_addr.x25_addr) ||
 234                      !strcmp(addr->x25_addr,
 235                              null_x25_address.x25_addr)) &&
 236                      s->sk_state == TCP_LISTEN) {
 237
 238                         /*
 239                          * Found a listening socket, now check the incoming
 240                          * call user data vs this sockets call user data
 241                          */
 242                         if (x25_check_calluserdata(&x25_sk(s)->calluserdata, calluserdata)) {
 243                                 sock_hold(s);
 244                                 goto found;
 245                         }
 246                         if (x25_sk(s)->calluserdata.cudlength == 0) {
 247                                 next_best = s;
 248                         }
 249                 }
 250         if (next_best) {
 251                 s = next_best;
 252                 sock_hold(s);
 253                 goto found;
 254         }
 255         s = NULL;
 256 found:
 257         read_unlock_bh(&x25_list_lock);
 258         return s;
 259 }
 260
 261 /*
 262  *      Find a connected X.25 socket given my LCI and neighbour.
 263  */
 264 static struct sock *__x25_find_socket(unsigned int lci, struct x25_neigh *nb)
 265 {
 266         struct sock *s;
 267         struct hlist_node *node;
 268
 269         sk_for_each(s, node, &x25_list)
 270                 if (x25_sk(s)->lci == lci && x25_sk(s)->neighbour == nb) {
 271                         sock_hold(s);
 272                         goto found;
 273                 }
 274         s = NULL;
 275 found:
 276         return s;
 277 }
 278
 279 struct sock *x25_find_socket(unsigned int lci, struct x25_neigh *nb)
 280 {
 281         struct sock *s;
 282
 283         read_lock_bh(&x25_list_lock);
 284         s = __x25_find_socket(lci, nb);
 285         read_unlock_bh(&x25_list_lock);
 286         return s;
 287 }
 288
 289 /*
 290  *      Find a unique LCI for a given device.
 291  */
 292 static unsigned int x25_new_lci(struct x25_neigh *nb)
 293 {
 294         unsigned int lci = 1;
 295         struct sock *sk;
 296
 297         read_lock_bh(&x25_list_lock);
 298
 299         while ((sk = __x25_find_socket(lci, nb)) != NULL) {
 300                 sock_put(sk);
 301                 if (++lci == 4096) {
 302                         lci = 0;
 303                         break;
 304                 }
 305         }
 306
 307         read_unlock_bh(&x25_list_lock);
 308         return lci;
 309 }
 310
 311 /*
 312  *      Deferred destroy.
 313  */
 314 void x25_destroy_socket(struct sock *);
 315
 316 /*
 317  *      handler for deferred kills.
 318  */
 319 static void x25_destroy_timer(unsigned long data)
 320 {
 321         x25_destroy_socket((struct sock *)data);
 322 }
 323
 324 /*
 325  *      This is called from user mode and the timers. Thus it protects itself
 326  *      against interrupt users but doesn't worry about being called during
 327  *      work. Once it is removed from the queue no interrupt or bottom half
 328  *      will touch it and we are (fairly 8-) ) safe.
 329  *      Not static as it's used by the timer
 330  */
 331 void x25_destroy_socket(struct sock *sk)
 332 {
 333         struct sk_buff *skb;
 334
 335         sock_hold(sk);
 336         lock_sock(sk);
 337         x25_stop_heartbeat(sk);
 338         x25_stop_timer(sk);
 339
 340         x25_remove_socket(sk);
 341         x25_clear_queues(sk);           /* Flush the queues */
 342
 343         while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
 344                 if (skb->sk != sk) {            /* A pending connection */
 345                         /*
 346                          * Queue the unaccepted socket for death
 347                          */
 348                         sock_set_flag(skb->sk, SOCK_DEAD);
 349                         x25_start_heartbeat(skb->sk);
 350                         x25_sk(skb->sk)->state = X25_STATE_0;
 351                 }
 352
 353                 kfree_skb(skb);
 354         }
 355
 356         if (atomic_read(&sk->sk_wmem_alloc) ||
 357             atomic_read(&sk->sk_rmem_alloc)) {
 358                 /* Defer: outstanding buffers */
 359                 sk->sk_timer.expires  = jiffies + 10 * HZ;
 360                 sk->sk_timer.function = x25_destroy_timer;
 361                 sk->sk_timer.data = (unsigned long)sk;
 362                 add_timer(&sk->sk_timer);
 363         } else {
 364                 /* drop last reference so sock_put will free */
 365                 __sock_put(sk);
 366         }
 367
 368         release_sock(sk);
 369         sock_put(sk);
 370 }
 371
 372 /*
 373  *      Handling for system calls applied via the various interfaces to a
 374  *      X.25 socket object.
 375  */
 376
 377 static int x25_setsockopt(struct socket *sock, int level, int optname,
 378                           char __user *optval, int optlen)
 379 {
 380         int opt;
 381         struct sock *sk = sock->sk;
 382         int rc = -ENOPROTOOPT;
 383
 384         if (level != SOL_X25 || optname != X25_QBITINCL)
 385                 goto out;
 386
 387         rc = -EINVAL;
 388         if (optlen < sizeof(int))
 389                 goto out;
 390
 391         rc = -EFAULT;
 392         if (get_user(opt, (int __user *)optval))
 393                 goto out;
 394
 395         x25_sk(sk)->qbitincl = !!opt;
 396         rc = 0;
 397 out:
 398         return rc;
 399 }
 400
 401 static int x25_getsockopt(struct socket *sock, int level, int optname,
 402                           char __user *optval, int __user *optlen)
 403 {
 404         struct sock *sk = sock->sk;
 405         int val, len, rc = -ENOPROTOOPT;
 406
 407         if (level != SOL_X25 || optname != X25_QBITINCL)
 408                 goto out;
 409
 410         rc = -EFAULT;
 411         if (get_user(len, optlen))
 412                 goto out;
 413
 414         len = min_t(unsigned int, len, sizeof(int));
 415
 416         rc = -EINVAL;
 417         if (len < 0)
 418                 goto out;
 419
 420         rc = -EFAULT;
 421         if (put_user(len, optlen))
 422                 goto out;
 423
 424         val = x25_sk(sk)->qbitincl;
 425         rc = copy_to_user(optval, &val, len) ? -EFAULT : 0;
 426 out:
 427         return rc;
 428 }
 429
 430 static int x25_listen(struct socket *sock, int backlog)
 431 {
 432         struct sock *sk = sock->sk;
 433         int rc = -EOPNOTSUPP;
 434
 435         if (sk->sk_state != TCP_LISTEN) {
 436                 memset(&x25_sk(sk)->dest_addr, 0, X25_ADDR_LEN);
 437                 sk->sk_max_ack_backlog = backlog;
 438                 sk->sk_state           = TCP_LISTEN;
 439                 rc = 0;
 440         }
 441
 442         return rc;
 443 }
 444
 445 static struct proto x25_proto = {
 446         .name     = "X25",
 447         .owner    = THIS_MODULE,
 448         .obj_size = sizeof(struct x25_sock),
 449 };
 450
 451 static struct sock *x25_alloc_socket(void)
 452 {
 453         struct x25_sock *x25;
 454         struct sock *sk = sk_alloc(AF_X25, GFP_ATOMIC, &x25_proto, 1);
 455
 456         if (!sk)
 457                 goto out;
 458
 459         sock_init_data(NULL, sk);
 460
 461         x25 = x25_sk(sk);
 462         skb_queue_head_init(&x25->ack_queue);
 463         skb_queue_head_init(&x25->fragment_queue);
 464         skb_queue_head_init(&x25->interrupt_in_queue);
 465         skb_queue_head_init(&x25->interrupt_out_queue);
 466 out:
 467         return sk;
 468 }
 469
 470 void x25_init_timers(struct sock *sk);
 471
 472 static int x25_create(struct socket *sock, int protocol)
 473 {
 474         struct sock *sk;
 475         struct x25_sock *x25;
 476         int rc = -ESOCKTNOSUPPORT;
 477
 478         if (sock->type != SOCK_SEQPACKET || protocol)
 479                 goto out;
 480
 481         rc = -ENOMEM;
 482         if ((sk = x25_alloc_socket()) == NULL)
 483                 goto out;
 484
 485         x25 = x25_sk(sk);
 486
 487         sk->sk_socket = sock;
 488         sk->sk_type = sock->type;
 489         sk->sk_sleep = &sock->wait;
 490         sock->sk = sk;
 491
 492         x25_init_timers(sk);
 493
 494         sock->ops    = &x25_proto_ops;
 495         sk->sk_protocol = protocol;
 496         sk->sk_backlog_rcv = x25_backlog_rcv;
 497
 498         x25->t21   = sysctl_x25_call_request_timeout;
 499         x25->t22   = sysctl_x25_reset_request_timeout;
 500         x25->t23   = sysctl_x25_clear_request_timeout;
 501         x25->t2    = sysctl_x25_ack_holdback_timeout;
 502         x25->state = X25_STATE_0;
 503
 504         x25->facilities.winsize_in  = X25_DEFAULT_WINDOW_SIZE;
 505         x25->facilities.winsize_out = X25_DEFAULT_WINDOW_SIZE;
 506         x25->facilities.pacsize_in  = X25_DEFAULT_PACKET_SIZE;
 507         x25->facilities.pacsize_out = X25_DEFAULT_PACKET_SIZE;
 508         x25->facilities.throughput  = X25_DEFAULT_THROUGHPUT;
 509         x25->facilities.reverse     = X25_DEFAULT_REVERSE;
 510         rc = 0;
 511 out:
 512         return rc;
 513 }
 514
 515 static struct sock *x25_make_new(struct sock *osk)
 516 {
 517         struct sock *sk = NULL;
 518         struct x25_sock *x25, *ox25;
 519
 520         if (osk->sk_type != SOCK_SEQPACKET)
 521                 goto out;
 522
 523         if ((sk = x25_alloc_socket()) == NULL)
 524                 goto out;
 525
 526         x25 = x25_sk(sk);
 527
 528         sk->sk_type        = osk->sk_type;
 529         sk->sk_socket      = osk->sk_socket;
 530         sk->sk_priority    = osk->sk_priority;
 531         sk->sk_protocol    = osk->sk_protocol;
 532         sk->sk_rcvbuf      = osk->sk_rcvbuf;
 533         sk->sk_sndbuf      = osk->sk_sndbuf;
 534         sk->sk_state       = TCP_ESTABLISHED;
 535         sk->sk_sleep       = osk->sk_sleep;
 536         sk->sk_backlog_rcv = osk->sk_backlog_rcv;
 537
 538         if (sock_flag(osk, SOCK_ZAPPED))
 539                 sock_set_flag(sk, SOCK_ZAPPED);
 540
 541         if (sock_flag(osk, SOCK_DBG))
 542                 sock_set_flag(sk, SOCK_DBG);
 543
 544         ox25 = x25_sk(osk);
 545         x25->t21        = ox25->t21;
 546         x25->t22        = ox25->t22;
 547         x25->t23        = ox25->t23;
 548         x25->t2         = ox25->t2;
 549         x25->facilities = ox25->facilities;
 550         x25->qbitincl   = ox25->qbitincl;
 551
 552         x25_init_timers(sk);
 553 out:
 554         return sk;
 555 }
 556
 557 static int x25_release(struct socket *sock)
 558 {
 559         struct sock *sk = sock->sk;
 560         struct x25_sock *x25;
 561
 562         if (!sk)
 563                 goto out;
 564
 565         x25 = x25_sk(sk);
 566
 567         switch (x25->state) {
 568
 569                 case X25_STATE_0:
 570                 case X25_STATE_2:
 571                         x25_disconnect(sk, 0, 0, 0);
 572                         x25_destroy_socket(sk);
 573                         goto out;
 574
 575                 case X25_STATE_1:
 576                 case X25_STATE_3:
 577                 case X25_STATE_4:
 578                         x25_clear_queues(sk);
 579                         x25_write_internal(sk, X25_CLEAR_REQUEST);
 580                         x25_start_t23timer(sk);
 581                         x25->state = X25_STATE_2;
 582                         sk->sk_state    = TCP_CLOSE;
 583                         sk->sk_shutdown |= SEND_SHUTDOWN;
 584                         sk->sk_state_change(sk);
 585                         sock_set_flag(sk, SOCK_DEAD);
 586                         sock_set_flag(sk, SOCK_DESTROY);
 587                         break;
 588         }
 589
 590         sock->sk        = NULL;
 591         sk->sk_socket   = NULL; /* Not used, but we should do this */
 592 out:
 593         return 0;
 594 }
 595
 596 static int x25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
 597 {
 598         struct sock *sk = sock->sk;
 599         struct sockaddr_x25 *addr = (struct sockaddr_x25 *)uaddr;
 600
 601         if (!sock_flag(sk, SOCK_ZAPPED) ||
 602             addr_len != sizeof(struct sockaddr_x25) ||
 603             addr->sx25_family != AF_X25)
 604                 return -EINVAL;
 605
 606         x25_sk(sk)->source_addr = addr->sx25_addr;
 607         x25_insert_socket(sk);
 608         sock_reset_flag(sk, SOCK_ZAPPED);
 609         SOCK_DEBUG(sk, "x25_bind: socket is bound\n");
 610
 611         return 0;
 612 }
 613
 614 static int x25_wait_for_connection_establishment(struct sock *sk)
 615 {
 616         DECLARE_WAITQUEUE(wait, current);
 617         int rc;
 618
 619         add_wait_queue_exclusive(sk->sk_sleep, &wait);
 620         for (;;) {
 621                 __set_current_state(TASK_INTERRUPTIBLE);
 622                 rc = -ERESTARTSYS;
 623                 if (signal_pending(current))
 624                         break;
 625                 rc = sock_error(sk);
 626                 if (rc) {
 627                         sk->sk_socket->state = SS_UNCONNECTED;
 628                         break;
 629                 }
 630                 rc = 0;
 631                 if (sk->sk_state != TCP_ESTABLISHED) {
 632                         release_sock(sk);
 633                         schedule();
 634                         lock_sock(sk);
 635                 } else
 636                         break;
 637         }
 638         __set_current_state(TASK_RUNNING);
 639         remove_wait_queue(sk->sk_sleep, &wait);
 640         return rc;
 641 }
 642
 643 static int x25_connect(struct socket *sock, struct sockaddr *uaddr,
 644                        int addr_len, int flags)
 645 {
 646         struct sock *sk = sock->sk;
 647         struct x25_sock *x25 = x25_sk(sk);
 648         struct sockaddr_x25 *addr = (struct sockaddr_x25 *)uaddr;
 649         struct x25_route *rt;
 650         int rc = 0;
 651
 652         lock_sock(sk);
 653         if (sk->sk_state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
 654                 sock->state = SS_CONNECTED;
 655                 goto out; /* Connect completed during a ERESTARTSYS event */
 656         }
 657
 658         rc = -ECONNREFUSED;
 659         if (sk->sk_state == TCP_CLOSE && sock->state == SS_CONNECTING) {
 660                 sock->state = SS_UNCONNECTED;
 661                 goto out;
 662         }
 663
 664         rc = -EISCONN;  /* No reconnect on a seqpacket socket */
 665         if (sk->sk_state == TCP_ESTABLISHED)
 666                 goto out;
 667
 668         sk->sk_state   = TCP_CLOSE;
 669         sock->state = SS_UNCONNECTED;
 670
 671         rc = -EINVAL;
 672         if (addr_len != sizeof(struct sockaddr_x25) ||
 673             addr->sx25_family != AF_X25)
 674                 goto out;
 675
 676         rc = -ENETUNREACH;
 677         rt = x25_get_route(&addr->sx25_addr);
 678         if (!rt)
 679                 goto out;
 680
 681         x25->neighbour = x25_get_neigh(rt->dev);
 682         if (!x25->neighbour)
 683                 goto out_put_route;
 684
 685         x25_limit_facilities(&x25->facilities, x25->neighbour);
 686
 687         x25->lci = x25_new_lci(x25->neighbour);
 688         if (!x25->lci)
 689                 goto out_put_neigh;
 690
 691         rc = -EINVAL;
 692         if (sock_flag(sk, SOCK_ZAPPED)) /* Must bind first - autobinding does not work */
 693                 goto out_put_neigh;
 694
 695         if (!strcmp(x25->source_addr.x25_addr, null_x25_address.x25_addr))
 696                 memset(&x25->source_addr, '\0', X25_ADDR_LEN);
 697
 698         x25->dest_addr = addr->sx25_addr;
 699
 700         /* Move to connecting socket, start sending Connect Requests */
 701         sock->state   = SS_CONNECTING;
 702         sk->sk_state  = TCP_SYN_SENT;
 703
 704         x25->state = X25_STATE_1;
 705
 706         x25_write_internal(sk, X25_CALL_REQUEST);
 707
 708         x25_start_heartbeat(sk);
 709         x25_start_t21timer(sk);
 710
 711         /* Now the loop */
 712         rc = -EINPROGRESS;
 713         if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
 714                 goto out_put_neigh;
 715
 716         rc = x25_wait_for_connection_establishment(sk);
 717         if (rc)
 718                 goto out_put_neigh;
 719
 720         sock->state = SS_CONNECTED;
 721         rc = 0;
 722 out_put_neigh:
 723         if (rc)
 724                 x25_neigh_put(x25->neighbour);
 725 out_put_route:
 726         x25_route_put(rt);
 727 out:
 728         release_sock(sk);
 729         return rc;
 730 }
 731
 732 static int x25_wait_for_data(struct sock *sk, int timeout)
 733 {
 734         DECLARE_WAITQUEUE(wait, current);
 735         int rc = 0;
 736
 737         add_wait_queue_exclusive(sk->sk_sleep, &wait);
 738         for (;;) {
 739                 __set_current_state(TASK_INTERRUPTIBLE);
 740                 if (sk->sk_shutdown & RCV_SHUTDOWN)
 741                         break;
 742                 rc = -ERESTARTSYS;
 743                 if (signal_pending(current))
 744                         break;
 745                 rc = -EAGAIN;
 746                 if (!timeout)
 747                         break;
 748                 rc = 0;
 749                 if (skb_queue_empty(&sk->sk_receive_queue)) {
 750                         release_sock(sk);
 751                         timeout = schedule_timeout(timeout);
 752                         lock_sock(sk);
 753                 } else
 754                         break;
 755         }
 756         __set_current_state(TASK_RUNNING);
 757         remove_wait_queue(sk->sk_sleep, &wait);
 758         return rc;
 759 }
 760
 761 static int x25_accept(struct socket *sock, struct socket *newsock, int flags)
 762 {
 763         struct sock *sk = sock->sk;
 764         struct sock *newsk;
 765         struct sk_buff *skb;
 766         int rc = -EINVAL;
 767
 768         if (!sk || sk->sk_state != TCP_LISTEN)
 769                 goto out;
 770
 771         rc = -EOPNOTSUPP;
 772         if (sk->sk_type != SOCK_SEQPACKET)
 773                 goto out;
 774
 775         lock_sock(sk);
 776         rc = x25_wait_for_data(sk, sk->sk_rcvtimeo);
 777         if (rc)
 778                 goto out2;
 779         skb = skb_dequeue(&sk->sk_receive_queue);
 780         rc = -EINVAL;
 781         if (!skb->sk)
 782                 goto out2;
 783         newsk            = skb->sk;
 784         newsk->sk_socket = newsock;
 785         newsk->sk_sleep  = &newsock->wait;
 786
 787         /* Now attach up the new socket */
 788         skb->sk = NULL;
 789         kfree_skb(skb);
 790         sk->sk_ack_backlog--;
 791         newsock->sk    = newsk;
 792         newsock->state = SS_CONNECTED;
 793         rc = 0;
 794 out2:
 795         release_sock(sk);
 796 out:
 797         return rc;
 798 }
 799
 800 static int x25_getname(struct socket *sock, struct sockaddr *uaddr,
 801                        int *uaddr_len, int peer)
 802 {
 803         struct sockaddr_x25 *sx25 = (struct sockaddr_x25 *)uaddr;
 804         struct sock *sk = sock->sk;
 805         struct x25_sock *x25 = x25_sk(sk);
 806
 807         if (peer) {
 808                 if (sk->sk_state != TCP_ESTABLISHED)
 809                         return -ENOTCONN;
 810                 sx25->sx25_addr = x25->dest_addr;
 811         } else
 812                 sx25->sx25_addr = x25->source_addr;
 813
 814         sx25->sx25_family = AF_X25;
 815         *uaddr_len = sizeof(*sx25);
 816
 817         return 0;
 818 }
 819
 820 int x25_rx_call_request(struct sk_buff *skb, struct x25_neigh *nb,
 821                         unsigned int lci)
 822 {
 823         struct sock *sk;
 824         struct sock *make;
 825         struct x25_sock *makex25;
 826         struct x25_address source_addr, dest_addr;
 827         struct x25_facilities facilities;
 828         struct x25_calluserdata calluserdata;
 829         int len, rc;
 830
 831         /*
 832          *      Remove the LCI and frame type.
 833          */
 834         skb_pull(skb, X25_STD_MIN_LEN);
 835
 836         /*
 837          *      Extract the X.25 addresses and convert them to ASCII strings,
 838          *      and remove them.
 839          */
 840         skb_pull(skb, x25_addr_ntoa(skb->data, &source_addr, &dest_addr));
 841
 842         /*
 843          *      Get the length of the facilities, skip past them for the moment
 844          *      get the call user data because this is needed to determine
 845          *      the correct listener
 846          */
 847         len = skb->data[0] + 1;
 848         skb_pull(skb,len);
 849
 850         /*
 851          *      Incoming Call User Data.
 852          */
 853         if (skb->len >= 0) {
 854                 memcpy(calluserdata.cuddata, skb->data, skb->len);
 855                 calluserdata.cudlength = skb->len;
 856         }
 857
 858         skb_push(skb,len);
 859
 860         /*
 861          *      Find a listener for the particular address/cud pair.
 862          */
 863         sk = x25_find_listener(&source_addr,&calluserdata);
 864
 865         /*
 866          *      We can't accept the Call Request.
 867          */
 868         if (sk == NULL || sk_acceptq_is_full(sk))
 869                 goto out_clear_request;
 870
 871         /*
 872          *      Try to reach a compromise on the requested facilities.
 873          */
 874         if ((len = x25_negotiate_facilities(skb, sk, &facilities)) == -1)
 875                 goto out_sock_put;
 876
 877         /*
 878          * current neighbour/link might impose additional limits
 879          * on certain facilties
 880          */
 881
 882         x25_limit_facilities(&facilities, nb);
 883
 884         /*
 885          *      Try to create a new socket.
 886          */
 887         make = x25_make_new(sk);
 888         if (!make)
 889                 goto out_sock_put;
 890
 891         /*
 892          *      Remove the facilities
 893          */
 894         skb_pull(skb, len);
 895
 896         skb->sk     = make;
 897         make->sk_state = TCP_ESTABLISHED;
 898
 899         makex25 = x25_sk(make);
 900         makex25->lci           = lci;
 901         makex25->dest_addr     = dest_addr;
 902         makex25->source_addr   = source_addr;
 903         makex25->neighbour     = nb;
 904         makex25->facilities    = facilities;
 905         makex25->vc_facil_mask = x25_sk(sk)->vc_facil_mask;
 906         makex25->calluserdata  = calluserdata;
 907
 908         x25_write_internal(make, X25_CALL_ACCEPTED);
 909
 910         makex25->state = X25_STATE_3;
 911
 912         sk->sk_ack_backlog++;
 913
 914         x25_insert_socket(make);
 915
 916         skb_queue_head(&sk->sk_receive_queue, skb);
 917
 918         x25_start_heartbeat(make);
 919
 920         if (!sock_flag(sk, SOCK_DEAD))
 921                 sk->sk_data_ready(sk, skb->len);
 922         rc = 1;
 923         sock_put(sk);
 924 out:
 925         return rc;
 926 out_sock_put:
 927         sock_put(sk);
 928 out_clear_request:
 929         rc = 0;
 930         x25_transmit_clear_request(nb, lci, 0x01);
 931         goto out;
 932 }
 933
 934 static int x25_sendmsg(struct kiocb *iocb, struct socket *sock,
 935                        struct msghdr *msg, size_t len)
 936 {
 937         struct sock *sk = sock->sk;
 938         struct x25_sock *x25 = x25_sk(sk);
 939         struct sockaddr_x25 *usx25 = (struct sockaddr_x25 *)msg->msg_name;
 940         struct sockaddr_x25 sx25;
 941         struct sk_buff *skb;
 942         unsigned char *asmptr;
 943         int noblock = msg->msg_flags & MSG_DONTWAIT;
 944         size_t size;
 945         int qbit = 0, rc = -EINVAL;
 946
 947         if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_OOB|MSG_EOR|MSG_CMSG_COMPAT))
 948                 goto out;
 949
 950         /* we currently don't support segmented records at the user interface */
 951         if (!(msg->msg_flags & (MSG_EOR|MSG_OOB)))
 952                 goto out;
 953
 954         rc = -EADDRNOTAVAIL;
 955         if (sock_flag(sk, SOCK_ZAPPED))
 956                 goto out;
 957
 958         rc = -EPIPE;
 959         if (sk->sk_shutdown & SEND_SHUTDOWN) {
 960                 send_sig(SIGPIPE, current, 0);
 961                 goto out;
 962         }
 963
 964         rc = -ENETUNREACH;
 965         if (!x25->neighbour)
 966                 goto out;
 967
 968         if (usx25) {
 969                 rc = -EINVAL;
 970                 if (msg->msg_namelen < sizeof(sx25))
 971                         goto out;
 972                 memcpy(&sx25, usx25, sizeof(sx25));
 973                 rc = -EISCONN;
 974                 if (strcmp(x25->dest_addr.x25_addr, sx25.sx25_addr.x25_addr))
 975                         goto out;
 976                 rc = -EINVAL;
 977                 if (sx25.sx25_family != AF_X25)
 978                         goto out;
 979         } else {
 980                 /*
 981                  *      FIXME 1003.1g - if the socket is like this because
 982                  *      it has become closed (not started closed) we ought
 983                  *      to SIGPIPE, EPIPE;
 984                  */
 985                 rc = -ENOTCONN;
 986                 if (sk->sk_state != TCP_ESTABLISHED)
 987                         goto out;
 988
 989                 sx25.sx25_family = AF_X25;
 990                 sx25.sx25_addr   = x25->dest_addr;
 991         }
 992
 993         SOCK_DEBUG(sk, "x25_sendmsg: sendto: Addresses built.\n");
 994
 995         /* Build a packet */
 996         SOCK_DEBUG(sk, "x25_sendmsg: sendto: building packet.\n");
 997
 998         if ((msg->msg_flags & MSG_OOB) && len > 32)
 999                 len = 32;
1000
1001         size = len + X25_MAX_L2_LEN + X25_EXT_MIN_LEN;
1002
1003         skb = sock_alloc_send_skb(sk, size, noblock, &rc);
1004         if (!skb)
1005                 goto out;
1006         X25_SKB_CB(skb)->flags = msg->msg_flags;
1007
1008         skb_reserve(skb, X25_MAX_L2_LEN + X25_EXT_MIN_LEN);
1009
1010         /*
1011          *      Put the data on the end
1012          */
1013         SOCK_DEBUG(sk, "x25_sendmsg: Copying user data\n");
1014
1015         asmptr = skb->h.raw = skb_put(skb, len);
1016
1017         rc = memcpy_fromiovec(asmptr, msg->msg_iov, len);
1018         if (rc)
1019                 goto out_kfree_skb;
1020
1021         /*
1022          *      If the Q BIT Include socket option is in force, the first
1023          *      byte of the user data is the logical value of the Q Bit.
1024          */
1025         if (x25->qbitincl) {
1026                 qbit = skb->data[0];
1027                 skb_pull(skb, 1);
1028         }
1029
1030         /*
1031          *      Push down the X.25 header
1032          */
1033         SOCK_DEBUG(sk, "x25_sendmsg: Building X.25 Header.\n");
1034
1035         if (msg->msg_flags & MSG_OOB) {
1036                 if (x25->neighbour->extended) {
1037                         asmptr    = skb_push(skb, X25_STD_MIN_LEN);
1038                         *asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_EXTSEQ;
1039                         *asmptr++ = (x25->lci >> 0) & 0xFF;
1040                         *asmptr++ = X25_INTERRUPT;
1041                 } else {
1042                         asmptr    = skb_push(skb, X25_STD_MIN_LEN);
1043                         *asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_STDSEQ;
1044                         *asmptr++ = (x25->lci >> 0) & 0xFF;
1045                         *asmptr++ = X25_INTERRUPT;
1046                 }
1047         } else {
1048                 if (x25->neighbour->extended) {
1049                         /* Build an Extended X.25 header */
1050                         asmptr    = skb_push(skb, X25_EXT_MIN_LEN);
1051                         *asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_EXTSEQ;
1052                         *asmptr++ = (x25->lci >> 0) & 0xFF;
1053                         *asmptr++ = X25_DATA;
1054                         *asmptr++ = X25_DATA;
1055                 } else {
1056                         /* Build an Standard X.25 header */
1057                         asmptr    = skb_push(skb, X25_STD_MIN_LEN);
1058                         *asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_STDSEQ;
1059                         *asmptr++ = (x25->lci >> 0) & 0xFF;
1060                         *asmptr++ = X25_DATA;
1061                 }
1062
1063                 if (qbit)
1064                         skb->data[0] |= X25_Q_BIT;
1065         }
1066
1067         SOCK_DEBUG(sk, "x25_sendmsg: Built header.\n");
1068         SOCK_DEBUG(sk, "x25_sendmsg: Transmitting buffer\n");
1069
1070         rc = -ENOTCONN;
1071         if (sk->sk_state != TCP_ESTABLISHED)
1072                 goto out_kfree_skb;
1073
1074         if (msg->msg_flags & MSG_OOB)
1075                 skb_queue_tail(&x25->interrupt_out_queue, skb);
1076         else {
1077                 len = x25_output(sk, skb);
1078                 if (len < 0)
1079                         kfree_skb(skb);
1080                 else if (x25->qbitincl)
1081                         len++;
1082         }
1083
1084         /*
1085          * lock_sock() is currently only used to serialize this x25_kick()
1086          * against input-driven x25_kick() calls. It currently only blocks
1087          * incoming packets for this socket and does not protect against
1088          * any other socket state changes and is not called from anywhere
1089          * else. As x25_kick() cannot block and as long as all socket
1090          * operations are BKL-wrapped, we don't need take to care about
1091          * purging the backlog queue in x25_release().
1092          *
1093          * Using lock_sock() to protect all socket operations entirely
1094          * (and making the whole x25 stack SMP aware) unfortunately would
1095          * require major changes to {send,recv}msg and skb allocation methods.
1096          * -> 2.5 ;)
1097          */
1098         lock_sock(sk);
1099         x25_kick(sk);
1100         release_sock(sk);
1101         rc = len;
1102 out:
1103         return rc;
1104 out_kfree_skb:
1105         kfree_skb(skb);
1106         goto out;
1107 }
1108
1109
1110 static int x25_recvmsg(struct kiocb *iocb, struct socket *sock,
1111                        struct msghdr *msg, size_t size,
1112                        int flags)
1113 {
1114         struct sock *sk = sock->sk;
1115         struct x25_sock *x25 = x25_sk(sk);
1116         struct sockaddr_x25 *sx25 = (struct sockaddr_x25 *)msg->msg_name;
1117         size_t copied;
1118         int qbit;
1119         struct sk_buff *skb;
1120         unsigned char *asmptr;
1121         int rc = -ENOTCONN;
1122
1123         /*
1124          * This works for seqpacket too. The receiver has ordered the queue for
1125          * us! We do one quick check first though
1126          */
1127         if (sk->sk_state != TCP_ESTABLISHED)
1128                 goto out;
1129
1130         if (flags & MSG_OOB) {
1131                 rc = -EINVAL;
1132                 if (sock_flag(sk, SOCK_URGINLINE) ||
1133                     !skb_peek(&x25->interrupt_in_queue))
1134                         goto out;
1135
1136                 skb = skb_dequeue(&x25->interrupt_in_queue);
1137
1138                 skb_pull(skb, X25_STD_MIN_LEN);
1139
1140                 /*
1141                  *      No Q bit information on Interrupt data.
1142                  */
1143                 if (x25->qbitincl) {
1144                         asmptr  = skb_push(skb, 1);
1145                         *asmptr = 0x00;
1146                 }
1147
1148                 msg->msg_flags |= MSG_OOB;
1149         } else {
1150                 /* Now we can treat all alike */
1151                 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1152                                         flags & MSG_DONTWAIT, &rc);
1153                 if (!skb)
1154                         goto out;
1155
1156                 qbit = (skb->data[0] & X25_Q_BIT) == X25_Q_BIT;
1157
1158                 skb_pull(skb, x25->neighbour->extended ?
1159                                 X25_EXT_MIN_LEN : X25_STD_MIN_LEN);
1160
1161                 if (x25->qbitincl) {
1162                         asmptr  = skb_push(skb, 1);
1163                         *asmptr = qbit;
1164                 }
1165         }
1166
1167         skb->h.raw = skb->data;
1168
1169         copied = skb->len;
1170
1171         if (copied > size) {
1172                 copied = size;
1173                 msg->msg_flags |= MSG_TRUNC;
1174         }
1175
1176         /* Currently, each datagram always contains a complete record */
1177         msg->msg_flags |= MSG_EOR;
1178
1179         rc = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1180         if (rc)
1181                 goto out_free_dgram;
1182
1183         if (sx25) {
1184                 sx25->sx25_family = AF_X25;
1185                 sx25->sx25_addr   = x25->dest_addr;
1186         }
1187
1188         msg->msg_namelen = sizeof(struct sockaddr_x25);
1189
1190         lock_sock(sk);
1191         x25_check_rbuf(sk);
1192         release_sock(sk);
1193         rc = copied;
1194 out_free_dgram:
1195         skb_free_datagram(sk, skb);
1196 out:
1197         return rc;
1198 }
1199
1200
1201 static int x25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1202 {
1203         struct sock *sk = sock->sk;
1204         struct x25_sock *x25 = x25_sk(sk);
1205         void __user *argp = (void __user *)arg;
1206         int rc;
1207
1208         switch (cmd) {
1209                 case TIOCOUTQ: {
1210                         int amount = sk->sk_sndbuf -
1211                                      atomic_read(&sk->sk_wmem_alloc);
1212                         if (amount < 0)
1213                                 amount = 0;
1214                         rc = put_user(amount, (unsigned int __user *)argp);
1215                         break;
1216                 }
1217
1218                 case TIOCINQ: {
1219                         struct sk_buff *skb;
1220                         int amount = 0;
1221                         /*
1222                          * These two are safe on a single CPU system as
1223                          * only user tasks fiddle here
1224                          */
1225                         if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1226                                 amount = skb->len;
1227                         rc = put_user(amount, (unsigned int __user *)argp);
1228                         break;
1229                 }
1230
1231                 case SIOCGSTAMP:
1232                         rc = -EINVAL;
1233                         if (sk)
1234                                 rc = sock_get_timestamp(sk,
1235                                                 (struct timeval __user *)argp);
1236                         break;
1237                 case SIOCGIFADDR:
1238                 case SIOCSIFADDR:
1239                 case SIOCGIFDSTADDR:
1240                 case SIOCSIFDSTADDR:
1241                 case SIOCGIFBRDADDR:
1242                 case SIOCSIFBRDADDR:
1243                 case SIOCGIFNETMASK:
1244                 case SIOCSIFNETMASK:
1245                 case SIOCGIFMETRIC:
1246                 case SIOCSIFMETRIC:
1247                         rc = -EINVAL;
1248                         break;
1249                 case SIOCADDRT:
1250                 case SIOCDELRT:
1251                         rc = -EPERM;
1252                         if (!capable(CAP_NET_ADMIN))
1253                                 break;
1254                         rc = x25_route_ioctl(cmd, argp);
1255                         break;
1256                 case SIOCX25GSUBSCRIP:
1257                         rc = x25_subscr_ioctl(cmd, argp);
1258                         break;
1259                 case SIOCX25SSUBSCRIP:
1260                         rc = -EPERM;
1261                         if (!capable(CAP_NET_ADMIN))
1262                                 break;
1263                         rc = x25_subscr_ioctl(cmd, argp);
1264                         break;
1265                 case SIOCX25GFACILITIES: {
1266                         struct x25_facilities fac = x25->facilities;
1267                         rc = copy_to_user(argp, &fac,
1268                                           sizeof(fac)) ? -EFAULT : 0;
1269                         break;
1270                 }
1271
1272                 case SIOCX25SFACILITIES: {
1273                         struct x25_facilities facilities;
1274                         rc = -EFAULT;
1275                         if (copy_from_user(&facilities, argp,
1276                                            sizeof(facilities)))
1277                                 break;
1278                         rc = -EINVAL;
1279                         if (sk->sk_state != TCP_LISTEN &&
1280                             sk->sk_state != TCP_CLOSE)
1281                                 break;
1282                         if (facilities.pacsize_in < X25_PS16 ||
1283                             facilities.pacsize_in > X25_PS4096)
1284                                 break;
1285                         if (facilities.pacsize_out < X25_PS16 ||
1286                             facilities.pacsize_out > X25_PS4096)
1287                                 break;
1288                         if (facilities.winsize_in < 1 ||
1289                             facilities.winsize_in > 127)
1290                                 break;
1291                         if (facilities.throughput < 0x03 ||
1292                             facilities.throughput > 0xDD)
1293                                 break;
1294                         if (facilities.reverse && facilities.reverse != 1)
1295                                 break;
1296                         x25->facilities = facilities;
1297                         rc = 0;
1298                         break;
1299                 }
1300
1301                 case SIOCX25GCALLUSERDATA: {
1302                         struct x25_calluserdata cud = x25->calluserdata;
1303                         rc = copy_to_user(argp, &cud,
1304                                           sizeof(cud)) ? -EFAULT : 0;
1305                         break;
1306                 }
1307
1308                 case SIOCX25SCALLUSERDATA: {
1309                         struct x25_calluserdata calluserdata;
1310
1311                         rc = -EFAULT;
1312                         if (copy_from_user(&calluserdata, argp,
1313                                            sizeof(calluserdata)))
1314                                 break;
1315                         rc = -EINVAL;
1316                         if (calluserdata.cudlength > X25_MAX_CUD_LEN)
1317                                 break;
1318                         x25->calluserdata = calluserdata;
1319                         rc = 0;
1320                         break;
1321                 }
1322
1323                 case SIOCX25GCAUSEDIAG: {
1324                         struct x25_causediag causediag;
1325                         causediag = x25->causediag;
1326                         rc = copy_to_user(argp, &causediag,
1327                                           sizeof(causediag)) ? -EFAULT : 0;
1328                         break;
1329                 }
1330
1331                 default:
1332                         rc = dev_ioctl(cmd, argp);
1333                         break;
1334         }
1335
1336         return rc;
1337 }
1338
1339 static struct net_proto_family x25_family_ops = {
1340         .family =       AF_X25,
1341         .create =       x25_create,
1342         .owner  =       THIS_MODULE,
1343 };
1344
1345 static struct proto_ops SOCKOPS_WRAPPED(x25_proto_ops) = {
1346         .family =       AF_X25,
1347         .owner =        THIS_MODULE,
1348         .release =      x25_release,
1349         .bind =         x25_bind,
1350         .connect =      x25_connect,
1351         .socketpair =   sock_no_socketpair,
1352         .accept =       x25_accept,
1353         .getname =      x25_getname,
1354         .poll =         datagram_poll,
1355         .ioctl =        x25_ioctl,
1356         .listen =       x25_listen,
1357         .shutdown =     sock_no_shutdown,
1358         .setsockopt =   x25_setsockopt,
1359         .getsockopt =   x25_getsockopt,
1360         .sendmsg =      x25_sendmsg,
1361         .recvmsg =      x25_recvmsg,
1362         .mmap =         sock_no_mmap,
1363         .sendpage =     sock_no_sendpage,
1364 };
1365
1366 #include <linux/smp_lock.h>
1367 SOCKOPS_WRAP(x25_proto, AF_X25);
1368
1369 static struct packet_type x25_packet_type = {
1370         .type = __constant_htons(ETH_P_X25),
1371         .func = x25_lapb_receive_frame,
1372 };
1373
1374 static struct notifier_block x25_dev_notifier = {
1375         .notifier_call = x25_device_event,
1376 };
1377
1378 void x25_kill_by_neigh(struct x25_neigh *nb)
1379 {
1380         struct sock *s;
1381         struct hlist_node *node;
1382
1383         write_lock_bh(&x25_list_lock);
1384
1385         sk_for_each(s, node, &x25_list)
1386                 if (x25_sk(s)->neighbour == nb)
1387                         x25_disconnect(s, ENETUNREACH, 0, 0);
1388
1389         write_unlock_bh(&x25_list_lock);
1390 }
1391
1392 static int __init x25_init(void)
1393 {
1394         int rc = proto_register(&x25_proto, 0);
1395
1396         if (rc != 0)
1397                 goto out;
1398
1399         sock_register(&x25_family_ops);
1400
1401         dev_add_pack(&x25_packet_type);
1402
1403         register_netdevice_notifier(&x25_dev_notifier);
1404
1405         printk(KERN_INFO "X.25 for Linux. Version 0.2 for Linux 2.1.15\n");
1406
1407 #ifdef CONFIG_SYSCTL
1408         x25_register_sysctl();
1409 #endif
1410         x25_proc_init();
1411 out:
1412         return rc;
1413 }
1414 module_init(x25_init);
1415
1416 static void __exit x25_exit(void)
1417 {
1418         x25_proc_exit();
1419         x25_link_free();
1420         x25_route_free();
1421
1422 #ifdef CONFIG_SYSCTL
1423         x25_unregister_sysctl();
1424 #endif
1425
1426         unregister_netdevice_notifier(&x25_dev_notifier);
1427
1428         dev_remove_pack(&x25_packet_type);
1429
1430         sock_unregister(AF_X25);
1431         proto_unregister(&x25_proto);
1432 }
1433 module_exit(x25_exit);
1434
1435 MODULE_AUTHOR("Jonathan Naylor <g4klx@g4klx.demon.co.uk>");
1436 MODULE_DESCRIPTION("The X.25 Packet Layer network layer protocol");
1437 MODULE_LICENSE("GPL");
1438 MODULE_ALIAS_NETPROTO(PF_X25);