net/ax25/af_ax25.c

   1 /*
   2  * This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation; either version 2 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
   8  * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
   9  * Copyright (C) Darryl Miles G7LED (dlm@g7led.demon.co.uk)
  10  * Copyright (C) Steven Whitehouse GW7RRM (stevew@acm.org)
  11  * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
  12  * Copyright (C) Hans-Joachim Hetscher DD8NE (dd8ne@bnv-bamberg.de)
  13  * Copyright (C) Hans Alblas PE1AYX (hans@esrac.ele.tue.nl)
  14  * Copyright (C) Frederic Rible F1OAT (frible@teaser.fr)
  15  */
  16 #include <linux/capability.h>
  17 #include <linux/module.h>
  18 #include <linux/errno.h>
  19 #include <linux/types.h>
  20 #include <linux/socket.h>
  21 #include <linux/in.h>
  22 #include <linux/kernel.h>
  23 #include <linux/sched.h>
  24 #include <linux/timer.h>
  25 #include <linux/string.h>
  26 #include <linux/sockios.h>
  27 #include <linux/net.h>
  28 #include <linux/slab.h>
  29 #include <net/ax25.h>
  30 #include <linux/inet.h>
  31 #include <linux/netdevice.h>
  32 #include <linux/if_arp.h>
  33 #include <linux/skbuff.h>
  34 #include <net/sock.h>
  35 #include <asm/uaccess.h>
  36 #include <linux/fcntl.h>
  37 #include <linux/termios.h>      /* For TIOCINQ/OUTQ */
  38 #include <linux/mm.h>
  39 #include <linux/interrupt.h>
  40 #include <linux/notifier.h>
  41 #include <linux/proc_fs.h>
  42 #include <linux/stat.h>
  43 #include <linux/sysctl.h>
  44 #include <linux/init.h>
  45 #include <linux/spinlock.h>
  46 #include <net/net_namespace.h>
  47 #include <net/tcp_states.h>
  48 #include <net/ip.h>
  49 #include <net/arp.h>
  50
  51
  52
  53 HLIST_HEAD(ax25_list);
  54 DEFINE_SPINLOCK(ax25_list_lock);
  55
  56 static const struct proto_ops ax25_proto_ops;
  57
  58 static void ax25_free_sock(struct sock *sk)
  59 {
  60         ax25_cb_put(sk_to_ax25(sk));
  61 }
  62
  63 /*
  64  *      Socket removal during an interrupt is now safe.
  65  */
  66 static void ax25_cb_del(ax25_cb *ax25)
  67 {
  68         if (!hlist_unhashed(&ax25->ax25_node)) {
  69                 spin_lock_bh(&ax25_list_lock);
  70                 hlist_del_init(&ax25->ax25_node);
  71                 spin_unlock_bh(&ax25_list_lock);
  72                 ax25_cb_put(ax25);
  73         }
  74 }
  75
  76 /*
  77  *      Kill all bound sockets on a dropped device.
  78  */
  79 static void ax25_kill_by_device(struct net_device *dev)
  80 {
  81         ax25_dev *ax25_dev;
  82         ax25_cb *s;
  83
  84         if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
  85                 return;
  86
  87         spin_lock_bh(&ax25_list_lock);
  88 again:
  89         ax25_for_each(s, &ax25_list) {
  90                 if (s->ax25_dev == ax25_dev) {
  91                         s->ax25_dev = NULL;
  92                         spin_unlock_bh(&ax25_list_lock);
  93                         ax25_disconnect(s, ENETUNREACH);
  94                         spin_lock_bh(&ax25_list_lock);
  95
  96                         /* The entry could have been deleted from the
  97                          * list meanwhile and thus the next pointer is
  98                          * no longer valid.  Play it safe and restart
  99                          * the scan.  Forward progress is ensured
 100                          * because we set s->ax25_dev to NULL and we
 101                          * are never passed a NULL 'dev' argument.
 102                          */
 103                         goto again;
 104                 }
 105         }
 106         spin_unlock_bh(&ax25_list_lock);
 107 }
 108
 109 /*
 110  *      Handle device status changes.
 111  */
 112 static int ax25_device_event(struct notifier_block *this, unsigned long event,
 113                              void *ptr)
 114 {
 115         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 116
 117         if (!net_eq(dev_net(dev), &init_net))
 118                 return NOTIFY_DONE;
 119
 120         /* Reject non AX.25 devices */
 121         if (dev->type != ARPHRD_AX25)
 122                 return NOTIFY_DONE;
 123
 124         switch (event) {
 125         case NETDEV_UP:
 126                 ax25_dev_device_up(dev);
 127                 break;
 128         case NETDEV_DOWN:
 129                 ax25_kill_by_device(dev);
 130                 ax25_rt_device_down(dev);
 131                 ax25_dev_device_down(dev);
 132                 break;
 133         default:
 134                 break;
 135         }
 136
 137         return NOTIFY_DONE;
 138 }
 139
 140 /*
 141  *      Add a socket to the bound sockets list.
 142  */
 143 void ax25_cb_add(ax25_cb *ax25)
 144 {
 145         spin_lock_bh(&ax25_list_lock);
 146         ax25_cb_hold(ax25);
 147         hlist_add_head(&ax25->ax25_node, &ax25_list);
 148         spin_unlock_bh(&ax25_list_lock);
 149 }
 150
 151 /*
 152  *      Find a socket that wants to accept the SABM we have just
 153  *      received.
 154  */
 155 struct sock *ax25_find_listener(ax25_address *addr, int digi,
 156         struct net_device *dev, int type)
 157 {
 158         ax25_cb *s;
 159
 160         spin_lock(&ax25_list_lock);
 161         ax25_for_each(s, &ax25_list) {
 162                 if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
 163                         continue;
 164                 if (s->sk && !ax25cmp(&s->source_addr, addr) &&
 165                     s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
 166                         /* If device is null we match any device */
 167                         if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
 168                                 sock_hold(s->sk);
 169                                 spin_unlock(&ax25_list_lock);
 170                                 return s->sk;
 171                         }
 172                 }
 173         }
 174         spin_unlock(&ax25_list_lock);
 175
 176         return NULL;
 177 }
 178
 179 /*
 180  *      Find an AX.25 socket given both ends.
 181  */
 182 struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
 183         int type)
 184 {
 185         struct sock *sk = NULL;
 186         ax25_cb *s;
 187
 188         spin_lock(&ax25_list_lock);
 189         ax25_for_each(s, &ax25_list) {
 190                 if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
 191                     !ax25cmp(&s->dest_addr, dest_addr) &&
 192                     s->sk->sk_type == type) {
 193                         sk = s->sk;
 194                         sock_hold(sk);
 195                         break;
 196                 }
 197         }
 198
 199         spin_unlock(&ax25_list_lock);
 200
 201         return sk;
 202 }
 203
 204 /*
 205  *      Find an AX.25 control block given both ends. It will only pick up
 206  *      floating AX.25 control blocks or non Raw socket bound control blocks.
 207  */
 208 ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
 209         ax25_digi *digi, struct net_device *dev)
 210 {
 211         ax25_cb *s;
 212
 213         spin_lock_bh(&ax25_list_lock);
 214         ax25_for_each(s, &ax25_list) {
 215                 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
 216                         continue;
 217                 if (s->ax25_dev == NULL)
 218                         continue;
 219                 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
 220                         if (digi != NULL && digi->ndigi != 0) {
 221                                 if (s->digipeat == NULL)
 222                                         continue;
 223                                 if (ax25digicmp(s->digipeat, digi) != 0)
 224                                         continue;
 225                         } else {
 226                                 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
 227                                         continue;
 228                         }
 229                         ax25_cb_hold(s);
 230                         spin_unlock_bh(&ax25_list_lock);
 231
 232                         return s;
 233                 }
 234         }
 235         spin_unlock_bh(&ax25_list_lock);
 236
 237         return NULL;
 238 }
 239
 240 EXPORT_SYMBOL(ax25_find_cb);
 241
 242 void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
 243 {
 244         ax25_cb *s;
 245         struct sk_buff *copy;
 246
 247         spin_lock(&ax25_list_lock);
 248         ax25_for_each(s, &ax25_list) {
 249                 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
 250                     s->sk->sk_type == SOCK_RAW &&
 251                     s->sk->sk_protocol == proto &&
 252                     s->ax25_dev->dev == skb->dev &&
 253                     atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
 254                         if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
 255                                 continue;
 256                         if (sock_queue_rcv_skb(s->sk, copy) != 0)
 257                                 kfree_skb(copy);
 258                 }
 259         }
 260         spin_unlock(&ax25_list_lock);
 261 }
 262
 263 /*
 264  *      Deferred destroy.
 265  */
 266 void ax25_destroy_socket(ax25_cb *);
 267
 268 /*
 269  *      Handler for deferred kills.
 270  */
 271 static void ax25_destroy_timer(unsigned long data)
 272 {
 273         ax25_cb *ax25=(ax25_cb *)data;
 274         struct sock *sk;
 275
 276         sk=ax25->sk;
 277
 278         bh_lock_sock(sk);
 279         sock_hold(sk);
 280         ax25_destroy_socket(ax25);
 281         bh_unlock_sock(sk);
 282         sock_put(sk);
 283 }
 284
 285 /*
 286  *      This is called from user mode and the timers. Thus it protects itself
 287  *      against interrupt users but doesn't worry about being called during
 288  *      work. Once it is removed from the queue no interrupt or bottom half
 289  *      will touch it and we are (fairly 8-) ) safe.
 290  */
 291 void ax25_destroy_socket(ax25_cb *ax25)
 292 {
 293         struct sk_buff *skb;
 294
 295         ax25_cb_del(ax25);
 296
 297         ax25_stop_heartbeat(ax25);
 298         ax25_stop_t1timer(ax25);
 299         ax25_stop_t2timer(ax25);
 300         ax25_stop_t3timer(ax25);
 301         ax25_stop_idletimer(ax25);
 302
 303         ax25_clear_queues(ax25);        /* Flush the queues */
 304
 305         if (ax25->sk != NULL) {
 306                 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
 307                         if (skb->sk != ax25->sk) {
 308                                 /* A pending connection */
 309                                 ax25_cb *sax25 = sk_to_ax25(skb->sk);
 310
 311                                 /* Queue the unaccepted socket for death */
 312                                 sock_orphan(skb->sk);
 313
 314                                 /* 9A4GL: hack to release unaccepted sockets */
 315                                 skb->sk->sk_state = TCP_LISTEN;
 316
 317                                 ax25_start_heartbeat(sax25);
 318                                 sax25->state = AX25_STATE_0;
 319                         }
 320
 321                         kfree_skb(skb);
 322                 }
 323                 skb_queue_purge(&ax25->sk->sk_write_queue);
 324         }
 325
 326         if (ax25->sk != NULL) {
 327                 if (sk_has_allocations(ax25->sk)) {
 328                         /* Defer: outstanding buffers */
 329                         setup_timer(&ax25->dtimer, ax25_destroy_timer,
 330                                         (unsigned long)ax25);
 331                         ax25->dtimer.expires  = jiffies + 2 * HZ;
 332                         add_timer(&ax25->dtimer);
 333                 } else {
 334                         struct sock *sk=ax25->sk;
 335                         ax25->sk=NULL;
 336                         sock_put(sk);
 337                 }
 338         } else {
 339                 ax25_cb_put(ax25);
 340         }
 341 }
 342
 343 /*
 344  * dl1bke 960311: set parameters for existing AX.25 connections,
 345  *                includes a KILL command to abort any connection.
 346  *                VERY useful for debugging ;-)
 347  */
 348 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
 349 {
 350         struct ax25_ctl_struct ax25_ctl;
 351         ax25_digi digi;
 352         ax25_dev *ax25_dev;
 353         ax25_cb *ax25;
 354         unsigned int k;
 355         int ret = 0;
 356
 357         if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
 358                 return -EFAULT;
 359
 360         if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
 361                 return -ENODEV;
 362
 363         if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
 364                 return -EINVAL;
 365
 366         if (ax25_ctl.arg > ULONG_MAX / HZ && ax25_ctl.cmd != AX25_KILL)
 367                 return -EINVAL;
 368
 369         digi.ndigi = ax25_ctl.digi_count;
 370         for (k = 0; k < digi.ndigi; k++)
 371                 digi.calls[k] = ax25_ctl.digi_addr[k];
 372
 373         if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
 374                 return -ENOTCONN;
 375
 376         switch (ax25_ctl.cmd) {
 377         case AX25_KILL:
 378                 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
 379 #ifdef CONFIG_AX25_DAMA_SLAVE
 380                 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
 381                         ax25_dama_off(ax25);
 382 #endif
 383                 ax25_disconnect(ax25, ENETRESET);
 384                 break;
 385
 386         case AX25_WINDOW:
 387                 if (ax25->modulus == AX25_MODULUS) {
 388                         if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
 389                                 goto einval_put;
 390                 } else {
 391                         if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
 392                                 goto einval_put;
 393                 }
 394                 ax25->window = ax25_ctl.arg;
 395                 break;
 396
 397         case AX25_T1:
 398                 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
 399                         goto einval_put;
 400                 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
 401                 ax25->t1  = ax25_ctl.arg * HZ;
 402                 break;
 403
 404         case AX25_T2:
 405                 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
 406                         goto einval_put;
 407                 ax25->t2 = ax25_ctl.arg * HZ;
 408                 break;
 409
 410         case AX25_N2:
 411                 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
 412                         goto einval_put;
 413                 ax25->n2count = 0;
 414                 ax25->n2 = ax25_ctl.arg;
 415                 break;
 416
 417         case AX25_T3:
 418                 if (ax25_ctl.arg > ULONG_MAX / HZ)
 419                         goto einval_put;
 420                 ax25->t3 = ax25_ctl.arg * HZ;
 421                 break;
 422
 423         case AX25_IDLE:
 424                 if (ax25_ctl.arg > ULONG_MAX / (60 * HZ))
 425                         goto einval_put;
 426
 427                 ax25->idle = ax25_ctl.arg * 60 * HZ;
 428                 break;
 429
 430         case AX25_PACLEN:
 431                 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
 432                         goto einval_put;
 433                 ax25->paclen = ax25_ctl.arg;
 434                 break;
 435
 436         default:
 437                 goto einval_put;
 438           }
 439
 440 out_put:
 441         ax25_cb_put(ax25);
 442         return ret;
 443
 444 einval_put:
 445         ret = -EINVAL;
 446         goto out_put;
 447 }
 448
 449 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
 450 {
 451         ax25->rtt     = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
 452         ax25->t1      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
 453         ax25->t2      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
 454         ax25->t3      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
 455         ax25->n2      = ax25_dev->values[AX25_VALUES_N2];
 456         ax25->paclen  = ax25_dev->values[AX25_VALUES_PACLEN];
 457         ax25->idle    = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
 458         ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
 459
 460         if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
 461                 ax25->modulus = AX25_EMODULUS;
 462                 ax25->window  = ax25_dev->values[AX25_VALUES_EWINDOW];
 463         } else {
 464                 ax25->modulus = AX25_MODULUS;
 465                 ax25->window  = ax25_dev->values[AX25_VALUES_WINDOW];
 466         }
 467 }
 468
 469 /*
 470  *      Fill in a created AX.25 created control block with the default
 471  *      values for a particular device.
 472  */
 473 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
 474 {
 475         ax25->ax25_dev = ax25_dev;
 476
 477         if (ax25->ax25_dev != NULL) {
 478                 ax25_fillin_cb_from_dev(ax25, ax25_dev);
 479                 return;
 480         }
 481
 482         /*
 483          * No device, use kernel / AX.25 spec default values
 484          */
 485         ax25->rtt     = msecs_to_jiffies(AX25_DEF_T1) / 2;
 486         ax25->t1      = msecs_to_jiffies(AX25_DEF_T1);
 487         ax25->t2      = msecs_to_jiffies(AX25_DEF_T2);
 488         ax25->t3      = msecs_to_jiffies(AX25_DEF_T3);
 489         ax25->n2      = AX25_DEF_N2;
 490         ax25->paclen  = AX25_DEF_PACLEN;
 491         ax25->idle    = msecs_to_jiffies(AX25_DEF_IDLE);
 492         ax25->backoff = AX25_DEF_BACKOFF;
 493
 494         if (AX25_DEF_AXDEFMODE) {
 495                 ax25->modulus = AX25_EMODULUS;
 496                 ax25->window  = AX25_DEF_EWINDOW;
 497         } else {
 498                 ax25->modulus = AX25_MODULUS;
 499                 ax25->window  = AX25_DEF_WINDOW;
 500         }
 501 }
 502
 503 /*
 504  * Create an empty AX.25 control block.
 505  */
 506 ax25_cb *ax25_create_cb(void)
 507 {
 508         ax25_cb *ax25;
 509
 510         if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
 511                 return NULL;
 512
 513         atomic_set(&ax25->refcount, 1);
 514
 515         skb_queue_head_init(&ax25->write_queue);
 516         skb_queue_head_init(&ax25->frag_queue);
 517         skb_queue_head_init(&ax25->ack_queue);
 518         skb_queue_head_init(&ax25->reseq_queue);
 519
 520         ax25_setup_timers(ax25);
 521
 522         ax25_fillin_cb(ax25, NULL);
 523
 524         ax25->state = AX25_STATE_0;
 525
 526         return ax25;
 527 }
 528
 529 /*
 530  *      Handling for system calls applied via the various interfaces to an
 531  *      AX25 socket object
 532  */
 533
 534 static int ax25_setsockopt(struct socket *sock, int level, int optname,
 535         char __user *optval, unsigned int optlen)
 536 {
 537         struct sock *sk = sock->sk;
 538         ax25_cb *ax25;
 539         struct net_device *dev;
 540         char devname[IFNAMSIZ];
 541         unsigned long opt;
 542         int res = 0;
 543
 544         if (level != SOL_AX25)
 545                 return -ENOPROTOOPT;
 546
 547         if (optlen < sizeof(unsigned int))
 548                 return -EINVAL;
 549
 550         if (get_user(opt, (unsigned int __user *)optval))
 551                 return -EFAULT;
 552
 553         lock_sock(sk);
 554         ax25 = sk_to_ax25(sk);
 555
 556         switch (optname) {
 557         case AX25_WINDOW:
 558                 if (ax25->modulus == AX25_MODULUS) {
 559                         if (opt < 1 || opt > 7) {
 560                                 res = -EINVAL;
 561                                 break;
 562                         }
 563                 } else {
 564                         if (opt < 1 || opt > 63) {
 565                                 res = -EINVAL;
 566                                 break;
 567                         }
 568                 }
 569                 ax25->window = opt;
 570                 break;
 571
 572         case AX25_T1:
 573                 if (opt < 1 || opt > ULONG_MAX / HZ) {
 574                         res = -EINVAL;
 575                         break;
 576                 }
 577                 ax25->rtt = (opt * HZ) >> 1;
 578                 ax25->t1  = opt * HZ;
 579                 break;
 580
 581         case AX25_T2:
 582                 if (opt < 1 || opt > ULONG_MAX / HZ) {
 583                         res = -EINVAL;
 584                         break;
 585                 }
 586                 ax25->t2 = opt * HZ;
 587                 break;
 588
 589         case AX25_N2:
 590                 if (opt < 1 || opt > 31) {
 591                         res = -EINVAL;
 592                         break;
 593                 }
 594                 ax25->n2 = opt;
 595                 break;
 596
 597         case AX25_T3:
 598                 if (opt < 1 || opt > ULONG_MAX / HZ) {
 599                         res = -EINVAL;
 600                         break;
 601                 }
 602                 ax25->t3 = opt * HZ;
 603                 break;
 604
 605         case AX25_IDLE:
 606                 if (opt > ULONG_MAX / (60 * HZ)) {
 607                         res = -EINVAL;
 608                         break;
 609                 }
 610                 ax25->idle = opt * 60 * HZ;
 611                 break;
 612
 613         case AX25_BACKOFF:
 614                 if (opt > 2) {
 615                         res = -EINVAL;
 616                         break;
 617                 }
 618                 ax25->backoff = opt;
 619                 break;
 620
 621         case AX25_EXTSEQ:
 622                 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
 623                 break;
 624
 625         case AX25_PIDINCL:
 626                 ax25->pidincl = opt ? 1 : 0;
 627                 break;
 628
 629         case AX25_IAMDIGI:
 630                 ax25->iamdigi = opt ? 1 : 0;
 631                 break;
 632
 633         case AX25_PACLEN:
 634                 if (opt < 16 || opt > 65535) {
 635                         res = -EINVAL;
 636                         break;
 637                 }
 638                 ax25->paclen = opt;
 639                 break;
 640
 641         case SO_BINDTODEVICE:
 642                 if (optlen > IFNAMSIZ - 1)
 643                         optlen = IFNAMSIZ - 1;
 644
 645                 memset(devname, 0, sizeof(devname));
 646
 647                 if (copy_from_user(devname, optval, optlen)) {
 648                         res = -EFAULT;
 649                         break;
 650                 }
 651
 652                 if (sk->sk_type == SOCK_SEQPACKET &&
 653                    (sock->state != SS_UNCONNECTED ||
 654                     sk->sk_state == TCP_LISTEN)) {
 655                         res = -EADDRNOTAVAIL;
 656                         break;
 657                 }
 658
 659                 rtnl_lock();
 660                 dev = __dev_get_by_name(&init_net, devname);
 661                 if (!dev) {
 662                         rtnl_unlock();
 663                         res = -ENODEV;
 664                         break;
 665                 }
 666
 667                 ax25->ax25_dev = ax25_dev_ax25dev(dev);
 668                 if (!ax25->ax25_dev) {
 669                         rtnl_unlock();
 670                         res = -ENODEV;
 671                         break;
 672                 }
 673                 ax25_fillin_cb(ax25, ax25->ax25_dev);
 674                 rtnl_unlock();
 675                 break;
 676
 677         default:
 678                 res = -ENOPROTOOPT;
 679         }
 680         release_sock(sk);
 681
 682         return res;
 683 }
 684
 685 static int ax25_getsockopt(struct socket *sock, int level, int optname,
 686         char __user *optval, int __user *optlen)
 687 {
 688         struct sock *sk = sock->sk;
 689         ax25_cb *ax25;
 690         struct ax25_dev *ax25_dev;
 691         char devname[IFNAMSIZ];
 692         void *valptr;
 693         int val = 0;
 694         int maxlen, length;
 695
 696         if (level != SOL_AX25)
 697                 return -ENOPROTOOPT;
 698
 699         if (get_user(maxlen, optlen))
 700                 return -EFAULT;
 701
 702         if (maxlen < 1)
 703                 return -EFAULT;
 704
 705         valptr = (void *) &val;
 706         length = min_t(unsigned int, maxlen, sizeof(int));
 707
 708         lock_sock(sk);
 709         ax25 = sk_to_ax25(sk);
 710
 711         switch (optname) {
 712         case AX25_WINDOW:
 713                 val = ax25->window;
 714                 break;
 715
 716         case AX25_T1:
 717                 val = ax25->t1 / HZ;
 718                 break;
 719
 720         case AX25_T2:
 721                 val = ax25->t2 / HZ;
 722                 break;
 723
 724         case AX25_N2:
 725                 val = ax25->n2;
 726                 break;
 727
 728         case AX25_T3:
 729                 val = ax25->t3 / HZ;
 730                 break;
 731
 732         case AX25_IDLE:
 733                 val = ax25->idle / (60 * HZ);
 734                 break;
 735
 736         case AX25_BACKOFF:
 737                 val = ax25->backoff;
 738                 break;
 739
 740         case AX25_EXTSEQ:
 741                 val = (ax25->modulus == AX25_EMODULUS);
 742                 break;
 743
 744         case AX25_PIDINCL:
 745                 val = ax25->pidincl;
 746                 break;
 747
 748         case AX25_IAMDIGI:
 749                 val = ax25->iamdigi;
 750                 break;
 751
 752         case AX25_PACLEN:
 753                 val = ax25->paclen;
 754                 break;
 755
 756         case SO_BINDTODEVICE:
 757                 ax25_dev = ax25->ax25_dev;
 758
 759                 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
 760                         strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
 761                         length = strlen(devname) + 1;
 762                 } else {
 763                         *devname = '\0';
 764                         length = 1;
 765                 }
 766
 767                 valptr = (void *) devname;
 768                 break;
 769
 770         default:
 771                 release_sock(sk);
 772                 return -ENOPROTOOPT;
 773         }
 774         release_sock(sk);
 775
 776         if (put_user(length, optlen))
 777                 return -EFAULT;
 778
 779         return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
 780 }
 781
 782 static int ax25_listen(struct socket *sock, int backlog)
 783 {
 784         struct sock *sk = sock->sk;
 785         int res = 0;
 786
 787         lock_sock(sk);
 788         if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
 789                 sk->sk_max_ack_backlog = backlog;
 790                 sk->sk_state           = TCP_LISTEN;
 791                 goto out;
 792         }
 793         res = -EOPNOTSUPP;
 794
 795 out:
 796         release_sock(sk);
 797
 798         return res;
 799 }
 800
 801 /*
 802  * XXX: when creating ax25_sock we should update the .obj_size setting
 803  * below.
 804  */
 805 static struct proto ax25_proto = {
 806         .name     = "AX25",
 807         .owner    = THIS_MODULE,
 808         .obj_size = sizeof(struct ax25_sock),
 809 };
 810
 811 static int ax25_create(struct net *net, struct socket *sock, int protocol,
 812                        int kern)
 813 {
 814         struct sock *sk;
 815         ax25_cb *ax25;
 816
 817         if (protocol < 0 || protocol > SK_PROTOCOL_MAX)
 818                 return -EINVAL;
 819
 820         if (!net_eq(net, &init_net))
 821                 return -EAFNOSUPPORT;
 822
 823         switch (sock->type) {
 824         case SOCK_DGRAM:
 825                 if (protocol == 0 || protocol == PF_AX25)
 826                         protocol = AX25_P_TEXT;
 827                 break;
 828
 829         case SOCK_SEQPACKET:
 830                 switch (protocol) {
 831                 case 0:
 832                 case PF_AX25:   /* For CLX */
 833                         protocol = AX25_P_TEXT;
 834                         break;
 835                 case AX25_P_SEGMENT:
 836 #ifdef CONFIG_INET
 837                 case AX25_P_ARP:
 838                 case AX25_P_IP:
 839 #endif
 840 #ifdef CONFIG_NETROM
 841                 case AX25_P_NETROM:
 842 #endif
 843 #ifdef CONFIG_ROSE
 844                 case AX25_P_ROSE:
 845 #endif
 846                         return -ESOCKTNOSUPPORT;
 847 #ifdef CONFIG_NETROM_MODULE
 848                 case AX25_P_NETROM:
 849                         if (ax25_protocol_is_registered(AX25_P_NETROM))
 850                                 return -ESOCKTNOSUPPORT;
 851                         break;
 852 #endif
 853 #ifdef CONFIG_ROSE_MODULE
 854                 case AX25_P_ROSE:
 855                         if (ax25_protocol_is_registered(AX25_P_ROSE))
 856                                 return -ESOCKTNOSUPPORT;
 857 #endif
 858                 default:
 859                         break;
 860                 }
 861                 break;
 862
 863         case SOCK_RAW:
 864                 if (!capable(CAP_NET_RAW))
 865                         return -EPERM;
 866                 break;
 867         default:
 868                 return -ESOCKTNOSUPPORT;
 869         }
 870
 871         sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto, kern);
 872         if (sk == NULL)
 873                 return -ENOMEM;
 874
 875         ax25 = ax25_sk(sk)->cb = ax25_create_cb();
 876         if (!ax25) {
 877                 sk_free(sk);
 878                 return -ENOMEM;
 879         }
 880
 881         sock_init_data(sock, sk);
 882
 883         sk->sk_destruct = ax25_free_sock;
 884         sock->ops    = &ax25_proto_ops;
 885         sk->sk_protocol = protocol;
 886
 887         ax25->sk    = sk;
 888
 889         return 0;
 890 }
 891
 892 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
 893 {
 894         struct sock *sk;
 895         ax25_cb *ax25, *oax25;
 896
 897         sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot, 0);
 898         if (sk == NULL)
 899                 return NULL;
 900
 901         if ((ax25 = ax25_create_cb()) == NULL) {
 902                 sk_free(sk);
 903                 return NULL;
 904         }
 905
 906         switch (osk->sk_type) {
 907         case SOCK_DGRAM:
 908                 break;
 909         case SOCK_SEQPACKET:
 910                 break;
 911         default:
 912                 sk_free(sk);
 913                 ax25_cb_put(ax25);
 914                 return NULL;
 915         }
 916
 917         sock_init_data(NULL, sk);
 918
 919         sk->sk_type     = osk->sk_type;
 920         sk->sk_priority = osk->sk_priority;
 921         sk->sk_protocol = osk->sk_protocol;
 922         sk->sk_rcvbuf   = osk->sk_rcvbuf;
 923         sk->sk_sndbuf   = osk->sk_sndbuf;
 924         sk->sk_state    = TCP_ESTABLISHED;
 925         sock_copy_flags(sk, osk);
 926
 927         oax25 = sk_to_ax25(osk);
 928
 929         ax25->modulus = oax25->modulus;
 930         ax25->backoff = oax25->backoff;
 931         ax25->pidincl = oax25->pidincl;
 932         ax25->iamdigi = oax25->iamdigi;
 933         ax25->rtt     = oax25->rtt;
 934         ax25->t1      = oax25->t1;
 935         ax25->t2      = oax25->t2;
 936         ax25->t3      = oax25->t3;
 937         ax25->n2      = oax25->n2;
 938         ax25->idle    = oax25->idle;
 939         ax25->paclen  = oax25->paclen;
 940         ax25->window  = oax25->window;
 941
 942         ax25->ax25_dev    = ax25_dev;
 943         ax25->source_addr = oax25->source_addr;
 944
 945         if (oax25->digipeat != NULL) {
 946                 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
 947                                          GFP_ATOMIC);
 948                 if (ax25->digipeat == NULL) {
 949                         sk_free(sk);
 950                         ax25_cb_put(ax25);
 951                         return NULL;
 952                 }
 953         }
 954
 955         ax25_sk(sk)->cb = ax25;
 956         sk->sk_destruct = ax25_free_sock;
 957         ax25->sk    = sk;
 958
 959         return sk;
 960 }
 961
 962 static int ax25_release(struct socket *sock)
 963 {
 964         struct sock *sk = sock->sk;
 965         ax25_cb *ax25;
 966
 967         if (sk == NULL)
 968                 return 0;
 969
 970         sock_hold(sk);
 971         sock_orphan(sk);
 972         lock_sock(sk);
 973         ax25 = sk_to_ax25(sk);
 974
 975         if (sk->sk_type == SOCK_SEQPACKET) {
 976                 switch (ax25->state) {
 977                 case AX25_STATE_0:
 978                         release_sock(sk);
 979                         ax25_disconnect(ax25, 0);
 980                         lock_sock(sk);
 981                         ax25_destroy_socket(ax25);
 982                         break;
 983
 984                 case AX25_STATE_1:
 985                 case AX25_STATE_2:
 986                         ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
 987                         release_sock(sk);
 988                         ax25_disconnect(ax25, 0);
 989                         lock_sock(sk);
 990                         if (!sock_flag(ax25->sk, SOCK_DESTROY))
 991                                 ax25_destroy_socket(ax25);
 992                         break;
 993
 994                 case AX25_STATE_3:
 995                 case AX25_STATE_4:
 996                         ax25_clear_queues(ax25);
 997                         ax25->n2count = 0;
 998
 999                         switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1000                         case AX25_PROTO_STD_SIMPLEX:
1001                         case AX25_PROTO_STD_DUPLEX:
1002                                 ax25_send_control(ax25,
1003                                                   AX25_DISC,
1004                                                   AX25_POLLON,
1005                                                   AX25_COMMAND);
1006                                 ax25_stop_t2timer(ax25);
1007                                 ax25_stop_t3timer(ax25);
1008                                 ax25_stop_idletimer(ax25);
1009                                 break;
1010 #ifdef CONFIG_AX25_DAMA_SLAVE
1011                         case AX25_PROTO_DAMA_SLAVE:
1012                                 ax25_stop_t3timer(ax25);
1013                                 ax25_stop_idletimer(ax25);
1014                                 break;
1015 #endif
1016                         }
1017                         ax25_calculate_t1(ax25);
1018                         ax25_start_t1timer(ax25);
1019                         ax25->state = AX25_STATE_2;
1020                         sk->sk_state                = TCP_CLOSE;
1021                         sk->sk_shutdown            |= SEND_SHUTDOWN;
1022                         sk->sk_state_change(sk);
1023                         sock_set_flag(sk, SOCK_DESTROY);
1024                         break;
1025
1026                 default:
1027                         break;
1028                 }
1029         } else {
1030                 sk->sk_state     = TCP_CLOSE;
1031                 sk->sk_shutdown |= SEND_SHUTDOWN;
1032                 sk->sk_state_change(sk);
1033                 ax25_destroy_socket(ax25);
1034         }
1035
1036         sock->sk   = NULL;
1037         release_sock(sk);
1038         sock_put(sk);
1039
1040         return 0;
1041 }
1042
1043 /*
1044  *      We support a funny extension here so you can (as root) give any callsign
1045  *      digipeated via a local address as source. This hack is obsolete now
1046  *      that we've implemented support for SO_BINDTODEVICE. It is however small
1047  *      and trivially backward compatible.
1048  */
1049 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1050 {
1051         struct sock *sk = sock->sk;
1052         struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1053         ax25_dev *ax25_dev = NULL;
1054         ax25_uid_assoc *user;
1055         ax25_address call;
1056         ax25_cb *ax25;
1057         int err = 0;
1058
1059         if (addr_len != sizeof(struct sockaddr_ax25) &&
1060             addr_len != sizeof(struct full_sockaddr_ax25))
1061                 /* support for old structure may go away some time
1062                  * ax25_bind(): uses old (6 digipeater) socket structure.
1063                  */
1064                 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1065                     (addr_len > sizeof(struct full_sockaddr_ax25)))
1066                         return -EINVAL;
1067
1068         if (addr->fsa_ax25.sax25_family != AF_AX25)
1069                 return -EINVAL;
1070
1071         user = ax25_findbyuid(current_euid());
1072         if (user) {
1073                 call = user->call;
1074                 ax25_uid_put(user);
1075         } else {
1076                 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1077                         return -EACCES;
1078
1079                 call = addr->fsa_ax25.sax25_call;
1080         }
1081
1082         lock_sock(sk);
1083
1084         ax25 = sk_to_ax25(sk);
1085         if (!sock_flag(sk, SOCK_ZAPPED)) {
1086                 err = -EINVAL;
1087                 goto out;
1088         }
1089
1090         ax25->source_addr = call;
1091
1092         /*
1093          * User already set interface with SO_BINDTODEVICE
1094          */
1095         if (ax25->ax25_dev != NULL)
1096                 goto done;
1097
1098         if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1099                 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1100                     (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1101                         err = -EADDRNOTAVAIL;
1102                         goto out;
1103                 }
1104         } else {
1105                 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1106                         err = -EADDRNOTAVAIL;
1107                         goto out;
1108                 }
1109         }
1110
1111         if (ax25_dev != NULL)
1112                 ax25_fillin_cb(ax25, ax25_dev);
1113
1114 done:
1115         ax25_cb_add(ax25);
1116         sock_reset_flag(sk, SOCK_ZAPPED);
1117
1118 out:
1119         release_sock(sk);
1120
1121         return err;
1122 }
1123
1124 /*
1125  *      FIXME: nonblock behaviour looks like it may have a bug.
1126  */
1127 static int __must_check ax25_connect(struct socket *sock,
1128         struct sockaddr *uaddr, int addr_len, int flags)
1129 {
1130         struct sock *sk = sock->sk;
1131         ax25_cb *ax25 = sk_to_ax25(sk), *ax25t;
1132         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1133         ax25_digi *digi = NULL;
1134         int ct = 0, err = 0;
1135
1136         /*
1137          * some sanity checks. code further down depends on this
1138          */
1139
1140         if (addr_len == sizeof(struct sockaddr_ax25))
1141                 /* support for this will go away in early 2.5.x
1142                  * ax25_connect(): uses obsolete socket structure
1143                  */
1144                 ;
1145         else if (addr_len != sizeof(struct full_sockaddr_ax25))
1146                 /* support for old structure may go away some time
1147                  * ax25_connect(): uses old (6 digipeater) socket structure.
1148                  */
1149                 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1150                     (addr_len > sizeof(struct full_sockaddr_ax25)))
1151                         return -EINVAL;
1152
1153
1154         if (fsa->fsa_ax25.sax25_family != AF_AX25)
1155                 return -EINVAL;
1156
1157         lock_sock(sk);
1158
1159         /* deal with restarts */
1160         if (sock->state == SS_CONNECTING) {
1161                 switch (sk->sk_state) {
1162                 case TCP_SYN_SENT: /* still trying */
1163                         err = -EINPROGRESS;
1164                         goto out_release;
1165
1166                 case TCP_ESTABLISHED: /* connection established */
1167                         sock->state = SS_CONNECTED;
1168                         goto out_release;
1169
1170                 case TCP_CLOSE: /* connection refused */
1171                         sock->state = SS_UNCONNECTED;
1172                         err = -ECONNREFUSED;
1173                         goto out_release;
1174                 }
1175         }
1176
1177         if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1178                 err = -EISCONN; /* No reconnect on a seqpacket socket */
1179                 goto out_release;
1180         }
1181
1182         sk->sk_state   = TCP_CLOSE;
1183         sock->state = SS_UNCONNECTED;
1184
1185         kfree(ax25->digipeat);
1186         ax25->digipeat = NULL;
1187
1188         /*
1189          *      Handle digi-peaters to be used.
1190          */
1191         if (addr_len > sizeof(struct sockaddr_ax25) &&
1192             fsa->fsa_ax25.sax25_ndigis != 0) {
1193                 /* Valid number of digipeaters ? */
1194                 if (fsa->fsa_ax25.sax25_ndigis < 1 ||
1195                     fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS ||
1196                     addr_len < sizeof(struct sockaddr_ax25) +
1197                     sizeof(ax25_address) * fsa->fsa_ax25.sax25_ndigis) {
1198                         err = -EINVAL;
1199                         goto out_release;
1200                 }
1201
1202                 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1203                         err = -ENOBUFS;
1204                         goto out_release;
1205                 }
1206
1207                 digi->ndigi      = fsa->fsa_ax25.sax25_ndigis;
1208                 digi->lastrepeat = -1;
1209
1210                 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1211                         if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1212                              AX25_HBIT) && ax25->iamdigi) {
1213                                 digi->repeated[ct] = 1;
1214                                 digi->lastrepeat   = ct;
1215                         } else {
1216                                 digi->repeated[ct] = 0;
1217                         }
1218                         digi->calls[ct] = fsa->fsa_digipeater[ct];
1219                         ct++;
1220                 }
1221         }
1222
1223         /*
1224          *      Must bind first - autobinding in this may or may not work. If
1225          *      the socket is already bound, check to see if the device has
1226          *      been filled in, error if it hasn't.
1227          */
1228         if (sock_flag(sk, SOCK_ZAPPED)) {
1229                 /* check if we can remove this feature. It is broken. */
1230                 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1231                         current->comm);
1232                 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1233                         kfree(digi);
1234                         goto out_release;
1235                 }
1236
1237                 ax25_fillin_cb(ax25, ax25->ax25_dev);
1238                 ax25_cb_add(ax25);
1239         } else {
1240                 if (ax25->ax25_dev == NULL) {
1241                         kfree(digi);
1242                         err = -EHOSTUNREACH;
1243                         goto out_release;
1244                 }
1245         }
1246
1247         if (sk->sk_type == SOCK_SEQPACKET &&
1248             (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1249                          ax25->ax25_dev->dev))) {
1250                 kfree(digi);
1251                 err = -EADDRINUSE;              /* Already such a connection */
1252                 ax25_cb_put(ax25t);
1253                 goto out_release;
1254         }
1255
1256         ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1257         ax25->digipeat  = digi;
1258
1259         /* First the easy one */
1260         if (sk->sk_type != SOCK_SEQPACKET) {
1261                 sock->state = SS_CONNECTED;
1262                 sk->sk_state   = TCP_ESTABLISHED;
1263                 goto out_release;
1264         }
1265
1266         /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1267         sock->state        = SS_CONNECTING;
1268         sk->sk_state          = TCP_SYN_SENT;
1269
1270         switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1271         case AX25_PROTO_STD_SIMPLEX:
1272         case AX25_PROTO_STD_DUPLEX:
1273                 ax25_std_establish_data_link(ax25);
1274                 break;
1275
1276 #ifdef CONFIG_AX25_DAMA_SLAVE
1277         case AX25_PROTO_DAMA_SLAVE:
1278                 ax25->modulus = AX25_MODULUS;
1279                 ax25->window  = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1280                 if (ax25->ax25_dev->dama.slave)
1281                         ax25_ds_establish_data_link(ax25);
1282                 else
1283                         ax25_std_establish_data_link(ax25);
1284                 break;
1285 #endif
1286         }
1287
1288         ax25->state = AX25_STATE_1;
1289
1290         ax25_start_heartbeat(ax25);
1291
1292         /* Now the loop */
1293         if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1294                 err = -EINPROGRESS;
1295                 goto out_release;
1296         }
1297
1298         if (sk->sk_state == TCP_SYN_SENT) {
1299                 DEFINE_WAIT(wait);
1300
1301                 for (;;) {
1302                         prepare_to_wait(sk_sleep(sk), &wait,
1303                                         TASK_INTERRUPTIBLE);
1304                         if (sk->sk_state != TCP_SYN_SENT)
1305                                 break;
1306                         if (!signal_pending(current)) {
1307                                 release_sock(sk);
1308                                 schedule();
1309                                 lock_sock(sk);
1310                                 continue;
1311                         }
1312                         err = -ERESTARTSYS;
1313                         break;
1314                 }
1315                 finish_wait(sk_sleep(sk), &wait);
1316
1317                 if (err)
1318                         goto out_release;
1319         }
1320
1321         if (sk->sk_state != TCP_ESTABLISHED) {
1322                 /* Not in ABM, not in WAIT_UA -> failed */
1323                 sock->state = SS_UNCONNECTED;
1324                 err = sock_error(sk);   /* Always set at this point */
1325                 goto out_release;
1326         }
1327
1328         sock->state = SS_CONNECTED;
1329
1330         err = 0;
1331 out_release:
1332         release_sock(sk);
1333
1334         return err;
1335 }
1336
1337 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1338 {
1339         struct sk_buff *skb;
1340         struct sock *newsk;
1341         DEFINE_WAIT(wait);
1342         struct sock *sk;
1343         int err = 0;
1344
1345         if (sock->state != SS_UNCONNECTED)
1346                 return -EINVAL;
1347
1348         if ((sk = sock->sk) == NULL)
1349                 return -EINVAL;
1350
1351         lock_sock(sk);
1352         if (sk->sk_type != SOCK_SEQPACKET) {
1353                 err = -EOPNOTSUPP;
1354                 goto out;
1355         }
1356
1357         if (sk->sk_state != TCP_LISTEN) {
1358                 err = -EINVAL;
1359                 goto out;
1360         }
1361
1362         /*
1363          *      The read queue this time is holding sockets ready to use
1364          *      hooked into the SABM we saved
1365          */
1366         for (;;) {
1367                 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1368                 skb = skb_dequeue(&sk->sk_receive_queue);
1369                 if (skb)
1370                         break;
1371
1372                 if (flags & O_NONBLOCK) {
1373                         err = -EWOULDBLOCK;
1374                         break;
1375                 }
1376                 if (!signal_pending(current)) {
1377                         release_sock(sk);
1378                         schedule();
1379                         lock_sock(sk);
1380                         continue;
1381                 }
1382                 err = -ERESTARTSYS;
1383                 break;
1384         }
1385         finish_wait(sk_sleep(sk), &wait);
1386
1387         if (err)
1388                 goto out;
1389
1390         newsk            = skb->sk;
1391         sock_graft(newsk, newsock);
1392
1393         /* Now attach up the new socket */
1394         kfree_skb(skb);
1395         sk->sk_ack_backlog--;
1396         newsock->state = SS_CONNECTED;
1397
1398 out:
1399         release_sock(sk);
1400
1401         return err;
1402 }
1403
1404 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1405         int *uaddr_len, int peer)
1406 {
1407         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1408         struct sock *sk = sock->sk;
1409         unsigned char ndigi, i;
1410         ax25_cb *ax25;
1411         int err = 0;
1412
1413         memset(fsa, 0, sizeof(*fsa));
1414         lock_sock(sk);
1415         ax25 = sk_to_ax25(sk);
1416
1417         if (peer != 0) {
1418                 if (sk->sk_state != TCP_ESTABLISHED) {
1419                         err = -ENOTCONN;
1420                         goto out;
1421                 }
1422
1423                 fsa->fsa_ax25.sax25_family = AF_AX25;
1424                 fsa->fsa_ax25.sax25_call   = ax25->dest_addr;
1425
1426                 if (ax25->digipeat != NULL) {
1427                         ndigi = ax25->digipeat->ndigi;
1428                         fsa->fsa_ax25.sax25_ndigis = ndigi;
1429                         for (i = 0; i < ndigi; i++)
1430                                 fsa->fsa_digipeater[i] =
1431                                                 ax25->digipeat->calls[i];
1432                 }
1433         } else {
1434                 fsa->fsa_ax25.sax25_family = AF_AX25;
1435                 fsa->fsa_ax25.sax25_call   = ax25->source_addr;
1436                 fsa->fsa_ax25.sax25_ndigis = 1;
1437                 if (ax25->ax25_dev != NULL) {
1438                         memcpy(&fsa->fsa_digipeater[0],
1439                                ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1440                 } else {
1441                         fsa->fsa_digipeater[0] = null_ax25_address;
1442                 }
1443         }
1444         *uaddr_len = sizeof (struct full_sockaddr_ax25);
1445
1446 out:
1447         release_sock(sk);
1448
1449         return err;
1450 }
1451
1452 static int ax25_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
1453 {
1454         DECLARE_SOCKADDR(struct sockaddr_ax25 *, usax, msg->msg_name);
1455         struct sock *sk = sock->sk;
1456         struct sockaddr_ax25 sax;
1457         struct sk_buff *skb;
1458         ax25_digi dtmp, *dp;
1459         ax25_cb *ax25;
1460         size_t size;
1461         int lv, err, addr_len = msg->msg_namelen;
1462
1463         if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1464                 return -EINVAL;
1465
1466         lock_sock(sk);
1467         ax25 = sk_to_ax25(sk);
1468
1469         if (sock_flag(sk, SOCK_ZAPPED)) {
1470                 err = -EADDRNOTAVAIL;
1471                 goto out;
1472         }
1473
1474         if (sk->sk_shutdown & SEND_SHUTDOWN) {
1475                 send_sig(SIGPIPE, current, 0);
1476                 err = -EPIPE;
1477                 goto out;
1478         }
1479
1480         if (ax25->ax25_dev == NULL) {
1481                 err = -ENETUNREACH;
1482                 goto out;
1483         }
1484
1485         if (len > ax25->ax25_dev->dev->mtu) {
1486                 err = -EMSGSIZE;
1487                 goto out;
1488         }
1489
1490         if (usax != NULL) {
1491                 if (usax->sax25_family != AF_AX25) {
1492                         err = -EINVAL;
1493                         goto out;
1494                 }
1495
1496                 if (addr_len == sizeof(struct sockaddr_ax25))
1497                         /* ax25_sendmsg(): uses obsolete socket structure */
1498                         ;
1499                 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1500                         /* support for old structure may go away some time
1501                          * ax25_sendmsg(): uses old (6 digipeater)
1502                          * socket structure.
1503                          */
1504                         if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1505                             (addr_len > sizeof(struct full_sockaddr_ax25))) {
1506                                 err = -EINVAL;
1507                                 goto out;
1508                         }
1509
1510
1511                 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1512                         int ct           = 0;
1513                         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1514
1515                         /* Valid number of digipeaters ? */
1516                         if (usax->sax25_ndigis < 1 ||
1517                             usax->sax25_ndigis > AX25_MAX_DIGIS ||
1518                             addr_len < sizeof(struct sockaddr_ax25) +
1519                             sizeof(ax25_address) * usax->sax25_ndigis) {
1520                                 err = -EINVAL;
1521                                 goto out;
1522                         }
1523
1524                         dtmp.ndigi      = usax->sax25_ndigis;
1525
1526                         while (ct < usax->sax25_ndigis) {
1527                                 dtmp.repeated[ct] = 0;
1528                                 dtmp.calls[ct]    = fsa->fsa_digipeater[ct];
1529                                 ct++;
1530                         }
1531
1532                         dtmp.lastrepeat = 0;
1533                 }
1534
1535                 sax = *usax;
1536                 if (sk->sk_type == SOCK_SEQPACKET &&
1537                     ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1538                         err = -EISCONN;
1539                         goto out;
1540                 }
1541                 if (usax->sax25_ndigis == 0)
1542                         dp = NULL;
1543                 else
1544                         dp = &dtmp;
1545         } else {
1546                 /*
1547                  *      FIXME: 1003.1g - if the socket is like this because
1548                  *      it has become closed (not started closed) and is VC
1549                  *      we ought to SIGPIPE, EPIPE
1550                  */
1551                 if (sk->sk_state != TCP_ESTABLISHED) {
1552                         err = -ENOTCONN;
1553                         goto out;
1554                 }
1555                 sax.sax25_family = AF_AX25;
1556                 sax.sax25_call   = ax25->dest_addr;
1557                 dp = ax25->digipeat;
1558         }
1559
1560         /* Build a packet */
1561         /* Assume the worst case */
1562         size = len + ax25->ax25_dev->dev->hard_header_len;
1563
1564         skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1565         if (skb == NULL)
1566                 goto out;
1567
1568         skb_reserve(skb, size - len);
1569
1570         /* User data follows immediately after the AX.25 data */
1571         if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
1572                 err = -EFAULT;
1573                 kfree_skb(skb);
1574                 goto out;
1575         }
1576
1577         skb_reset_network_header(skb);
1578
1579         /* Add the PID if one is not supplied by the user in the skb */
1580         if (!ax25->pidincl)
1581                 *skb_push(skb, 1) = sk->sk_protocol;
1582
1583         if (sk->sk_type == SOCK_SEQPACKET) {
1584                 /* Connected mode sockets go via the LAPB machine */
1585                 if (sk->sk_state != TCP_ESTABLISHED) {
1586                         kfree_skb(skb);
1587                         err = -ENOTCONN;
1588                         goto out;
1589                 }
1590
1591                 /* Shove it onto the queue and kick */
1592                 ax25_output(ax25, ax25->paclen, skb);
1593
1594                 err = len;
1595                 goto out;
1596         }
1597
1598         skb_push(skb, 1 + ax25_addr_size(dp));
1599
1600         /* Building AX.25 Header */
1601
1602         /* Build an AX.25 header */
1603         lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1604                              dp, AX25_COMMAND, AX25_MODULUS);
1605
1606         skb_set_transport_header(skb, lv);
1607
1608         *skb_transport_header(skb) = AX25_UI;
1609
1610         /* Datagram frames go straight out of the door as UI */
1611         ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1612
1613         err = len;
1614
1615 out:
1616         release_sock(sk);
1617
1618         return err;
1619 }
1620
1621 static int ax25_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1622                         int flags)
1623 {
1624         struct sock *sk = sock->sk;
1625         struct sk_buff *skb;
1626         int copied;
1627         int err = 0;
1628
1629         lock_sock(sk);
1630         /*
1631          *      This works for seqpacket too. The receiver has ordered the
1632          *      queue for us! We do one quick check first though
1633          */
1634         if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1635                 err =  -ENOTCONN;
1636                 goto out;
1637         }
1638
1639         /* Now we can treat all alike */
1640         skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1641                                 flags & MSG_DONTWAIT, &err);
1642         if (skb == NULL)
1643                 goto out;
1644
1645         if (!sk_to_ax25(sk)->pidincl)
1646                 skb_pull(skb, 1);               /* Remove PID */
1647
1648         skb_reset_transport_header(skb);
1649         copied = skb->len;
1650
1651         if (copied > size) {
1652                 copied = size;
1653                 msg->msg_flags |= MSG_TRUNC;
1654         }
1655
1656         skb_copy_datagram_msg(skb, 0, msg, copied);
1657
1658         if (msg->msg_name) {
1659                 ax25_digi digi;
1660                 ax25_address src;
1661                 const unsigned char *mac = skb_mac_header(skb);
1662                 DECLARE_SOCKADDR(struct sockaddr_ax25 *, sax, msg->msg_name);
1663
1664                 memset(sax, 0, sizeof(struct full_sockaddr_ax25));
1665                 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1666                                 &digi, NULL, NULL);
1667                 sax->sax25_family = AF_AX25;
1668                 /* We set this correctly, even though we may not let the
1669                    application know the digi calls further down (because it
1670                    did NOT ask to know them).  This could get political... **/
1671                 sax->sax25_ndigis = digi.ndigi;
1672                 sax->sax25_call   = src;
1673
1674                 if (sax->sax25_ndigis != 0) {
1675                         int ct;
1676                         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1677
1678                         for (ct = 0; ct < digi.ndigi; ct++)
1679                                 fsa->fsa_digipeater[ct] = digi.calls[ct];
1680                 }
1681                 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1682         }
1683
1684         skb_free_datagram(sk, skb);
1685         err = copied;
1686
1687 out:
1688         release_sock(sk);
1689
1690         return err;
1691 }
1692
1693 static int ax25_shutdown(struct socket *sk, int how)
1694 {
1695         /* FIXME - generate DM and RNR states */
1696         return -EOPNOTSUPP;
1697 }
1698
1699 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1700 {
1701         struct sock *sk = sock->sk;
1702         void __user *argp = (void __user *)arg;
1703         int res = 0;
1704
1705         lock_sock(sk);
1706         switch (cmd) {
1707         case TIOCOUTQ: {
1708                 long amount;
1709
1710                 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1711                 if (amount < 0)
1712                         amount = 0;
1713                 res = put_user(amount, (int __user *)argp);
1714                 break;
1715         }
1716
1717         case TIOCINQ: {
1718                 struct sk_buff *skb;
1719                 long amount = 0L;
1720                 /* These two are safe on a single CPU system as only user tasks fiddle here */
1721                 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1722                         amount = skb->len;
1723                 res = put_user(amount, (int __user *) argp);
1724                 break;
1725         }
1726
1727         case SIOCGSTAMP:
1728                 res = sock_get_timestamp(sk, argp);
1729                 break;
1730
1731         case SIOCGSTAMPNS:
1732                 res = sock_get_timestampns(sk, argp);
1733                 break;
1734
1735         case SIOCAX25ADDUID:    /* Add a uid to the uid/call map table */
1736         case SIOCAX25DELUID:    /* Delete a uid from the uid/call map table */
1737         case SIOCAX25GETUID: {
1738                 struct sockaddr_ax25 sax25;
1739                 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1740                         res = -EFAULT;
1741                         break;
1742                 }
1743                 res = ax25_uid_ioctl(cmd, &sax25);
1744                 break;
1745         }
1746
1747         case SIOCAX25NOUID: {   /* Set the default policy (default/bar) */
1748                 long amount;
1749                 if (!capable(CAP_NET_ADMIN)) {
1750                         res = -EPERM;
1751                         break;
1752                 }
1753                 if (get_user(amount, (long __user *)argp)) {
1754                         res = -EFAULT;
1755                         break;
1756                 }
1757                 if (amount < 0 || amount > AX25_NOUID_BLOCK) {
1758                         res = -EINVAL;
1759                         break;
1760                 }
1761                 ax25_uid_policy = amount;
1762                 res = 0;
1763                 break;
1764         }
1765
1766         case SIOCADDRT:
1767         case SIOCDELRT:
1768         case SIOCAX25OPTRT:
1769                 if (!capable(CAP_NET_ADMIN)) {
1770                         res = -EPERM;
1771                         break;
1772                 }
1773                 res = ax25_rt_ioctl(cmd, argp);
1774                 break;
1775
1776         case SIOCAX25CTLCON:
1777                 if (!capable(CAP_NET_ADMIN)) {
1778                         res = -EPERM;
1779                         break;
1780                 }
1781                 res = ax25_ctl_ioctl(cmd, argp);
1782                 break;
1783
1784         case SIOCAX25GETINFO:
1785         case SIOCAX25GETINFOOLD: {
1786                 ax25_cb *ax25 = sk_to_ax25(sk);
1787                 struct ax25_info_struct ax25_info;
1788
1789                 ax25_info.t1        = ax25->t1   / HZ;
1790                 ax25_info.t2        = ax25->t2   / HZ;
1791                 ax25_info.t3        = ax25->t3   / HZ;
1792                 ax25_info.idle      = ax25->idle / (60 * HZ);
1793                 ax25_info.n2        = ax25->n2;
1794                 ax25_info.t1timer   = ax25_display_timer(&ax25->t1timer)   / HZ;
1795                 ax25_info.t2timer   = ax25_display_timer(&ax25->t2timer)   / HZ;
1796                 ax25_info.t3timer   = ax25_display_timer(&ax25->t3timer)   / HZ;
1797                 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1798                 ax25_info.n2count   = ax25->n2count;
1799                 ax25_info.state     = ax25->state;
1800                 ax25_info.rcv_q     = sk_rmem_alloc_get(sk);
1801                 ax25_info.snd_q     = sk_wmem_alloc_get(sk);
1802                 ax25_info.vs        = ax25->vs;
1803                 ax25_info.vr        = ax25->vr;
1804                 ax25_info.va        = ax25->va;
1805                 ax25_info.vs_max    = ax25->vs; /* reserved */
1806                 ax25_info.paclen    = ax25->paclen;
1807                 ax25_info.window    = ax25->window;
1808
1809                 /* old structure? */
1810                 if (cmd == SIOCAX25GETINFOOLD) {
1811                         static int warned = 0;
1812                         if (!warned) {
1813                                 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1814                                         current->comm);
1815                                 warned=1;
1816                         }
1817
1818                         if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1819                                 res = -EFAULT;
1820                                 break;
1821                         }
1822                 } else {
1823                         if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1824                                 res = -EINVAL;
1825                                 break;
1826                         }
1827                 }
1828                 res = 0;
1829                 break;
1830         }
1831
1832         case SIOCAX25ADDFWD:
1833         case SIOCAX25DELFWD: {
1834                 struct ax25_fwd_struct ax25_fwd;
1835                 if (!capable(CAP_NET_ADMIN)) {
1836                         res = -EPERM;
1837                         break;
1838                 }
1839                 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1840                         res = -EFAULT;
1841                         break;
1842                 }
1843                 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1844                 break;
1845         }
1846
1847         case SIOCGIFADDR:
1848         case SIOCSIFADDR:
1849         case SIOCGIFDSTADDR:
1850         case SIOCSIFDSTADDR:
1851         case SIOCGIFBRDADDR:
1852         case SIOCSIFBRDADDR:
1853         case SIOCGIFNETMASK:
1854         case SIOCSIFNETMASK:
1855         case SIOCGIFMETRIC:
1856         case SIOCSIFMETRIC:
1857                 res = -EINVAL;
1858                 break;
1859
1860         default:
1861                 res = -ENOIOCTLCMD;
1862                 break;
1863         }
1864         release_sock(sk);
1865
1866         return res;
1867 }
1868
1869 #ifdef CONFIG_PROC_FS
1870
1871 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1872         __acquires(ax25_list_lock)
1873 {
1874         spin_lock_bh(&ax25_list_lock);
1875         return seq_hlist_start(&ax25_list, *pos);
1876 }
1877
1878 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1879 {
1880         return seq_hlist_next(v, &ax25_list, pos);
1881 }
1882
1883 static void ax25_info_stop(struct seq_file *seq, void *v)
1884         __releases(ax25_list_lock)
1885 {
1886         spin_unlock_bh(&ax25_list_lock);
1887 }
1888
1889 static int ax25_info_show(struct seq_file *seq, void *v)
1890 {
1891         ax25_cb *ax25 = hlist_entry(v, struct ax25_cb, ax25_node);
1892         char buf[11];
1893         int k;
1894
1895
1896         /*
1897          * New format:
1898          * magic dev src_addr dest_addr,digi1,digi2,.. st vs vr va t1 t1 t2 t2 t3 t3 idle idle n2 n2 rtt window paclen Snd-Q Rcv-Q inode
1899          */
1900
1901         seq_printf(seq, "%8.8lx %s %s%s ",
1902                    (long) ax25,
1903                    ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1904                    ax2asc(buf, &ax25->source_addr),
1905                    ax25->iamdigi? "*":"");
1906         seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1907
1908         for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1909                 seq_printf(seq, ",%s%s",
1910                            ax2asc(buf, &ax25->digipeat->calls[k]),
1911                            ax25->digipeat->repeated[k]? "*":"");
1912         }
1913
1914         seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1915                    ax25->state,
1916                    ax25->vs, ax25->vr, ax25->va,
1917                    ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1918                    ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1919                    ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1920                    ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1921                    ax25->idle / (60 * HZ),
1922                    ax25->n2count, ax25->n2,
1923                    ax25->rtt / HZ,
1924                    ax25->window,
1925                    ax25->paclen);
1926
1927         if (ax25->sk != NULL) {
1928                 seq_printf(seq, " %d %d %lu\n",
1929                            sk_wmem_alloc_get(ax25->sk),
1930                            sk_rmem_alloc_get(ax25->sk),
1931                            sock_i_ino(ax25->sk));
1932         } else {
1933                 seq_puts(seq, " * * *\n");
1934         }
1935         return 0;
1936 }
1937
1938 static const struct seq_operations ax25_info_seqops = {
1939         .start = ax25_info_start,
1940         .next = ax25_info_next,
1941         .stop = ax25_info_stop,
1942         .show = ax25_info_show,
1943 };
1944
1945 static int ax25_info_open(struct inode *inode, struct file *file)
1946 {
1947         return seq_open(file, &ax25_info_seqops);
1948 }
1949
1950 static const struct file_operations ax25_info_fops = {
1951         .owner = THIS_MODULE,
1952         .open = ax25_info_open,
1953         .read = seq_read,
1954         .llseek = seq_lseek,
1955         .release = seq_release,
1956 };
1957
1958 #endif
1959
1960 static const struct net_proto_family ax25_family_ops = {
1961         .family =       PF_AX25,
1962         .create =       ax25_create,
1963         .owner  =       THIS_MODULE,
1964 };
1965
1966 static const struct proto_ops ax25_proto_ops = {
1967         .family         = PF_AX25,
1968         .owner          = THIS_MODULE,
1969         .release        = ax25_release,
1970         .bind           = ax25_bind,
1971         .connect        = ax25_connect,
1972         .socketpair     = sock_no_socketpair,
1973         .accept         = ax25_accept,
1974         .getname        = ax25_getname,
1975         .poll           = datagram_poll,
1976         .ioctl          = ax25_ioctl,
1977         .listen         = ax25_listen,
1978         .shutdown       = ax25_shutdown,
1979         .setsockopt     = ax25_setsockopt,
1980         .getsockopt     = ax25_getsockopt,
1981         .sendmsg        = ax25_sendmsg,
1982         .recvmsg        = ax25_recvmsg,
1983         .mmap           = sock_no_mmap,
1984         .sendpage       = sock_no_sendpage,
1985 };
1986
1987 /*
1988  *      Called by socket.c on kernel start up
1989  */
1990 static struct packet_type ax25_packet_type __read_mostly = {
1991         .type   =       cpu_to_be16(ETH_P_AX25),
1992         .func   =       ax25_kiss_rcv,
1993 };
1994
1995 static struct notifier_block ax25_dev_notifier = {
1996         .notifier_call = ax25_device_event,
1997 };
1998
1999 static int __init ax25_init(void)
2000 {
2001         int rc = proto_register(&ax25_proto, 0);
2002
2003         if (rc != 0)
2004                 goto out;
2005
2006         sock_register(&ax25_family_ops);
2007         dev_add_pack(&ax25_packet_type);
2008         register_netdevice_notifier(&ax25_dev_notifier);
2009
2010         proc_create("ax25_route", S_IRUGO, init_net.proc_net,
2011                     &ax25_route_fops);
2012         proc_create("ax25", S_IRUGO, init_net.proc_net, &ax25_info_fops);
2013         proc_create("ax25_calls", S_IRUGO, init_net.proc_net, &ax25_uid_fops);
2014 out:
2015         return rc;
2016 }
2017 module_init(ax25_init);
2018
2019
2020 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2021 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2022 MODULE_LICENSE("GPL");
2023 MODULE_ALIAS_NETPROTO(PF_AX25);
2024
2025 static void __exit ax25_exit(void)
2026 {
2027         remove_proc_entry("ax25_route", init_net.proc_net);
2028         remove_proc_entry("ax25", init_net.proc_net);
2029         remove_proc_entry("ax25_calls", init_net.proc_net);
2030
2031         unregister_netdevice_notifier(&ax25_dev_notifier);
2032
2033         dev_remove_pack(&ax25_packet_type);
2034
2035         sock_unregister(PF_AX25);
2036         proto_unregister(&ax25_proto);
2037
2038         ax25_rt_free();
2039         ax25_uid_free();
2040         ax25_dev_free();
2041 }
2042 module_exit(ax25_exit);