net/ax25/af_ax25.c

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