net/ax25/af

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

DEFINITIONS
