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