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