root/net/ax25/af_ax25.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. ax2asc
  2. ax25cmp
  3. ax25_remove_socket
  4. ax25_kill_by_device
  5. ax25_device_event
  6. ax25_insert_socket
  7. ax25_find_listener
  8. ax25_find_socket
  9. ax25_find_cb
  10. ax25_addr_match
  11. ax25_send_to_raw
  12. ax25_destroy_timer
  13. ax25_destroy_socket
  14. ax25_findbyuid
  15. ax25_uid_ioctl
  16. ax25_create_cb
  17. ax25_fillin_cb
  18. ax25_send_frame
  19. ax25rtr_get_dev
  20. ax25_fcntl
  21. ax25_setsockopt
  22. ax25_getsockopt
  23. ax25_listen
  24. def_callback1
  25. def_callback2
  26. ax25_create
  27. ax25_make_new
  28. ax25_dup
  29. ax25_release
  30. ax25_bind
  31. ax25_connect
  32. ax25_socketpair
  33. ax25_accept
  34. ax25_getname
  35. ax25_rcv
  36. kiss_rcv
  37. bpq_rcv
  38. ax25_sendmsg
  39. ax25_sendto
  40. ax25_send
  41. ax25_write
  42. ax25_recvmsg
  43. ax25_recvfrom
  44. ax25_recv
  45. ax25_read
  46. ax25_shutdown
  47. ax25_select
  48. ax25_ioctl
  49. ax25_get_info
  50. ax25_proto_init
  51. ax25_queue_xmit
  52. ax25_encapsulate
  53. ax25_rebuild_header

   1 /*
   2  *      AX.25 release 030
   3  *
   4  *      This is ALPHA test software. This code may break your machine, randomly fail to work with new 
   5  *      releases, misbehave and/or generally screw up. It might even work. 
   6  *
   7  *      This code REQUIRES 1.2.1 or higher/ NET3.029
   8  *
   9  *      This module:
  10  *              This module is free software; you can redistribute it and/or
  11  *              modify it under the terms of the GNU General Public License
  12  *              as published by the Free Software Foundation; either version
  13  *              2 of the License, or (at your option) any later version.
  14  *
  15  *      History
  16  *      AX.25 006       Alan(GW4PTS)            Nearly died of shock - its working 8-)
  17  *      AX.25 007       Alan(GW4PTS)            Removed the silliest bugs
  18  *      AX.25 008       Alan(GW4PTS)            Cleaned up, fixed a few state machine problems, added callbacks
  19  *      AX.25 009       Alan(GW4PTS)            Emergency patch kit to fix memory corruption
  20  *      AX.25 010       Alan(GW4PTS)            Added RAW sockets/Digipeat.
  21  *      AX.25 011       Alan(GW4PTS)            RAW socket and datagram fixes (thanks) - Raw sendto now gets PID right
  22  *                                              datagram sendto uses correct target address.
  23  *      AX.25 012       Alan(GW4PTS)            Correct incoming connection handling, send DM to failed connects.
  24  *                                              Use skb->data not skb+1. Support sk->priority correctly.
  25  *                                              Correct receive on SOCK_DGRAM.
  26  *      AX.25 013       Alan(GW4PTS)            Send DM to all unknown frames, missing initialiser fixed
  27  *                                              Leave spare SSID bits set (DAMA etc) - thanks for bug report,
  28  *                                              removed device registration (its not used or needed). Clean up for
  29  *                                              gcc 2.5.8. PID to AX25_P_
  30  *      AX.25 014       Alan(GW4PTS)            Cleanup and NET3 merge
  31  *      AX.25 015       Alan(GW4PTS)            Internal test version.
  32  *      AX.25 016       Alan(GW4PTS)            Semi Internal version for PI card
  33  *                                              work.
  34  *      AX.25 017       Alan(GW4PTS)            Fixed some small bugs reported by
  35  *                                              G4KLX
  36  *      AX.25 018       Alan(GW4PTS)            Fixed a small error in SOCK_DGRAM
  37  *      AX.25 019       Alan(GW4PTS)            Clean ups for the non INET kernel and device ioctls in AX.25
  38  *      AX.25 020       Jonathan(G4KLX)         /proc support and other changes.
  39  *      AX.25 021       Alan(GW4PTS)            Added AX25_T1, AX25_N2, AX25_T3 as requested.
  40  *      AX.25 022       Jonathan(G4KLX)         More work on the ax25 auto router and /proc improved (again)!
  41  *                      Alan(GW4PTS)            Added TIOCINQ/OUTQ
  42  *      AX.25 023       Alan(GW4PTS)            Fixed shutdown bug
  43  *      AX.25 023       Alan(GW4PTS)            Linus changed timers
  44  *      AX.25 024       Alan(GW4PTS)            Small bug fixes
  45  *      AX.25 025       Alan(GW4PTS)            More fixes, Linux 1.1.51 compatibility stuff, timers again!
  46  *      AX.25 026       Alan(GW4PTS)            Small state fix.
  47  *      AX.25 027       Alan(GW4PTS)            Socket close crash fixes.
  48  *      AX.25 028       Alan(GW4PTS)            Callsign control including settings per uid.
  49  *                                              Small bug fixes.
  50  *                                              Protocol set by sockets only.
  51  *                                              Small changes to allow for start of NET/ROM layer.
  52  *      AX.25 028a      Jonathan(G4KLX)         Changes to state machine.
  53  *      AX.25 028b      Jonathan(G4KLX)         Extracted ax25 control block
  54  *                                              from sock structure.
  55  *      AX.25 029       Alan(GW4PTS)            Combined 028b and some KA9Q code
  56  *                      Jonathan(G4KLX)         and removed all the old Berkeley, added IP mode registration.
  57  *                      Darryl(G7LED)           stuff. Cross-port digipeating. Minor fixes and enhancements.
  58  *                      Alan(GW4PTS)            Missed suser() on axassociate checks
  59  *      AX.25 030       Alan(GW4PTS)            Added variable length headers.
  60  *                      Jonathan(G4KLX)         Added BPQ Ethernet interface.
  61  *                      Steven(GW7RRM)          Added digi-peating control ioctl.
  62  *                                              Added extended AX.25 support.
  63  *                                              Added AX.25 frame segmentation.
  64  *                      Darryl(G7LED)           Changed connect(), recvfrom(), sendto() sockaddr/addrlen to
  65  *                                              fall inline with bind() and new policy.
  66  *                                              Moved digipeating ctl to new ax25_dev structs.
  67  *                                              Fixed ax25_release(), set TCP_CLOSE, wakeup app
  68  *                                              context, THEN make the sock dead.
  69  *
  70  *      To do:
  71  *              Restructure the ax25_rcv code to be cleaner/faster and
  72  *              copy only when needed.
  73  *              Consider better arbitary protocol support.
  74  */
  75  
  76 #include <linux/config.h>
  77 #ifdef CONFIG_AX25
  78 #include <linux/errno.h>
  79 #include <linux/types.h>
  80 #include <linux/socket.h>
  81 #include <linux/in.h>
  82 #include <linux/kernel.h>
  83 #include <linux/sched.h>
  84 #include <linux/timer.h>
  85 #include <linux/string.h>
  86 #include <linux/sockios.h>
  87 #include <linux/net.h>
  88 #include <net/ax25.h>
  89 #include <linux/inet.h>
  90 #include <linux/netdevice.h>
  91 #include <linux/if_arp.h>
  92 #include <linux/skbuff.h>
  93 #include <net/sock.h>
  94 #include <asm/segment.h>
  95 #include <asm/system.h>
  96 #include <linux/fcntl.h>
  97 #include <linux/termios.h>      /* For TIOCINQ/OUTQ */
  98 #include <linux/mm.h>
  99 #include <linux/interrupt.h>
 100 #include <linux/notifier.h>
 101 #include <linux/proc_fs.h>
 102 #include <linux/stat.h>
 103 
 104 #include <net/ip.h>
 105 #include <net/arp.h>
 106 
 107 
 108 /**********************************************************************************************************************\
 109 *                                                                                                                      *
 110 *                                               Handlers for the socket list.                                          *
 111 *                                                                                                                      *
 112 \**********************************************************************************************************************/
 113 
 114 static ax25_cb *volatile ax25_list = NULL;
 115 
 116 /*
 117  *      ax25 -> ascii conversion
 118  */
 119 char *ax2asc(ax25_address *a)
     /* [previous][next][first][last][top][bottom][index][help] */
 120 {
 121         static char buf[11];
 122         char c, *s;
 123         int n;
 124 
 125         for (n = 0, s = buf; n < 6; n++)
 126         {
 127                 c = (a->ax25_call[n] >> 1) & 0x7F;
 128 
 129                 if (c != ' ') *s++ = c;
 130         }
 131         
 132         *s++ = '-';
 133 
 134         if ((n = ((a->ax25_call[6] >> 1) & 0x0F)) > 9)
 135         {
 136                 *s++ = '1';
 137                 n -= 10;
 138         }
 139         
 140         *s++ = n + '0';
 141         *s++ = '\0';
 142 
 143         if (*buf == '\0' || *buf == '-')
 144            return "*";
 145 
 146         return buf;
 147 
 148 }
 149 
 150 /*
 151  *      Compare two ax.25 addresses
 152  */
 153 int ax25cmp(ax25_address *a, ax25_address *b)
     /* [previous][next][first][last][top][bottom][index][help] */
 154 {
 155         int ct = 0;
 156 
 157         while (ct < 6) {
 158                 if ((a->ax25_call[ct] & 0xFE) != (b->ax25_call[ct] & 0xFE))     /* Clean off repeater bits */
 159                         return 1;
 160                 ct++;
 161         }
 162 
 163         if ((a->ax25_call[ct] & 0x1E) == (b->ax25_call[ct] & 0x1E))     /* SSID without control bit */
 164                 return 0;
 165 
 166         return 2;                       /* Partial match */
 167 }
 168 
 169 /*
 170  *      Socket removal during an interrupt is now safe.
 171  */
 172 static void ax25_remove_socket(ax25_cb *ax25)
     /* [previous][next][first][last][top][bottom][index][help] */
 173 {
 174         ax25_cb *s;
 175         unsigned long flags;
 176         
 177         save_flags(flags);
 178         cli();
 179 
 180         if ((s = ax25_list) == ax25) {
 181                 ax25_list = s->next;
 182                 restore_flags(flags);
 183                 return;
 184         }
 185 
 186         while (s != NULL && s->next != NULL) {
 187                 if (s->next == ax25) {
 188                         s->next = ax25->next;
 189                         restore_flags(flags);
 190                         return;
 191                 }
 192 
 193                 s = s->next;
 194         }
 195 
 196         restore_flags(flags);
 197 }
 198 
 199 /*
 200  *      Kill all bound sockets on a dropped device.
 201  */
 202 static void ax25_kill_by_device(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 203 {
 204         ax25_cb *s;
 205         
 206         for (s = ax25_list; s != NULL; s = s->next) {
 207                 if (s->device == dev) {
 208                         s->state  = AX25_STATE_0;
 209                         s->device = NULL;
 210                         if (s->sk != NULL) {
 211                                 s->sk->state = TCP_CLOSE;
 212                                 s->sk->err   = ENETUNREACH;
 213                                 if (!s->sk->dead)
 214                                         s->sk->state_change(s->sk);
 215                                 s->sk->dead  = 1;
 216                         }
 217                 }
 218         }
 219 }
 220 
 221 /*
 222  *      Handle device status changes.
 223  */
 224 static int ax25_device_event(unsigned long event, void *ptr)
     /* [previous][next][first][last][top][bottom][index][help] */
 225 {
 226         struct device *dev = (struct device *)ptr;
 227 
 228         switch (event) {
 229                 case NETDEV_UP:
 230                         ax25_dev_device_up(dev);
 231                         break;
 232                 case NETDEV_DOWN:
 233                         ax25_kill_by_device(dev);
 234                         ax25_rt_device_down(dev);
 235                         ax25_dev_device_down(dev);
 236                         break;
 237                 default:
 238                         break;
 239         }
 240 
 241         return NOTIFY_DONE;
 242 }
 243 
 244 /*
 245  *      Add a socket to the bound sockets list.
 246  */
 247 static void ax25_insert_socket(ax25_cb *ax25)
     /* [previous][next][first][last][top][bottom][index][help] */
 248 {
 249         unsigned long flags;
 250 
 251         save_flags(flags);
 252         cli();
 253 
 254         ax25->next = ax25_list;
 255         ax25_list  = ax25;
 256 
 257         restore_flags(flags);
 258 }
 259 
 260 /*
 261  *      Find a socket that wants to accept the SABM we just
 262  *      received.
 263  */
 264 static struct sock *ax25_find_listener(ax25_address *addr, struct device *dev, int type)
     /* [previous][next][first][last][top][bottom][index][help] */
 265 {
 266         unsigned long flags;
 267         ax25_cb *s;
 268 
 269         save_flags(flags);
 270         cli();
 271 
 272         for (s = ax25_list; s != NULL; s = s->next) {
 273                 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 && s->sk->type == type && s->sk->state == TCP_LISTEN) {
 274                         /* If device is null we match any device */
 275                         if (s->device == NULL || s->device == dev) {
 276                                 restore_flags(flags);
 277                                 return s->sk;
 278                         }
 279                 }
 280         }
 281 
 282         restore_flags(flags);
 283         return NULL;
 284 }
 285 
 286 /*
 287  *      Find an AX.25 socket given both ends.
 288  */
 289 static struct sock *ax25_find_socket(ax25_address *my_addr, ax25_address *dest_addr, int type)
     /* [previous][next][first][last][top][bottom][index][help] */
 290 {
 291         ax25_cb *s;
 292         unsigned long flags;
 293 
 294         save_flags(flags);
 295         cli();
 296 
 297         for (s = ax25_list; s != NULL; s = s->next) {
 298                 if (s->sk != NULL && ax25cmp(&s->source_addr, my_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->sk->type == type) {
 299                         restore_flags(flags);
 300                         return s->sk;
 301                 }
 302         }
 303 
 304         restore_flags(flags);
 305 
 306         return NULL;
 307 }
 308 
 309 /*
 310  *      Find an AX.25 control block given both ends. It will only pick up
 311  *      floating AX.25 control blocks or non Raw socket bound control blocks.
 312  */
 313 static ax25_cb *ax25_find_cb(ax25_address *my_addr, ax25_address *dest_addr, struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 314 {
 315         ax25_cb *s;
 316         unsigned long flags;
 317 
 318         save_flags(flags);
 319         cli();
 320 
 321         for (s = ax25_list; s != NULL; s = s->next) {
 322                 if (s->sk != NULL && s->sk->type != SOCK_SEQPACKET)
 323                         continue;
 324                 if (ax25cmp(&s->source_addr, my_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->device == dev) {
 325                         restore_flags(flags);
 326                         return s;
 327                 }
 328         }
 329 
 330         restore_flags(flags);
 331 
 332         return NULL;
 333 }
 334 
 335 /*
 336  *      Look for any matching address - RAW sockets can bind to arbitary names
 337  */
 338 static struct sock *ax25_addr_match(ax25_address *addr)
     /* [previous][next][first][last][top][bottom][index][help] */
 339 {
 340         unsigned long flags;
 341         ax25_cb *s;
 342 
 343         save_flags(flags);
 344         cli();
 345 
 346         for (s = ax25_list; s != NULL; s = s->next) {
 347                 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 && s->sk->type == SOCK_RAW) {
 348                         restore_flags(flags);
 349                         return s->sk;
 350                 }
 351         }
 352 
 353         restore_flags(flags);
 354 
 355         return NULL;
 356 }
 357 
 358 static void ax25_send_to_raw(struct sock *sk, struct sk_buff *skb, int proto)
     /* [previous][next][first][last][top][bottom][index][help] */
 359 {
 360         struct sk_buff *copy;
 361         
 362         while (sk != NULL) {
 363                 if (sk->type == SOCK_RAW && sk->protocol == proto && sk->rmem_alloc <= sk->rcvbuf) {
 364                         if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
 365                                 return;
 366 
 367                         copy->sk = sk;
 368                         sk->rmem_alloc += copy->truesize;
 369                         skb_queue_tail(&sk->receive_queue, copy);
 370                         if (!sk->dead)
 371                                 sk->data_ready(sk, skb->len);
 372                 }
 373 
 374                 sk = sk->next;
 375         }
 376 }       
 377 
 378 /*
 379  *      Deferred destroy.
 380  */
 381 void ax25_destory_socket(ax25_cb *);
 382 
 383 /*
 384  *      Handler for deferred kills.
 385  */
 386 static void ax25_destroy_timer(unsigned long data)
     /* [previous][next][first][last][top][bottom][index][help] */
 387 {
 388         ax25_destroy_socket((ax25_cb *)data);
 389 }
 390 
 391 /*
 392  *      This is called from user mode and the timers. Thus it protects itself against
 393  *      interrupt users but doesn't worry about being called during work.
 394  *      Once it is removed from the queue no interrupt or bottom half will
 395  *      touch it and we are (fairly 8-) ) safe.
 396  */
 397 void ax25_destroy_socket(ax25_cb *ax25) /* Not static as its used by the timer */
     /* [previous][next][first][last][top][bottom][index][help] */
 398 {
 399         struct sk_buff *skb;
 400         unsigned long flags;
 401         
 402         save_flags(flags);
 403         cli();
 404         
 405         del_timer(&ax25->timer);
 406         
 407         ax25_remove_socket(ax25);
 408         ax25_clear_queues(ax25);        /* Flush the queues */
 409         
 410         if (ax25->sk != NULL) {
 411                 while ((skb = skb_dequeue(&ax25->sk->receive_queue)) != NULL) {
 412                         if (skb->sk != ax25->sk) {                      /* A pending connection */
 413                                 skb->sk->dead = 1;      /* Queue the unaccepted socket for death */
 414                                 ax25_set_timer(skb->sk->ax25);
 415                                 skb->sk->ax25->state = AX25_STATE_0;
 416                         }
 417 
 418                         kfree_skb(skb, FREE_READ);
 419                 }
 420         }
 421         
 422         if (ax25->digipeat != NULL) {
 423                 kfree_s(ax25->digipeat, sizeof(ax25_digi));
 424                 ax25->digipeat = NULL;
 425         }
 426 
 427         if (ax25->sk != NULL) {
 428                 if (ax25->sk->wmem_alloc || ax25->sk->rmem_alloc) { /* Defer: outstanding buffers */
 429                         init_timer(&ax25->timer);
 430                         ax25->timer.expires  = jiffies + 10 * HZ;
 431                         ax25->timer.function = ax25_destroy_timer;
 432                         ax25->timer.data     = (unsigned long)ax25;
 433                         add_timer(&ax25->timer);
 434                 } else {
 435                         kfree_s(ax25->sk, sizeof(*ax25->sk));
 436                         kfree_s(ax25, sizeof(*ax25));
 437                 }
 438         } else {
 439                 kfree_s(ax25, sizeof(*ax25));
 440         }
 441 
 442         restore_flags(flags);
 443 }
 444 
 445 /*
 446  *      Callsign/UID mapper. This is in kernel space for security on multi-amateur machines.
 447  */
 448 
 449 ax25_uid_assoc *ax25_uid_list;
 450 
 451 int ax25_uid_policy = 0;
 452 
 453 ax25_address *ax25_findbyuid(uid_t uid)
     /* [previous][next][first][last][top][bottom][index][help] */
 454 {
 455         ax25_uid_assoc *a;
 456         
 457         for (a = ax25_uid_list; a != NULL; a = a->next) {
 458                 if (a->uid == uid)
 459                         return &a->call;
 460         }
 461 
 462         return NULL;
 463 }
 464 
 465 static int ax25_uid_ioctl(int cmd, struct sockaddr_ax25 *sax)
     /* [previous][next][first][last][top][bottom][index][help] */
 466 {
 467         ax25_uid_assoc *a;
 468         
 469         switch (cmd) {
 470                 case SIOCAX25GETUID:
 471                         for (a = ax25_uid_list; a != NULL; a = a->next) {
 472                                 if (ax25cmp(&sax->sax25_call, &a->call) == 0)
 473                                         return a->uid;
 474                         }
 475                         return -ENOENT;
 476                 case SIOCAX25ADDUID:
 477                         if(!suser())
 478                                 return -EPERM;
 479                         if (ax25_findbyuid(sax->sax25_uid))
 480                                 return -EEXIST;
 481                         a = (ax25_uid_assoc *)kmalloc(sizeof(*a), GFP_KERNEL);
 482                         if (a == NULL)
 483                                 return -ENOMEM;
 484                         a->uid  = sax->sax25_uid;
 485                         a->call = sax->sax25_call;
 486                         a->next = ax25_uid_list;
 487                         ax25_uid_list = a;
 488                         return 0;
 489                 case SIOCAX25DELUID:
 490                 {
 491                         ax25_uid_assoc **l;
 492                         
 493                         if(!suser())
 494                                 return -EPERM;
 495                         l = &ax25_uid_list;
 496                         while ((*l) != NULL) {
 497                                 if (ax25cmp(&((*l)->call), &(sax->sax25_call)) == 0) {
 498                                         a = *l;
 499                                         *l = (*l)->next;
 500                                         kfree_s(a, sizeof(*a));
 501                                         return 0;
 502                                 }
 503                                 
 504                                 l = &((*l)->next);
 505                         }
 506                         return -ENOENT;
 507                 }
 508         }
 509 
 510         return -EINVAL; /*NOTREACHED */
 511 }       
 512 
 513 /*
 514  * Create an empty AX.25 control block.
 515  */
 516 static ax25_cb *ax25_create_cb(void)
     /* [previous][next][first][last][top][bottom][index][help] */
 517 {
 518         ax25_cb *ax25;
 519 
 520         if ((ax25 = (ax25_cb *)kmalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
 521                 return NULL;
 522 
 523         skb_queue_head_init(&ax25->write_queue);
 524         skb_queue_head_init(&ax25->frag_queue);
 525         skb_queue_head_init(&ax25->ack_queue);
 526         skb_queue_head_init(&ax25->reseq_queue);
 527 
 528         init_timer(&ax25->timer);
 529 
 530         ax25->rtt     = (AX25_DEF_T1 * PR_SLOWHZ) / 2;
 531         ax25->t1      = AX25_DEF_T1 * PR_SLOWHZ;
 532         ax25->t2      = AX25_DEF_T2 * PR_SLOWHZ;
 533         ax25->t3      = AX25_DEF_T3 * PR_SLOWHZ;
 534         ax25->n2      = AX25_DEF_N2;
 535 
 536         ax25->modulus   = AX25_DEF_AXDEFMODE;
 537         ax25->fragno    = 0;
 538         ax25->fraglen   = 0;
 539         ax25->hdrincl   = 0;
 540         ax25->backoff   = AX25_DEF_BACKOFF == 'E';
 541         ax25->condition = 0x00;
 542         ax25->t1timer   = 0;
 543         ax25->t2timer   = 0;
 544         ax25->t3timer   = 0;
 545         ax25->n2count   = 0;
 546 
 547         ax25->va      = 0;
 548         ax25->vr      = 0;
 549         ax25->vs      = 0;
 550 
 551         if (AX25_DEF_AXDEFMODE == EMODULUS) {
 552                 ax25->window = AX25_DEF_EWINDOW;
 553         } else {
 554                 ax25->window = AX25_DEF_WINDOW;
 555         }
 556         ax25->device   = NULL;
 557         ax25->digipeat = NULL;
 558         ax25->sk       = NULL;
 559 
 560         ax25->state    = AX25_STATE_0;
 561 
 562         memset(&ax25->dest_addr,   '\0', sizeof(ax25_address));
 563         memset(&ax25->source_addr, '\0', sizeof(ax25_address));
 564 
 565         return ax25;
 566 }
 567 
 568 /*
 569  *      Fill in a created AX.25 created control block with the default
 570  *      values for a particular device.
 571  */
 572 static void ax25_fillin_cb(ax25_cb *ax25, struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 573 {
 574         ax25->device = dev;
 575 
 576         ax25->rtt = ax25_dev_get_value(dev, AX25_VALUES_T1);
 577         ax25->t1  = ax25_dev_get_value(dev, AX25_VALUES_T1);
 578         ax25->t2  = ax25_dev_get_value(dev, AX25_VALUES_T2);
 579         ax25->t3  = ax25_dev_get_value(dev, AX25_VALUES_T3);
 580         ax25->n2  = ax25_dev_get_value(dev, AX25_VALUES_N2);
 581 
 582         ax25->modulus = ax25_dev_get_value(dev, AX25_VALUES_AXDEFMODE);
 583 
 584         if (ax25->modulus == MODULUS) {
 585                 ax25->window = ax25_dev_get_value(dev, AX25_VALUES_WINDOW);
 586         } else {
 587                 ax25->window = ax25_dev_get_value(dev, AX25_VALUES_EWINDOW);
 588         }
 589 
 590         ax25->backoff = ax25_dev_get_value(dev, AX25_VALUES_BACKOFF) == 'E';
 591 }
 592 
 593 int ax25_send_frame(struct sk_buff *skb, ax25_address *src, ax25_address *dest,
     /* [previous][next][first][last][top][bottom][index][help] */
 594         ax25_digi *digi, struct device *dev)
 595 {
 596         ax25_cb *ax25;
 597 
 598         if (skb == NULL)
 599                 return 0;
 600 
 601         /*
 602          * Look for an existing connection.
 603          */
 604         for (ax25 = ax25_list; ax25 != NULL; ax25 = ax25->next) {
 605                 if (ax25->sk != NULL && ax25->sk->type != SOCK_SEQPACKET)
 606                         continue;
 607 
 608                 if (ax25cmp(&ax25->source_addr, src) == 0 && ax25cmp(&ax25->dest_addr, dest) == 0 && ax25->device == dev) {
 609                         ax25_output(ax25, skb);
 610                         return 1;               /* It already existed */
 611                 }
 612         }
 613 
 614         if ((ax25 = ax25_create_cb()) == NULL)
 615                 return 0;
 616 
 617         ax25_fillin_cb(ax25, dev);
 618 
 619         memcpy(&ax25->source_addr, src,  sizeof(ax25_address));
 620         memcpy(&ax25->dest_addr,   dest, sizeof(ax25_address));
 621 
 622         if (digi != NULL) {
 623                 if ((ax25->digipeat = kmalloc(sizeof(ax25_digi), GFP_ATOMIC)) == NULL) {
 624                         kfree_s(ax25, sizeof(ax25));
 625                         return 0;
 626                 }
 627                 memcpy(ax25->digipeat, digi, sizeof(ax25_digi));
 628         }
 629 
 630         ax25_establish_data_link(ax25);
 631         ax25_insert_socket(ax25);
 632 
 633         ax25->state = AX25_STATE_1;
 634 
 635         ax25_set_timer(ax25);
 636 
 637         ax25_output(ax25, skb);
 638                         
 639         return 1;                       /* We had to create it */       
 640 }
 641 
 642 /*******************************************************************************************************************\
 643 *                                                                                                                   *
 644 *               Routing rules for AX.25: Basically iterate over the active interfaces                               *
 645 *                                                                                                                   *
 646 \*******************************************************************************************************************/
 647 
 648 struct device *ax25rtr_get_dev(ax25_address *addr)
     /* [previous][next][first][last][top][bottom][index][help] */
 649 {
 650         struct device *dev;
 651         ax25_address dev_addr;
 652         
 653         for (dev = dev_base; dev != NULL; dev = dev->next) {
 654                 if (dev->flags & IFF_UP) {
 655                         switch (dev->type) {
 656                                 case ARPHRD_AX25: /* Active kiss ax25 mode */ 
 657                                         if (ax25cmp(addr, (ax25_address *)dev->dev_addr) == 0)
 658                                                 return dev;
 659                                         break;
 660                                 case ARPHRD_ETHER:
 661                                         if (arp_query((unsigned char *)&dev_addr, dev->pa_addr, ARPHRD_AX25))
 662                                                 if (ax25cmp(addr, &dev_addr) == 0)
 663                                                         return dev;
 664                                         break;
 665                                 default:
 666                                         break;
 667                         }
 668                 }
 669         }
 670 
 671         return NULL;
 672 }
 673 
 674 /*******************************************************************************************************************\
 675 *                                                                                                                   *
 676 *             Handling for system calls applied via the various interfaces to an AX25 socket object                 *
 677 *                                                                                                                   *
 678 \*******************************************************************************************************************/
 679  
 680 static int ax25_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
     /* [previous][next][first][last][top][bottom][index][help] */
 681 {
 682         switch(cmd)
 683         {
 684                 default:
 685                         return(-EINVAL);
 686         }
 687 }
 688 
 689 static int ax25_setsockopt(struct socket *sock, int level, int optname,
     /* [previous][next][first][last][top][bottom][index][help] */
 690         char *optval, int optlen)
 691 {
 692         struct sock *sk;
 693         int err, opt;
 694 
 695         sk = (struct sock *)sock->data;
 696         
 697         if (level == SOL_SOCKET)
 698                 return sock_setsockopt(sk, level, optname, optval, optlen);
 699 
 700         if (level != SOL_AX25)
 701                 return -EOPNOTSUPP;
 702 
 703         if (optval == NULL)
 704                 return -EINVAL;
 705 
 706         if ((err = verify_area(VERIFY_READ, optval, sizeof(int))) != 0)
 707                 return err;
 708 
 709         opt = get_fs_long((unsigned long *)optval);
 710 
 711         switch (optname) {
 712                 case AX25_WINDOW:
 713                         if (sk->ax25->modulus == MODULUS) {
 714                                 if (opt < 1 || opt > 7)
 715                                         return -EINVAL;
 716                         } else {
 717                                 if (opt < 1 || opt > 63)
 718                                         return -EINVAL;
 719                         }
 720                         sk->ax25->window = opt;
 721                         return 0;
 722 
 723                 case AX25_T1:
 724                         if (opt < 1)
 725                                 return -EINVAL;
 726                         sk->ax25->rtt = (opt * PR_SLOWHZ) / 2;
 727                         return 0;
 728 
 729                 case AX25_T2:
 730                         if (opt < 1)
 731                                 return -EINVAL;
 732                         sk->ax25->t2 = opt * PR_SLOWHZ;
 733                         return 0;
 734 
 735                 case AX25_N2:
 736                         if (opt < 1 || opt > 31)
 737                                 return -EINVAL;
 738                         sk->ax25->n2 = opt;
 739                         return 0;
 740 
 741                 case AX25_T3:
 742                         if (opt < 1)
 743                                 return -EINVAL;
 744                         sk->ax25->t3 = opt * PR_SLOWHZ;
 745                         return 0;
 746 
 747                 case AX25_BACKOFF:
 748                         sk->ax25->backoff = opt ? 1 : 0;
 749                         return 0;
 750 
 751                 case AX25_EXTSEQ:
 752                         sk->ax25->modulus = opt ? EMODULUS : MODULUS;
 753                         return 0;
 754 
 755                 case AX25_HDRINCL:
 756                         sk->ax25->hdrincl = opt ? 1 : 0;
 757                         return 0;
 758 
 759                 default:
 760                         return -ENOPROTOOPT;
 761         }
 762 }
 763 
 764 static int ax25_getsockopt(struct socket *sock, int level, int optname,
     /* [previous][next][first][last][top][bottom][index][help] */
 765         char *optval, int *optlen)
 766 {
 767         struct sock *sk;
 768         int val = 0;
 769         int err; 
 770 
 771         sk = (struct sock *)sock->data;
 772         
 773         if (level == SOL_SOCKET)
 774                 return sock_getsockopt(sk, level, optname, optval, optlen);
 775         
 776         if (level != SOL_AX25)
 777                 return -EOPNOTSUPP;
 778 
 779         switch (optname) {
 780                 case AX25_WINDOW:
 781                         val = sk->ax25->window;
 782                         break;
 783 
 784                 case AX25_T1:
 785                         val = (sk->ax25->t1 * 2) / PR_SLOWHZ;
 786                         break;
 787 
 788                 case AX25_T2:
 789                         val = sk->ax25->t2 / PR_SLOWHZ;
 790                         break;
 791 
 792                 case AX25_N2:
 793                         val = sk->ax25->n2;
 794                         break;
 795 
 796                 case AX25_T3:
 797                         val = sk->ax25->t3 / PR_SLOWHZ;
 798                         break;
 799 
 800                 case AX25_BACKOFF:
 801                         val = sk->ax25->backoff;
 802                         break;
 803 
 804                 case AX25_EXTSEQ:
 805                         val = (sk->ax25->modulus == EMODULUS);
 806                         break;
 807 
 808                 case AX25_HDRINCL:
 809                         val = sk->ax25->hdrincl;
 810                         break;
 811 
 812                 default:
 813                         return -ENOPROTOOPT;
 814         }
 815 
 816         if ((err = verify_area(VERIFY_WRITE, optlen, sizeof(int))) != 0)
 817                 return err;
 818 
 819         put_user(sizeof(int), optlen);
 820 
 821         if ((err = verify_area(VERIFY_WRITE, optval, sizeof(int))) != 0)
 822                 return err;
 823 
 824         put_user(val, optval);
 825 
 826         return 0;
 827 }
 828 
 829 static int ax25_listen(struct socket *sock, int backlog)
     /* [previous][next][first][last][top][bottom][index][help] */
 830 {
 831         struct sock *sk = (struct sock *)sock->data;
 832 
 833         if (sk->type == SOCK_SEQPACKET && sk->state != TCP_LISTEN) {
 834                 sk->max_ack_backlog = backlog;
 835                 sk->state           = TCP_LISTEN;
 836                 return 0;
 837         }
 838 
 839         return -EOPNOTSUPP;
 840 }
 841 
 842 static void def_callback1(struct sock *sk)
     /* [previous][next][first][last][top][bottom][index][help] */
 843 {
 844         if (!sk->dead)
 845                 wake_up_interruptible(sk->sleep);
 846 }
 847 
 848 static void def_callback2(struct sock *sk, int len)
     /* [previous][next][first][last][top][bottom][index][help] */
 849 {
 850         if (!sk->dead)
 851                 wake_up_interruptible(sk->sleep);
 852 }
 853 
 854 static int ax25_create(struct socket *sock, int protocol)
     /* [previous][next][first][last][top][bottom][index][help] */
 855 {
 856         struct sock *sk;
 857         ax25_cb *ax25;
 858 
 859         switch (sock->type) {
 860                 case SOCK_DGRAM:
 861                         if (protocol == 0 || protocol == AF_AX25)
 862                                 protocol = AX25_P_TEXT;
 863                         break;
 864                 case SOCK_SEQPACKET:
 865                         switch (protocol) {
 866                                 case 0:
 867                                 case AF_AX25:   /* For CLX */
 868                                         protocol = AX25_P_TEXT;
 869                                         break;
 870                                 case AX25_P_SEGMENT:
 871 #ifdef CONFIG_INET
 872                                 case AX25_P_ARP:
 873                                 case AX25_P_IP:
 874 #endif
 875 #ifdef CONFIG_NETROM
 876                                 case AX25_P_NETROM:
 877 #endif
 878                                         return -ESOCKTNOSUPPORT;
 879                                 default:
 880                                         break;
 881                         }
 882                         break;
 883                 case SOCK_RAW:
 884                         break;
 885                 default:
 886                         return -ESOCKTNOSUPPORT;
 887         }
 888 
 889         if ((sk = (struct sock *)kmalloc(sizeof(*sk), GFP_ATOMIC)) == NULL)
 890                 return -ENOMEM;
 891 
 892         if ((ax25 = ax25_create_cb()) == NULL) {
 893                 kfree_s(sk, sizeof(*sk));
 894                 return -ENOMEM;
 895         }
 896 
 897         skb_queue_head_init(&sk->receive_queue);
 898         skb_queue_head_init(&sk->write_queue);
 899         skb_queue_head_init(&sk->back_log);
 900 
 901         sk->socket        = sock;
 902         sk->type          = sock->type;
 903         sk->protocol      = protocol;
 904         sk->dead          = 0;
 905         sk->next          = NULL;
 906         sk->broadcast     = 0;
 907         sk->allocation    = GFP_KERNEL;
 908         sk->rcvbuf        = SK_RMEM_MAX;
 909         sk->sndbuf        = SK_WMEM_MAX;
 910         sk->wmem_alloc    = 0;
 911         sk->rmem_alloc    = 0;
 912         sk->inuse         = 0;
 913         sk->debug         = 0;
 914         sk->destroy       = 0;
 915         sk->prot          = NULL;       /* So we use default free mechanisms */
 916         sk->err           = 0;
 917         sk->localroute    = 0;
 918         sk->send_head     = NULL;
 919         sk->state         = TCP_CLOSE;
 920         sk->shutdown      = 0;
 921         sk->priority      = SOPRI_NORMAL;
 922         sk->ack_backlog   = 0;
 923         sk->mtu           = AX25_MTU;   /* 256 */
 924         sk->zapped        = 1;
 925 
 926         sk->state_change = def_callback1;
 927         sk->data_ready   = def_callback2;
 928         sk->write_space  = def_callback1;
 929         sk->error_report = def_callback1;
 930 
 931         if (sock != NULL) {
 932                 sock->data = (void *)sk;
 933                 sk->sleep  = sock->wait;
 934         }
 935 
 936         ax25->sk = sk;
 937         sk->ax25 = ax25;
 938         
 939         return 0;
 940 }
 941 
 942 static struct sock *ax25_make_new(struct sock *osk, struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 943 {
 944         struct sock *sk;
 945         ax25_cb *ax25;
 946 
 947         if ((sk = (struct sock *)kmalloc(sizeof(*sk), GFP_ATOMIC)) == NULL)
 948                 return NULL;
 949 
 950         if ((ax25 = ax25_create_cb()) == NULL) {
 951                 kfree_s(sk, sizeof(*sk));
 952                 return NULL;
 953         }
 954 
 955         ax25_fillin_cb(ax25, dev);
 956 
 957         sk->type   = osk->type;
 958         sk->socket = osk->socket;
 959 
 960         switch(osk->type)
 961         {
 962                 case SOCK_DGRAM:
 963                         break;
 964                 case SOCK_SEQPACKET:
 965                         break;
 966                 default:
 967                         kfree_s((void *)sk, sizeof(*sk));
 968                         kfree_s((void *)ax25, sizeof(*ax25));
 969                         return NULL;
 970         }
 971 
 972         skb_queue_head_init(&sk->receive_queue);
 973         skb_queue_head_init(&sk->write_queue);
 974         skb_queue_head_init(&sk->back_log);
 975 
 976         sk->dead        = 0;
 977         sk->next        = NULL;
 978         sk->priority    = osk->priority;
 979         sk->broadcast   = 0;
 980         sk->protocol    = osk->protocol;
 981         sk->rcvbuf      = osk->rcvbuf;
 982         sk->sndbuf      = osk->sndbuf;
 983         sk->wmem_alloc  = 0;
 984         sk->rmem_alloc  = 0;
 985         sk->inuse       = 0;
 986         sk->ack_backlog = 0;
 987         sk->destroy     = 0;
 988         sk->prot        = NULL; /* So we use default free mechanisms */
 989         sk->err         = 0;
 990         sk->localroute  = 0;
 991         sk->send_head   = NULL;
 992         sk->debug       = osk->debug;
 993         sk->state       = TCP_ESTABLISHED;
 994         sk->window      = osk->window;
 995         sk->shutdown    = 0;
 996         sk->mtu         = osk->mtu;
 997         sk->sleep       = osk->sleep;
 998         sk->zapped      = osk->zapped;
 999 
1000         sk->state_change = def_callback1;
1001         sk->data_ready   = def_callback2;
1002         sk->write_space  = def_callback1;
1003         sk->error_report = def_callback1;
1004 
1005         ax25->modulus = osk->ax25->modulus;
1006         ax25->backoff = osk->ax25->backoff;
1007         ax25->hdrincl = osk->ax25->hdrincl;
1008         ax25->rtt     = osk->ax25->rtt;
1009         ax25->t1      = osk->ax25->t1;
1010         ax25->t2      = osk->ax25->t2;
1011         ax25->t3      = osk->ax25->t3;
1012         ax25->n2      = osk->ax25->n2;
1013 
1014         ax25->window  = osk->ax25->window;
1015 
1016         memcpy(&ax25->source_addr, &osk->ax25->source_addr, sizeof(ax25_address));
1017         
1018         if (osk->ax25->digipeat != NULL) {
1019                 if ((ax25->digipeat = (ax25_digi *)kmalloc(sizeof(ax25_digi), GFP_ATOMIC)) == NULL) {
1020                         kfree_s(sk, sizeof(*sk));
1021                         kfree_s(ax25, sizeof(*ax25));
1022                         return NULL;
1023                 }
1024         }
1025 
1026         sk->ax25 = ax25;
1027         ax25->sk = sk;
1028 
1029         return sk;
1030 }
1031 
1032 static int ax25_dup(struct socket *newsock, struct socket *oldsock)
     /* [previous][next][first][last][top][bottom][index][help] */
1033 {
1034         struct sock *sk = (struct sock *)oldsock->data;
1035 
1036         return ax25_create(newsock, sk->protocol);
1037 }
1038 
1039 static int ax25_release(struct socket *sock, struct socket *peer)
     /* [previous][next][first][last][top][bottom][index][help] */
1040 {
1041         struct sock *sk = (struct sock *)sock->data;
1042 
1043         if (sk == NULL) return 0;
1044 
1045         if (sk->type == SOCK_SEQPACKET) {
1046                 switch (sk->ax25->state) {
1047                         case AX25_STATE_0:
1048                                 sk->state       = TCP_CLOSE;
1049                                 sk->state_change(sk);
1050                                 sk->dead        = 1;
1051                                 ax25_destroy_socket(sk->ax25);
1052                                 break;
1053 
1054                         case AX25_STATE_1:
1055                                 ax25_send_control(sk->ax25, DISC, POLLON, C_COMMAND);
1056                                 sk->ax25->state = AX25_STATE_0;
1057                                 sk->state       = TCP_CLOSE;
1058                                 sk->state_change(sk);
1059                                 sk->dead        = 1;
1060                                 ax25_destroy_socket(sk->ax25);
1061                                 break;
1062 
1063                         case AX25_STATE_2:
1064                                 ax25_send_control(sk->ax25, DM, POLLON, C_RESPONSE);
1065                                 sk->ax25->state = AX25_STATE_0;
1066                                 sk->state       = TCP_CLOSE;
1067                                 sk->state_change(sk);
1068                                 sk->dead        = 1;
1069                                 ax25_destroy_socket(sk->ax25);
1070                                 break;                  
1071 
1072                         case AX25_STATE_3:
1073                         case AX25_STATE_4:
1074                                 ax25_clear_queues(sk->ax25);
1075                                 sk->ax25->n2count = 0;
1076                                 ax25_send_control(sk->ax25, DISC, POLLON, C_COMMAND);
1077                                 sk->ax25->t3timer = 0;
1078                                 sk->ax25->t1timer = sk->ax25->t1 = ax25_calculate_t1(sk->ax25);
1079                                 sk->ax25->state   = AX25_STATE_2;
1080                                 sk->state         = TCP_CLOSE;
1081                                 sk->state_change(sk);
1082                                 sk->dead          = 1;
1083                                 sk->destroy       = 1;
1084                                 break;
1085 
1086                         default:
1087                                 break;
1088                 }
1089         } else {
1090                 sk->state       = TCP_CLOSE;
1091                 sk->state_change(sk);
1092                 sk->dead = 1;
1093                 ax25_destroy_socket(sk->ax25);
1094         }
1095 
1096         sock->data = NULL;      
1097         sk->socket = NULL;      /* Not used, but we should do this. **/
1098 
1099         return 0;
1100 }
1101 
1102 /*
1103  *      We support a funny extension here so you can (as root) give any callsign
1104  *      digipeated via a local address as source. This is a hack until we add
1105  *      BSD 4.4 ADDIFADDR type support. It is however small and trivially backward
1106  *      compatible 8)
1107  */
1108 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr,int addr_len)
     /* [previous][next][first][last][top][bottom][index][help] */
1109 {
1110         struct sock *sk;
1111         struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1112         struct device *dev;
1113         ax25_address *call;
1114         
1115         sk = (struct sock *)sock->data;
1116         
1117         if (sk->zapped == 0)
1118                 return -EIO;
1119                 
1120         if (addr_len != sizeof(struct sockaddr_ax25) && addr_len != sizeof(struct full_sockaddr_ax25))
1121                 return -EINVAL;
1122 
1123 #ifdef DONTDO
1124         if (ax25_find_socket(&addr->fsa_ax25.sax25_call, sk->type) != NULL) {
1125                 if (sk->debug)
1126                         printk("AX25: bind failed: in use\n");
1127                 return -EADDRINUSE;
1128         }
1129 #endif
1130 
1131         call = ax25_findbyuid(current->euid);
1132         if (call == NULL && ax25_uid_policy && !suser())
1133                 return -EPERM;
1134                 
1135         if (call == NULL)
1136                 memcpy(&sk->ax25->source_addr, &addr->fsa_ax25.sax25_call, sizeof(ax25_address));
1137         else
1138                 memcpy(&sk->ax25->source_addr, call, sizeof(ax25_address));
1139 
1140         if (addr_len == sizeof(struct full_sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1141                 if (!suser())
1142                         return -EPERM;
1143                 call = &addr->fsa_digipeater[0];
1144         } else {
1145                 call = &addr->fsa_ax25.sax25_call;
1146         }
1147 
1148         if ((dev = ax25rtr_get_dev(call)) == NULL) {
1149                 if (sk->debug)
1150                         printk("AX25 bind failed: no device\n");
1151                 return -EADDRNOTAVAIL;
1152         }
1153 
1154         ax25_fillin_cb(sk->ax25, dev);
1155         ax25_insert_socket(sk->ax25);
1156 
1157         sk->zapped = 0;
1158 
1159         if (sk->debug)
1160                 printk("AX25: socket is bound\n");
1161 
1162         return 0;
1163 }
1164 
1165 static int ax25_connect(struct socket *sock, struct sockaddr *uaddr,
     /* [previous][next][first][last][top][bottom][index][help] */
1166         int addr_len, int flags)
1167 {
1168         struct sock *sk = (struct sock *)sock->data;
1169         struct sockaddr_ax25 *addr = (struct sockaddr_ax25 *)uaddr;
1170         int err;
1171         
1172         if (sk->state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
1173                 sock->state = SS_CONNECTED;
1174                 return 0;       /* Connect completed during a ERESTARTSYS event */
1175         }
1176         
1177         if (sk->state == TCP_CLOSE && sock->state == SS_CONNECTING) {
1178                 sock->state = SS_UNCONNECTED;
1179                 return -ECONNREFUSED;
1180         }
1181         
1182         if (sk->state == TCP_ESTABLISHED && sk->type == SOCK_SEQPACKET)
1183                 return -EISCONN;        /* No reconnect on a seqpacket socket */
1184                 
1185         sk->state   = TCP_CLOSE;        
1186         sock->state = SS_UNCONNECTED;
1187 
1188         if (addr_len != sizeof(struct sockaddr_ax25) && addr_len != sizeof(struct full_sockaddr_ax25))
1189                 return -EINVAL;
1190         if (addr_len == sizeof(struct full_sockaddr_ax25) && addr->sax25_ndigis != 0) {
1191                 int ct           = 0;
1192                 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)addr;
1193 
1194                 /* Valid number of digipeaters ? */
1195                 if (addr->sax25_ndigis < 1 || addr->sax25_ndigis > AX25_MAX_DIGIS)
1196                         return -EINVAL;
1197 
1198                 if (sk->ax25->digipeat == NULL) {
1199                         if ((sk->ax25->digipeat = (ax25_digi *)kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL)
1200                                 return -ENOMEM;
1201                 }
1202 
1203                 sk->ax25->digipeat->ndigi = addr->sax25_ndigis;
1204 
1205                 while (ct < addr->sax25_ndigis) {
1206                         sk->ax25->digipeat->repeated[ct] = 0;
1207                         memcpy(&sk->ax25->digipeat->calls[ct], &fsa->fsa_digipeater[ct], sizeof(ax25_address));
1208                         ct++;
1209                 }
1210 
1211                 sk->ax25->digipeat->lastrepeat = 0;
1212         }
1213 
1214         if (sk->zapped) {       /* Must bind first - autobinding in this may or may not work */
1215                 if ((err = ax25_rt_autobind(sk->ax25, &addr->sax25_call)) < 0)
1216                         return err;
1217                 ax25_insert_socket(sk->ax25);           /* Finish the bind */
1218         }
1219                 
1220         if (sk->type == SOCK_SEQPACKET && ax25_find_cb(&sk->ax25->source_addr, &addr->sax25_call, sk->ax25->device) != NULL)
1221                 return -EBUSY;                          /* Already such a connection */
1222 
1223         memcpy(&sk->ax25->dest_addr, &addr->sax25_call, sizeof(ax25_address));
1224         
1225         /* First the easy one */
1226         if (sk->type != SOCK_SEQPACKET) {
1227                 sock->state = SS_CONNECTED;
1228                 sk->state   = TCP_ESTABLISHED;
1229                 return 0;
1230         }
1231         
1232         /* Move to connecting socket, ax.25 lapb WAIT_UA.. */   
1233         sock->state        = SS_CONNECTING;
1234         sk->state          = TCP_SYN_SENT;
1235         ax25_establish_data_link(sk->ax25);
1236         sk->ax25->state     = AX25_STATE_1;
1237         ax25_set_timer(sk->ax25);               /* Start going SABM SABM until a UA or a give up and DM */
1238         
1239         /* Now the loop */
1240         if (sk->state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
1241                 return -EINPROGRESS;
1242                 
1243         cli();  /* To avoid races on the sleep */
1244 
1245         /* A DM or timeout will go to closed, a UA will go to ABM */
1246         while (sk->state == TCP_SYN_SENT) {
1247                 interruptible_sleep_on(sk->sleep);
1248                 if (current->signal & ~current->blocked) {
1249                         sti();
1250                         return -ERESTARTSYS;
1251                 }
1252         }
1253 
1254         if (sk->state != TCP_ESTABLISHED) {     /* Not in ABM, not in WAIT_UA -> failed */
1255                 sti();
1256                 sock->state = SS_UNCONNECTED;
1257                 return -sk->err;        /* Always set at this point */
1258         }
1259         
1260         sock->state = SS_CONNECTED;
1261 
1262         sti();
1263         
1264         return 0;
1265 }
1266         
1267 static int ax25_socketpair(struct socket *sock1, struct socket *sock2)
     /* [previous][next][first][last][top][bottom][index][help] */
1268 {
1269         return -EOPNOTSUPP;
1270 }
1271 
1272 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
     /* [previous][next][first][last][top][bottom][index][help] */
1273 {
1274         struct sock *sk;
1275         struct sock *newsk;
1276         struct sk_buff *skb;
1277 
1278         if (newsock->data)
1279                 kfree_s(newsock->data, sizeof(struct sock));
1280 
1281         newsock->data = NULL;
1282         
1283         sk = (struct sock *)sock->data;
1284 
1285         if (sk->type != SOCK_SEQPACKET)
1286                 return -EOPNOTSUPP;
1287         
1288         if (sk->state != TCP_LISTEN)
1289                 return -EINVAL;
1290                 
1291         /* The write queue this time is holding sockets ready to use
1292            hooked into the SABM we saved */
1293         do {
1294                 cli();
1295                 if ((skb = skb_dequeue(&sk->receive_queue)) == NULL) {
1296                         if (flags & O_NONBLOCK) {
1297                                 sti();
1298                                 return 0;
1299                         }
1300                         interruptible_sleep_on(sk->sleep);
1301                         if (current->signal & ~current->blocked) {
1302                                 sti();
1303                                 return -ERESTARTSYS;
1304                         }
1305                 }
1306         } while (skb == NULL);
1307 
1308         newsk = skb->sk;
1309         newsk->pair = NULL;
1310         sti();
1311 
1312         /* Now attach up the new socket */
1313         skb->sk = NULL;
1314         kfree_skb(skb, FREE_READ);
1315         sk->ack_backlog--;
1316         newsock->data = newsk;
1317 
1318         return 0;
1319 }
1320 
1321 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
     /* [previous][next][first][last][top][bottom][index][help] */
1322         int *uaddr_len, int peer)
1323 {
1324         ax25_address *addr;
1325         struct full_sockaddr_ax25 *sax = (struct full_sockaddr_ax25 *)uaddr;
1326         struct sock *sk;
1327         unsigned char ndigi, i;
1328         
1329         sk = (struct sock *)sock->data;
1330         
1331         if (peer != 0) {
1332                 if (sk->state != TCP_ESTABLISHED)
1333                         return -ENOTCONN;
1334                 addr = &sk->ax25->dest_addr;
1335         } else {
1336                 addr = &sk->ax25->source_addr;
1337         }
1338                 
1339         sax->fsa_ax25.sax25_family = AF_AX25;
1340         memcpy(&sax->fsa_ax25.sax25_call, addr, sizeof(ax25_address));
1341         sax->fsa_ax25.sax25_ndigis = 0;
1342         *uaddr_len = sizeof(struct sockaddr_ax25);
1343 
1344         /* This will supply digipeat path on both getpeername() and getsockname() */
1345         if (sk->ax25->digipeat != NULL) {
1346                 ndigi = sk->ax25->digipeat->ndigi;
1347                 sax->fsa_ax25.sax25_ndigis = ndigi;
1348                 *uaddr_len += sizeof(ax25_address) * ndigi;
1349                 for (i = 0; i < ndigi; i++)
1350                         memcpy(&sax->fsa_digipeater[i], &sk->ax25->digipeat->calls[i], sizeof(ax25_address));
1351         }
1352 
1353         return 0;
1354 }
1355  
1356 static int ax25_rcv(struct sk_buff *skb, struct device *dev, ax25_address *dev_addr, struct packet_type *ptype)
     /* [previous][next][first][last][top][bottom][index][help] */
1357 {
1358         struct sock *make;
1359         struct sock *sk;
1360         int type = 0;
1361         ax25_digi dp;
1362         ax25_cb *ax25;
1363         ax25_address src, dest;
1364         struct sock *raw;
1365         int mine = 0;
1366 
1367         /*
1368          *      Process the AX.25/LAPB frame.
1369          */
1370         skb->h.raw = skb->data;
1371 
1372         /*
1373          *      Parse the address header.
1374          */
1375         if (ax25_parse_addr(skb->data, skb->len, &src, &dest, &dp, &type) == NULL) {
1376                 kfree_skb(skb, FREE_READ);
1377                 return 0;
1378         }
1379 
1380         /*
1381          *      Send the frame to the AX.25 auto-router
1382          */
1383         ax25_rt_rx_frame(&src, dev, &dp);
1384         
1385         /*
1386          *      Ours perhaps ?
1387          */
1388         if (dp.lastrepeat + 1 < dp.ndigi) {             /* Not yet digipeated completely */
1389                 if (ax25cmp(&dp.calls[dp.lastrepeat + 1], dev_addr) == 0) {
1390                         struct device *dev_out = dev;
1391 
1392                         /* We are the digipeater. Mark ourselves as repeated
1393                            and throw the packet back out of the same device */
1394                         dp.lastrepeat++;
1395                         dp.repeated[(int)dp.lastrepeat] = 1;
1396 
1397                         if (ax25_dev_get_value(dev, AX25_VALUES_DIGI) & AX25_DIGI_XBAND) {
1398                                 while (dp.lastrepeat + 1 < dp.ndigi) {
1399                                         struct device *dev_scan;
1400                                         if ((dev_scan = ax25rtr_get_dev(&dp.calls[dp.lastrepeat + 1])) == NULL)
1401                                                 break;
1402                                         dp.lastrepeat++;
1403                                         dp.repeated[(int)dp.lastrepeat] = 1;
1404                                         dev_out = dev_scan;
1405                                 }
1406                                 if (dev != dev_out && (ax25_dev_get_value(dev_out, AX25_VALUES_DIGI) & AX25_DIGI_XBAND) == 0)
1407                                         kfree_skb(skb, FREE_READ);
1408                         }
1409 
1410                         if (dev == dev_out && (ax25_dev_get_value(dev, AX25_VALUES_DIGI) & AX25_DIGI_INBAND) == 0)
1411                                 kfree_skb(skb, FREE_READ);
1412 
1413                         build_ax25_addr(skb->data, &src, &dest, &dp, type, MODULUS);
1414                         skb->arp = 1;
1415                         ax25_queue_xmit(skb, dev_out, SOPRI_NORMAL);
1416                 } else {
1417                         kfree_skb(skb, FREE_READ);
1418                 }
1419 
1420                 return 0;
1421         }
1422 
1423         /*
1424          *      Pull of the AX.25 headers leaving the CTRL/PID bytes
1425          */
1426         skb_pull(skb, size_ax25_addr(&dp));
1427 
1428         /* For our port addreses ? */
1429         if (ax25cmp(&dest, dev_addr) == 0)
1430                 mine = 1;
1431 
1432 #ifdef CONFIG_NETROM
1433         /* Also match on any NET/ROM callsign */
1434         if (!mine && nr_dev_get(&dest) != NULL)
1435                 mine = 1;
1436 #endif  
1437         
1438         if ((*skb->data & ~0x10) == LAPB_UI) {  /* UI frame - bypass LAPB processing */
1439                 skb->h.raw = skb->data + 2;             /* skip control and pid */
1440 
1441                 if ((raw = ax25_addr_match(&dest)) != NULL)
1442                         ax25_send_to_raw(raw, skb, skb->data[1]);
1443 
1444                 if (!mine && ax25cmp(&dest, (ax25_address *)dev->broadcast) != 0) {
1445                         kfree_skb(skb, FREE_READ);
1446                         return 0;
1447                 }
1448 
1449                 /* Now we are pointing at the pid byte */
1450                 switch (skb->data[1]) {
1451 #ifdef CONFIG_INET              
1452                         case AX25_P_IP:
1453                                 skb_pull(skb,2);                /* drop PID/CTRL */
1454                                 ax25_ip_mode_set(&src, dev, 'D');
1455                                 ip_rcv(skb, dev, ptype);        /* Note ptype here is the wrong one, fix me later */
1456                                 break;
1457 
1458                         case AX25_P_ARP:
1459                                 skb_pull(skb,2);
1460                                 arp_rcv(skb, dev, ptype);       /* Note ptype here is wrong... */
1461                                 break;
1462 #endif                          
1463                         case AX25_P_TEXT:
1464                                 /* Now find a suitable dgram socket */
1465                                 if ((sk = ax25_find_socket(&dest, &src, SOCK_DGRAM)) != NULL) {
1466                                         if (sk->rmem_alloc >= sk->rcvbuf) {
1467                                                 kfree_skb(skb, FREE_READ);
1468                                         } else {
1469                                                 /*
1470                                                  *      Remove the control and PID.
1471                                                  */
1472                                                 skb_pull(skb, 2);
1473                                                 skb_queue_tail(&sk->receive_queue, skb);
1474                                                 skb->sk = sk;
1475                                                 sk->rmem_alloc += skb->truesize;
1476                                                 if (!sk->dead)
1477                                                         sk->data_ready(sk, skb->len);
1478                                         }
1479                                 } else {
1480                                         kfree_skb(skb, FREE_READ);
1481                                 }
1482                                 break;  
1483 
1484                         default:
1485                                 kfree_skb(skb, FREE_READ);      /* Will scan SOCK_AX25 RAW sockets */
1486                                 break;
1487                 }
1488 
1489                 return 0;
1490         }
1491 
1492         /*
1493          *      Is connected mode supported on this device ?
1494          *      If not, should we DM the incoming frame (except DMs) or
1495          *      silently ignore them. For now we stay quiet.
1496          */
1497         if (!ax25_dev_get_value(dev, AX25_VALUES_CONMODE)) {
1498                 kfree_skb(skb, FREE_READ);
1499                 return 0;
1500         }
1501         
1502         /* LAPB */
1503         if ((ax25 = ax25_find_cb(&dest, &src, dev)) != NULL) {
1504                 /*
1505                  *      Process the frame. If it is queued up internally it returns one otherwise we 
1506                  *      free it immediately. This routine itself wakes the user context layers so we
1507                  *      do no further work
1508                  */
1509                 if (ax25_process_rx_frame(ax25, skb, type) == 0)
1510                         kfree_skb(skb, FREE_READ);
1511 
1512                 return 0;
1513         }
1514 
1515         if ((*skb->data & ~PF) != SABM && (*skb->data & ~PF) != SABME) {
1516                 /*
1517                  *      Never reply to a DM. Also ignore any connects for
1518                  *      addresses that are not our interfaces and not a socket.
1519                  */
1520                 if ((*skb->data & ~PF) != DM && mine)
1521                         ax25_return_dm(dev, &src, &dest, &dp);
1522 
1523                 kfree_skb(skb, FREE_READ);
1524                 return 0;
1525         }
1526 
1527         if ((sk = ax25_find_listener(&dest, dev, SOCK_SEQPACKET)) != NULL) {
1528                 if (sk->ack_backlog == sk->max_ack_backlog || (make = ax25_make_new(sk, dev)) == NULL) {
1529                         if (mine)
1530                                 ax25_return_dm(dev, &src, &dest, &dp);
1531 
1532                         kfree_skb(skb, FREE_READ);
1533                         return 0;
1534                 }
1535                 
1536                 ax25 = make->ax25;
1537 
1538                 skb_queue_head(&sk->receive_queue, skb);
1539 
1540                 skb->sk     = make;
1541                 make->state = TCP_ESTABLISHED;
1542                 make->pair  = sk;
1543 
1544                 sk->ack_backlog++;
1545         } else {
1546 #ifdef CONFIG_NETROM
1547                 if (!mine) {
1548                         kfree_skb(skb, FREE_READ);
1549                         return 0;
1550                 }
1551 
1552                 if ((ax25 = ax25_create_cb()) == NULL) {
1553                         ax25_return_dm(dev, &src, &dest, &dp);
1554                         kfree_skb(skb, FREE_READ);
1555                         return 0;
1556                 }
1557 
1558                 ax25_fillin_cb(ax25, dev);
1559 #else
1560                 if (mine)
1561                         ax25_return_dm(dev, &src, &dest, &dp);
1562 
1563                 kfree_skb(skb, FREE_READ);
1564                 return 0;
1565 #endif
1566         }
1567 
1568         memcpy(&ax25->source_addr, &dest, sizeof(ax25_address));
1569         memcpy(&ax25->dest_addr,   &src,  sizeof(ax25_address));
1570 
1571         /*
1572          *      Sort out any digipeated paths.
1573          */
1574         if (dp.ndigi != 0 && ax25->digipeat == NULL && (ax25->digipeat = kmalloc(sizeof(ax25_digi), GFP_ATOMIC)) == NULL) {
1575                 kfree_skb(skb, FREE_READ);
1576                 ax25_destroy_socket(ax25);
1577                 return 0;
1578         }
1579 
1580         if (dp.ndigi == 0) {
1581                 if (ax25->digipeat != NULL) {
1582                         kfree_s(ax25->digipeat, sizeof(ax25_digi));
1583                         ax25->digipeat = NULL;
1584                 }
1585         } else {
1586                 /* Reverse the source SABM's path */
1587                 ax25_digi_invert(&dp, ax25->digipeat);
1588         }
1589 
1590         if ((*skb->data & ~PF) == SABME) {
1591                 ax25->modulus = EMODULUS;
1592                 ax25->window  = ax25_dev_get_value(dev, AX25_VALUES_EWINDOW);
1593         } else {
1594                 ax25->modulus = MODULUS;
1595                 ax25->window  = ax25_dev_get_value(dev, AX25_VALUES_WINDOW);
1596         }
1597 
1598         ax25->device = dev;
1599         
1600         ax25_send_control(ax25, UA, POLLON, C_RESPONSE);
1601 
1602         ax25->t3timer = ax25->t3;
1603         ax25->state   = AX25_STATE_3;
1604 
1605         ax25_insert_socket(ax25);
1606 
1607         ax25_set_timer(ax25);
1608 
1609         if (sk != NULL) {
1610                 if (!sk->dead)
1611                         sk->data_ready(sk, skb->len );
1612         } else {
1613                 kfree_skb(skb, FREE_READ);
1614         }
1615 
1616         return 0;
1617 }
1618 
1619 /*
1620  *      Receive an AX.25 frame via a SLIP interface.
1621  */
1622 static int kiss_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *ptype)
     /* [previous][next][first][last][top][bottom][index][help] */
1623 {
1624         skb->sk = NULL;         /* Initially we don't know who its for */
1625 
1626         if ((*skb->data & 0x0F) != 0) {
1627                 kfree_skb(skb, FREE_READ);      /* Not a KISS data frame */
1628                 return 0;
1629         }
1630 
1631         skb_pull(skb, AX25_KISS_HEADER_LEN);    /* Remove the KISS byte */
1632 
1633         return ax25_rcv(skb, dev, (ax25_address *)dev->dev_addr, ptype);
1634 }
1635 
1636 /*
1637  *      Receive an AX.25 frame via an Ethernet interface.
1638  */
1639 static int bpq_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *ptype)
     /* [previous][next][first][last][top][bottom][index][help] */
1640 {
1641         ax25_address port_call;
1642         int len;
1643 
1644         skb->sk = NULL;         /* Initially we don't know who its for */
1645 
1646         if (!arp_query((unsigned char *)&port_call, dev->pa_addr, ARPHRD_AX25)) {
1647                 kfree_skb(skb, FREE_READ);      /* We have no port callsign */
1648                 return 0;
1649         }
1650 
1651         len = skb->data[0] + skb->data[1] * 256 - 5;
1652 
1653         skb_pull(skb, 2);       /* Remove the length bytes */
1654         skb_trim(skb, len);     /* Set the length of the data */
1655 
1656         return ax25_rcv(skb, dev, &port_call, ptype);
1657 }
1658 
1659 static int ax25_sendmsg(struct socket *sock, struct msghdr *msg, int len, int noblock, int flags)
     /* [previous][next][first][last][top][bottom][index][help] */
1660 {
1661         struct sock *sk = (struct sock *)sock->data;
1662         struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1663         int err;
1664         struct sockaddr_ax25 sax;
1665         struct sk_buff *skb;
1666         unsigned char *asmptr;
1667         int size;
1668         ax25_digi *dp;
1669         ax25_digi dtmp;
1670         int lv;
1671         int addr_len=msg->msg_namelen;
1672         
1673         if (sk->err) {
1674                 cli();
1675                 err     = sk->err;
1676                 sk->err = 0;
1677                 sti();
1678                 return -err;
1679         }
1680 
1681         if (flags|| msg->msg_accrights)
1682                 return -EINVAL;
1683 
1684         if (sk->zapped)
1685                 return -EADDRNOTAVAIL;
1686                 
1687         if (sk->ax25->device == NULL)
1688                 return -ENETUNREACH;
1689                 
1690         if (usax) {
1691                 if (addr_len != sizeof(struct sockaddr_ax25) && addr_len != sizeof(struct full_sockaddr_ax25))
1692                         return -EINVAL;
1693                 if (usax->sax25_family != AF_AX25)
1694                         return -EINVAL;
1695                 if (addr_len == sizeof(struct full_sockaddr_ax25) && usax->sax25_ndigis != 0) {
1696                         int ct           = 0;
1697                         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1698 
1699                         /* Valid number of digipeaters ? */
1700                         if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS)
1701                                 return -EINVAL;
1702 
1703                         dtmp.ndigi      = usax->sax25_ndigis;
1704 
1705                         while (ct < usax->sax25_ndigis) {
1706                                 dtmp.repeated[ct] = 0;
1707                                 memcpy(&dtmp.calls[ct], &fsa->fsa_digipeater[ct], sizeof(ax25_address));
1708                                 ct++;
1709                         }
1710 
1711                         dtmp.lastrepeat = 0;
1712                 }
1713 
1714                 memcpy(&sax, usax, sizeof(sax));
1715                 if (sk->type == SOCK_SEQPACKET && memcmp(&sk->ax25->dest_addr, &sax.sax25_call, sizeof(ax25_address)) != 0)
1716                         return -EISCONN;
1717                 if (usax->sax25_ndigis == 0)
1718                         dp = NULL;
1719                 else
1720                         dp = &dtmp;
1721         } else {
1722                 if (sk->state != TCP_ESTABLISHED)
1723                         return -ENOTCONN;
1724                 sax.sax25_family = AF_AX25;
1725                 memcpy(&sax.sax25_call, &sk->ax25->dest_addr, sizeof(ax25_address));
1726                 dp = sk->ax25->digipeat;
1727         }
1728         
1729         if (sk->debug)
1730                 printk("AX.25: sendto: Addresses built.\n");
1731 
1732         /* Build a packet */
1733         if (sk->debug)
1734                 printk("AX.25: sendto: building packet.\n");
1735 
1736         /* Assume the worst case */
1737         size = len + 3 + size_ax25_addr(dp) + AX25_BPQ_HEADER_LEN;
1738 
1739         if ((skb = sock_alloc_send_skb(sk, size, 0, 0, &err)) == NULL)
1740                 return err;
1741 
1742         skb->sk   = sk;
1743         skb->free = 1;
1744         skb->arp  = 1;
1745 
1746         skb_reserve(skb, size - len);
1747 
1748         if (sk->debug)
1749                 printk("AX.25: Appending user data\n");
1750 
1751         /* User data follows immediately after the AX.25 data */
1752         memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
1753 
1754         /* Add the PID, usually AX25_TEXT */
1755         asmptr  = skb_push(skb, 1);
1756         *asmptr = sk->protocol;
1757 
1758         if (sk->debug)
1759                 printk("AX.25: Transmitting buffer\n");
1760 
1761         if (sk->type == SOCK_SEQPACKET) {
1762                 /* Connected mode sockets go via the LAPB machine */
1763                 if (sk->state != TCP_ESTABLISHED) {
1764                         kfree_skb(skb, FREE_WRITE);
1765                         return -ENOTCONN;
1766                 }
1767 
1768                 ax25_output(sk->ax25, skb);     /* Shove it onto the queue and kick */
1769 
1770                 return len;
1771         } else {
1772                 asmptr = skb_push(skb, 1 + size_ax25_addr(dp));
1773 
1774                 if (sk->debug) {
1775                         printk("Building AX.25 Header (dp=%p).\n", dp);
1776                         if (dp != 0)
1777                                 printk("Num digipeaters=%d\n", dp->ndigi);
1778                 }
1779 
1780                 /* Build an AX.25 header */
1781                 asmptr += (lv = build_ax25_addr(asmptr, &sk->ax25->source_addr, &sax.sax25_call, dp, C_COMMAND, MODULUS));
1782 
1783                 if (sk->debug)
1784                         printk("Built header (%d bytes)\n",lv);
1785 
1786                 skb->h.raw = asmptr;
1787         
1788                 if (sk->debug)
1789                         printk("base=%p pos=%p\n", skb->data, asmptr);
1790 
1791                 *asmptr = LAPB_UI;
1792 
1793                 /* Datagram frames go straight out of the door as UI */
1794                 ax25_queue_xmit(skb, sk->ax25->device, SOPRI_NORMAL);
1795 
1796                 return len;
1797         }
1798                 
1799 }
1800 
1801 static int ax25_sendto(struct socket *sock, const void *ubuf, int size, int noblock, unsigned flags,
     /* [previous][next][first][last][top][bottom][index][help] */
1802                 struct sockaddr *sa, int addr_len)
1803 {
1804         struct iovec iov;
1805         struct msghdr msg;
1806 
1807         iov.iov_base = (void *)ubuf;
1808         iov.iov_len  = size;
1809 
1810         msg.msg_name      = (void *)sa;
1811         msg.msg_namelen   = addr_len;
1812         msg.msg_accrights = NULL;
1813         msg.msg_iov       = &iov;
1814         msg.msg_iovlen    = 1;
1815 
1816         return ax25_sendmsg(sock, &msg, size, noblock, flags);
1817 }
1818 
1819 static int ax25_send(struct socket *sock, const void *ubuf, int size, int noblock, unsigned flags)
     /* [previous][next][first][last][top][bottom][index][help] */
1820 {
1821         return ax25_sendto(sock, ubuf, size, noblock, flags, NULL, 0);
1822 }
1823 
1824 static int ax25_write(struct socket *sock, const char *ubuf, int size, int noblock)
     /* [previous][next][first][last][top][bottom][index][help] */
1825 {
1826         return ax25_sendto(sock, ubuf, size, noblock, 0, NULL, 0);
1827 }
1828 
1829 static int ax25_recvmsg(struct socket *sock, struct msghdr *msg, int size, int noblock, int flags, int *addr_len)
     /* [previous][next][first][last][top][bottom][index][help] */
1830 {
1831         struct sock *sk = (struct sock *)sock->data;
1832         struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1833         int copied, length;
1834         struct sk_buff *skb;
1835         int er;
1836 
1837         if (sk->err) {
1838                 cli();
1839                 er      = -sk->err;
1840                 sk->err = 0;
1841                 sti();
1842                 return er;
1843         }
1844         
1845         if (addr_len != NULL)
1846                 *addr_len = sizeof(*sax);
1847 
1848         /*
1849          *      This works for seqpacket too. The receiver has ordered the
1850          *      queue for us! We do one quick check first though
1851          */
1852         if (sk->type == SOCK_SEQPACKET && sk->state != TCP_ESTABLISHED)
1853                 return -ENOTCONN;
1854 
1855         /* Now we can treat all alike */
1856         if ((skb = skb_recv_datagram(sk, flags, noblock, &er)) == NULL)
1857                 return er;
1858 
1859         if (sk->ax25->hdrincl) {
1860                 length = skb->len + (skb->data - skb->h.raw);
1861         } else {
1862                 if (sk->type == SOCK_SEQPACKET)
1863                         skb_pull(skb, 1);               /* Remove PID */
1864                 length     = skb->len;
1865                 skb->h.raw = skb->data;
1866         }
1867 
1868         copied = (size < length) ? size : length;
1869         skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1870         
1871         if (sax) {
1872                 ax25_digi digi;
1873                 ax25_address dest;
1874 
1875                 if (addr_len == (int *)0)
1876                         return -EINVAL;
1877                 if (*addr_len != sizeof(struct sockaddr_ax25) && *addr_len != sizeof(struct full_sockaddr_ax25))
1878                         return -EINVAL;
1879 
1880                 ax25_parse_addr(skb->data, skb->len, NULL, &dest, &digi, NULL);
1881 
1882                 sax->sax25_family = AF_AX25;
1883                 /* We set this correctly, even though we may not let the
1884                    application know the digi calls further down (because it
1885                    did NOT ask to know them).  This could get political... **/
1886                 sax->sax25_ndigis = digi.ndigi;
1887                 memcpy(&sax->sax25_call, &dest, sizeof(ax25_address));
1888 
1889                 *addr_len = sizeof(struct sockaddr_ax25);
1890 
1891                 if (*addr_len == sizeof(struct full_sockaddr_ax25) && sax->sax25_ndigis != 0) {
1892                         int ct           = 0;
1893                         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1894 
1895                         while (ct < digi.ndigi) {
1896                                 memcpy(&fsa->fsa_digipeater[ct], &digi.calls[ct], sizeof(ax25_address));
1897                                 ct++;
1898                         }
1899 
1900                         *addr_len = sizeof(struct full_sockaddr_ax25);
1901                 }
1902         }
1903 
1904         skb_free_datagram(skb);
1905 
1906         return copied;
1907 }               
1908 
1909 static int ax25_recvfrom(struct socket *sock, void *ubuf, int size, int noblock, unsigned flags,
     /* [previous][next][first][last][top][bottom][index][help] */
1910                 struct sockaddr *sa, int *addr_len)
1911 {
1912         struct iovec iov;
1913         struct msghdr msg;
1914 
1915         iov.iov_base = ubuf;
1916         iov.iov_len  = size;
1917 
1918         msg.msg_name      = (void *)sa;
1919         msg.msg_namelen   = 0;
1920         if (addr_len)
1921                 msg.msg_namelen = *addr_len;
1922         msg.msg_accrights = NULL;
1923         msg.msg_iov       = &iov;
1924         msg.msg_iovlen    = 1;
1925 
1926         return ax25_recvmsg(sock, &msg, size, noblock, flags, addr_len);
1927 }
1928 
1929 static int ax25_recv(struct socket *sock, void *ubuf, int size , int noblock,
     /* [previous][next][first][last][top][bottom][index][help] */
1930         unsigned flags)
1931 {
1932         struct sock *sk = (struct sock *)sock->data;
1933 
1934         if (sk->zapped)
1935                 return -ENOTCONN;
1936 
1937         return ax25_recvfrom(sock, ubuf, size, noblock, flags, NULL, NULL);
1938 }
1939 
1940 static int ax25_read(struct socket *sock, char *ubuf, int size, int noblock)
     /* [previous][next][first][last][top][bottom][index][help] */
1941 {
1942         return ax25_recv(sock, ubuf, size, noblock, 0);
1943 }
1944 
1945 static int ax25_shutdown(struct socket *sk, int how)
     /* [previous][next][first][last][top][bottom][index][help] */
1946 {
1947         /* FIXME - generate DM and RNR states */
1948         return -EOPNOTSUPP;
1949 }
1950 
1951 static int ax25_select(struct socket *sock , int sel_type, select_table *wait)
     /* [previous][next][first][last][top][bottom][index][help] */
1952 {
1953         struct sock *sk = (struct sock *)sock->data;
1954 
1955         return datagram_select(sk, sel_type, wait);
1956 }
1957 
1958 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
     /* [previous][next][first][last][top][bottom][index][help] */
1959 {
1960         struct sock *sk = (struct sock *)sock->data;
1961         int err;
1962         long amount = 0;
1963 
1964         switch (cmd) {
1965                 case TIOCOUTQ:
1966                         if ((err = verify_area(VERIFY_WRITE, (void *)arg, sizeof(unsigned long))) != 0)
1967                                 return err;
1968                         amount = sk->sndbuf - sk->wmem_alloc;
1969                         if (amount < 0)
1970                                 amount = 0;
1971                         put_fs_long(amount, (unsigned long *)arg);
1972                         return 0;
1973 
1974                 case TIOCINQ:
1975                 {
1976                         struct sk_buff *skb;
1977                         /* These two are safe on a single CPU system as only user tasks fiddle here */
1978                         if ((skb = skb_peek(&sk->receive_queue)) != NULL)
1979                                 amount = skb->len;
1980                         if ((err = verify_area(VERIFY_WRITE, (void *)arg, sizeof(unsigned long))) != 0)
1981                                 return err;
1982                         put_fs_long(amount, (unsigned long *)arg);
1983                         return 0;
1984                 }
1985 
1986                 case SIOCGSTAMP:
1987                         if (sk != NULL) {
1988                                 if (sk->stamp.tv_sec==0)
1989                                         return -ENOENT;
1990                                 if ((err = verify_area(VERIFY_WRITE,(void *)arg,sizeof(struct timeval))) != 0)
1991                                         return err;
1992                                 memcpy_tofs((void *)arg, &sk->stamp, sizeof(struct timeval));
1993                                 return 0;
1994                         }
1995                         return -EINVAL;
1996 
1997                 case SIOCAX25ADDUID:    /* Add a uid to the uid/call map table */
1998                 case SIOCAX25DELUID:    /* Delete a uid from the uid/call map table */
1999                 case SIOCAX25GETUID:
2000                 {
2001                         struct sockaddr_ax25 sax25;
2002                         if ((err = verify_area(VERIFY_READ, (void *)arg, sizeof(struct sockaddr_ax25))) != 0)
2003                                 return err;
2004                         memcpy_fromfs(&sax25, (void *)arg, sizeof(sax25));
2005                         return ax25_uid_ioctl(cmd, &sax25);
2006                 }
2007 
2008                 case SIOCAX25NOUID:     /* Set the default policy (default/bar) */
2009                         if ((err = verify_area(VERIFY_READ, (void *)arg, sizeof(unsigned long))) != 0)
2010                                 return err;
2011                         if(!suser())
2012                                 return -EPERM;
2013                         amount = get_fs_long((void *)arg);
2014                         if (amount > AX25_NOUID_BLOCK)
2015                                 return -EINVAL;
2016                         ax25_uid_policy = amount;
2017                         return 0;
2018 
2019                 case SIOCAX25GETPARMS:
2020                 case SIOCAX25SETPARMS:
2021                         return ax25_dev_ioctl(cmd, (void *)arg);
2022 
2023                 case SIOCADDRT:
2024                 case SIOCDELRT:
2025                         if (!suser())
2026                                 return -EPERM;
2027                         return ax25_rt_ioctl(cmd, (void *)arg);
2028 
2029                 case SIOCGIFADDR:
2030                 case SIOCSIFADDR:
2031                 case SIOCGIFDSTADDR:
2032                 case SIOCSIFDSTADDR:
2033                 case SIOCGIFBRDADDR:
2034                 case SIOCSIFBRDADDR:
2035                 case SIOCGIFNETMASK:
2036                 case SIOCSIFNETMASK:
2037                 case SIOCGIFMETRIC:
2038                 case SIOCSIFMETRIC:
2039                         return -EINVAL;
2040 
2041                 default:
2042                         return(dev_ioctl(cmd, (void *)arg));
2043         }
2044 
2045         /*NOTREACHED*/
2046         return(0);
2047 }
2048 
2049 static int ax25_get_info(char *buffer, char **start, off_t offset, int length, int dummy)
     /* [previous][next][first][last][top][bottom][index][help] */
2050 {
2051         ax25_cb *ax25;
2052         struct device *dev;
2053         const char *devname;
2054         int len = 0;
2055         off_t pos = 0;
2056         off_t begin = 0;
2057   
2058         cli();
2059 
2060         len += sprintf(buffer, "dest_addr src_addr  dev  st  vs  vr  va    t1     t2     t3     n2  rtt wnd Snd-Q Rcv-Q\n");
2061 
2062         for (ax25 = ax25_list; ax25 != NULL; ax25 = ax25->next) {
2063                 if ((dev = ax25->device) == NULL)
2064                         devname = "???";
2065                 else
2066                         devname = dev->name;
2067 
2068                 len += sprintf(buffer + len, "%-9s ",
2069                         ax2asc(&ax25->dest_addr));
2070                 len += sprintf(buffer + len, "%-9s %-4s %2d %3d %3d %3d %3d/%03d %2d/%02d %3d/%03d %2d/%02d %3d %3d",
2071                         ax2asc(&ax25->source_addr), devname,
2072                         ax25->state,
2073                         ax25->vs, ax25->vr, ax25->va,
2074                         ax25->t1timer / PR_SLOWHZ,
2075                         ax25->t1      / PR_SLOWHZ,
2076                         ax25->t2timer / PR_SLOWHZ,
2077                         ax25->t2      / PR_SLOWHZ,
2078                         ax25->t3timer / PR_SLOWHZ,
2079                         ax25->t3      / PR_SLOWHZ,
2080                         ax25->n2count, ax25->n2,
2081                         ax25->rtt     / PR_SLOWHZ,
2082                         ax25->window);
2083 
2084                 if (ax25->sk != NULL) {
2085                         len += sprintf(buffer + len, " %5ld %5ld\n",
2086                                 ax25->sk->wmem_alloc,
2087                                 ax25->sk->rmem_alloc);
2088                 } else {
2089                         len += sprintf(buffer + len, "\n");
2090                 }
2091                 
2092                 pos = begin + len;
2093 
2094                 if (pos < offset) {
2095                         len   = 0;
2096                         begin = pos;
2097                 }
2098                 
2099                 if (pos > offset + length)
2100                         break;
2101         }
2102 
2103         sti();
2104 
2105         *start = buffer + (offset - begin);
2106         len   -= (offset - begin);
2107 
2108         if (len > length) len = length;
2109 
2110         return(len);
2111 } 
2112 
2113 static struct proto_ops ax25_proto_ops = {
2114         AF_AX25,
2115         
2116         ax25_create,
2117         ax25_dup,
2118         ax25_release,
2119         ax25_bind,
2120         ax25_connect,
2121         ax25_socketpair,
2122         ax25_accept,
2123         ax25_getname,
2124         ax25_read,
2125         ax25_write,
2126         ax25_select,
2127         ax25_ioctl,
2128         ax25_listen,
2129         ax25_send,
2130         ax25_recv,
2131         ax25_sendto,
2132         ax25_recvfrom,
2133         ax25_shutdown,
2134         ax25_setsockopt,
2135         ax25_getsockopt,
2136         ax25_fcntl,
2137         ax25_sendmsg,
2138         ax25_recvmsg
2139 };
2140 
2141 /* Called by socket.c on kernel start up */
2142 
2143 static struct packet_type ax25_packet_type = 
2144 {
2145         0,      /* MUTTER ntohs(ETH_P_AX25),*/
2146         0,              /* copy */
2147         kiss_rcv,
2148         NULL,
2149         NULL,
2150 };
2151 
2152 static struct packet_type bpq_packet_type = 
2153 {
2154         0,      /* MUTTER ntohs(ETH_P_BPQ),*/
2155         0,              /* copy */
2156         bpq_rcv,
2157         NULL,
2158         NULL,
2159 };
2160 
2161 static struct notifier_block ax25_dev_notifier = {
2162         ax25_device_event,
2163         0
2164 };
2165 
2166 void ax25_proto_init(struct net_proto *pro)
     /* [previous][next][first][last][top][bottom][index][help] */
2167 {
2168         sock_register(ax25_proto_ops.family, &ax25_proto_ops);
2169         ax25_packet_type.type = htons(ETH_P_AX25);
2170         dev_add_pack(&ax25_packet_type);        
2171         bpq_packet_type.type  = htons(ETH_P_BPQ);
2172         dev_add_pack(&bpq_packet_type);
2173         register_netdevice_notifier(&ax25_dev_notifier);
2174                           
2175         proc_net_register(&(struct proc_dir_entry) {
2176                 PROC_NET_AX25_ROUTE, 10, "ax25_route",
2177                 S_IFREG | S_IRUGO, 1, 0, 0,
2178                 0, &proc_net_inode_operations,
2179                 ax25_rt_get_info
2180         });
2181         proc_net_register(&(struct proc_dir_entry) {
2182                 PROC_NET_AX25, 4, "ax25",
2183                 S_IFREG | S_IRUGO, 1, 0, 0,
2184                 0, &proc_net_inode_operations,
2185                 ax25_get_info
2186         });
2187         proc_net_register(&(struct proc_dir_entry) {
2188                 PROC_NET_AX25_CALLS, 10, "ax25_calls",
2189                 S_IFREG | S_IRUGO, 1, 0, 0,
2190                 0, &proc_net_inode_operations,
2191                 ax25_cs_get_info
2192         });
2193 
2194         printk("G4KLX/GW4PTS AX.25 for Linux. Version 0.30 ALPHA for Linux NET3.031 (Linux 1.3.25)\n");
2195 }
2196 
2197 /*
2198  *      A small shim to dev_queue_xmit to handle the difference between
2199  *      KISS AX.25 and BPQ AX.25.
2200  */
2201 void ax25_queue_xmit(struct sk_buff *skb, struct device *dev, int pri)
     /* [previous][next][first][last][top][bottom][index][help] */
2202 {
2203         static char bcast_addr[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
2204         unsigned char *ptr;
2205         int size;
2206 
2207         if (dev->type == ARPHRD_ETHER) {
2208                 if (skb_headroom(skb) < AX25_BPQ_HEADER_LEN) {
2209                         printk("ax25_queue_xmit: not enough space to add BPQ Ether header\n");
2210                         skb->free = 1;
2211                         kfree_skb(skb, FREE_WRITE);
2212                         return;
2213                 }
2214 
2215                 size = skb->len;
2216         
2217                 ptr = skb_push(skb, 2);
2218 
2219                 *ptr++ = (size + 5) % 256;
2220                 *ptr++ = (size + 5) / 256;
2221 
2222                 dev->hard_header(skb, dev, ETH_P_BPQ, bcast_addr, NULL, 0);
2223         } else {
2224                 ptr = skb_push(skb, 1);
2225                 
2226                 *ptr++ = 0;                     /* KISS */
2227         }
2228 
2229         dev_queue_xmit(skb, dev, pri);
2230 }
2231 
2232 /*******************************************************************************************************************\
2233 *                                                                                                                   *
2234 *               Driver encapsulation support: Moved out of SLIP because a) it should be here                        *
2235 *                                                                       b) for HDLC cards                           *
2236 *                                                                                                                   *
2237 \*******************************************************************************************************************/
2238 
2239 /*
2240  *      Shove an AX.25 UI header on an IP packet and handle ARP
2241  */
2242 
2243 #ifdef CONFIG_INET
2244  
2245 int ax25_encapsulate(struct sk_buff *skb, struct device *dev, unsigned short type, void *daddr,
     /* [previous][next][first][last][top][bottom][index][help] */
2246                 void *saddr, unsigned len)
2247 {
2248         /* header is an AX.25 UI frame from us to them */
2249         unsigned char *buff = skb_push(skb, AX25_HEADER_LEN);
2250 
2251         *buff++ = 0;    /* KISS DATA */
2252         
2253         if (daddr != NULL)
2254                 memcpy(buff, daddr, dev->addr_len);     /* Address specified */
2255 
2256         buff[6] &= ~LAPB_C;
2257         buff[6] &= ~LAPB_E;
2258         buff[6] |= SSSID_SPARE;
2259         buff += AX25_ADDR_LEN;
2260 
2261         if (saddr != NULL)
2262                 memcpy(buff, saddr, dev->addr_len);
2263         else
2264                 memcpy(buff, dev->dev_addr, dev->addr_len);
2265 
2266         buff[6] &= ~LAPB_C;
2267         buff[6] |= LAPB_E;
2268         buff[6] |= SSSID_SPARE;
2269         buff   += AX25_ADDR_LEN;
2270 
2271         *buff++ = LAPB_UI;      /* UI */
2272 
2273         /* Append a suitable AX.25 PID */
2274         switch (type) {
2275                 case ETH_P_IP:
2276                         *buff++ = AX25_P_IP;
2277                         break;
2278 
2279                 case ETH_P_ARP:
2280                         *buff++ = AX25_P_ARP;
2281                         break;
2282                 default:
2283                         *buff++ = 0;
2284                         break;
2285         }
2286         
2287         if (daddr != NULL)
2288                 return AX25_HEADER_LEN;
2289 
2290         return -AX25_HEADER_LEN;        /* Unfinished header */
2291 }
2292 
2293 int ax25_rebuild_header(unsigned char *bp, struct device *dev, unsigned long dest, struct sk_buff *skb)
     /* [previous][next][first][last][top][bottom][index][help] */
2294 {
2295         int mode;
2296 
2297         if (arp_find(bp + 1, dest, dev, dev->pa_addr, skb))
2298                 return 1;
2299 
2300         if (bp[16] == AX25_P_IP) {
2301                 mode = ax25_ip_mode_get((ax25_address *)(bp + 1), dev);
2302                 if (mode == 'V' || mode == 'v' || (mode == ' ' && ax25_dev_get_value(dev, AX25_VALUES_IPDEFMODE) == 'V')) {
2303                         skb_device_unlock(skb);
2304                         skb_pull(skb, AX25_HEADER_LEN - 1);     /* Keep PID */
2305                         ax25_send_frame(skb, (ax25_address *)(bp + 8), (ax25_address *)(bp + 1), NULL, dev);
2306                         return 1;
2307                 }
2308         }
2309 
2310         bp[7]  &= ~LAPB_C;
2311         bp[7]  &= ~LAPB_E;
2312         bp[7]  |= SSSID_SPARE;
2313 
2314         bp[14] &= ~LAPB_C;
2315         bp[14] |= LAPB_E;
2316         bp[14] |= SSSID_SPARE;
2317 
2318         return 0;
2319 }       
2320 
2321 #endif
2322 
2323 #endif

/* [previous][next][first][last][top][bottom][index][help] */