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