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