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