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

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