net/netrom/af_netrom.c

/* */
This source file includes following definitions.
nr_remove_socket
nr_kill_by_device
nr_device_event
nr_insert_socket
nr_find_listener
nr_find_socket
nr_find_peer
nr_destroy_timer
nr_destroy_socket
nr_fcntl
nr_setsockopt
nr_getsockopt
nr_listen
def_callback1
def_callback2
nr_create
nr_make_new
nr_dup
nr_release
nr_bind
nr_connect
nr_socketpair
nr_accept
nr_getname
nr_rx_frame
nr_sendto
nr_send
nr_write
nr_recvfrom
nr_recv
nr_read
nr_shutdown
nr_select
nr_ioctl
nr_get_info
nr_proto_init
   1 /*
   2  *      NET/ROM release 003
   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.3.0 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  *      NET/ROM 001     Jonathan(G4KLX) Cloned from the AX25 code.
  17  *      NET/ROM 002     Darryl(G7LED)   Fixes and address enhancement.
  18  *                      Jonathan(G4KLX) Complete bind re-think.
  19  *                      Alan(GW4PTS)    Trivial tweaks into new format.
  20  *      NET/ROM 003     Jonathan(G4KLX) Added G8BPQ extensions.
  21  *                                      Added NET/ROM routing ioctl.
  22  *
  23  *      To do:
  24  *              Fix non-blocking connect failure.
  25  */
  26   
  27 #include <linux/config.h>
  28 #ifdef CONFIG_NETROM
  29 #include <linux/errno.h>
  30 #include <linux/types.h>
  31 #include <linux/socket.h>
  32 #include <linux/in.h>
  33 #include <linux/kernel.h>
  34 #include <linux/sched.h>
  35 #include <linux/timer.h>
  36 #include <linux/string.h>
  37 #include <linux/sockios.h>
  38 #include <linux/net.h>
  39 #include <net/ax25.h>
  40 #include <linux/inet.h>
  41 #include <linux/netdevice.h>
  42 #include <linux/if_arp.h>
  43 #include <linux/skbuff.h>
  44 #include <net/sock.h>
  45 #include <asm/segment.h>
  46 #include <asm/system.h>
  47 #include <linux/fcntl.h>
  48 #include <linux/termios.h>      /* For TIOCINQ/OUTQ */
  49 #include <linux/mm.h>
  50 #include <linux/interrupt.h>
  51 #include <linux/notifier.h>
  52 #include <net/netrom.h>
  53 #include <linux/proc_fs.h>
  54 #include <net/ip.h>
  55 #include <net/arp.h>
  56 
  57 #include <linux/proc_fs.h>
  58 
  59 /************************************************************************\
  60 *                                                                       *
  61 *                       Handlers for the socket list                    *
  62 *                                                                       *
  63 \************************************************************************/
  64 
  65 struct nr_parms_struct nr_default;
  66 
  67 static unsigned short circuit = 0x101;
  68 
  69 static struct sock *volatile nr_list = NULL;
  70 
  71 /*
  72  *      Socket removal during an interrupt is now safe.
  73  */
  74 static void nr_remove_socket(struct sock *sk)
     /*  */
  75 {
  76         struct sock *s;
  77         unsigned long flags;
  78         
  79         save_flags(flags);
  80         cli();
  81 
  82         if ((s = nr_list) == sk) {
  83                 nr_list = s->next;
  84                 restore_flags(flags);
  85                 return;
  86         }
  87 
  88         while (s != NULL && s->next != NULL) {
  89                 if (s->next == sk) {
  90                         s->next = sk->next;
  91                         restore_flags(flags);
  92                         return;
  93                 }
  94 
  95                 s = s->next;
  96         }
  97 
  98         restore_flags(flags);
  99 }
 100 
 101 /*
 102  *      Kill all bound sockets on a dropped device.
 103  */
 104 static void nr_kill_by_device(struct device *dev)
     /*  */
 105 {
 106         struct sock *s;
 107         
 108         for (s = nr_list; s != NULL; s = s->next) {
 109                 if (s->nr->device == dev) {
 110                         s->nr->state  = NR_STATE_0;
 111                         s->nr->device = NULL;
 112                         s->state = TCP_CLOSE;
 113                         s->err   = ENETUNREACH;
 114                         s->state_change(s);
 115                         s->dead  = 1;
 116                 }
 117         }
 118 }
 119 
 120 /*
 121  *      Handle device status changes.
 122  */
 123 static int nr_device_event(unsigned long event, void *ptr)
     /*  */
 124 {
 125         struct device *dev = (struct device *)ptr;
 126 
 127         if (event != NETDEV_DOWN)
 128                 return NOTIFY_DONE;
 129                 
 130         nr_kill_by_device(dev);
 131         nr_rt_device_down(dev);
 132         
 133         return NOTIFY_DONE;
 134 }
 135 
 136 /*
 137  *      Add a socket to the bound sockets list.
 138  */
 139 static void nr_insert_socket(struct sock *sk)
     /*  */
 140 {
 141         unsigned long flags;
 142 
 143         save_flags(flags);
 144         cli();
 145 
 146         sk->next = nr_list;
 147         nr_list  = sk;
 148 
 149         restore_flags(flags);
 150 }
 151 
 152 /*
 153  *      Find a socket that wants to accept the Connect Request we just
 154  *      received.
 155  */
 156 static struct sock *nr_find_listener(ax25_address *addr, int type)
     /*  */
 157 {
 158         unsigned long flags;
 159         struct sock *s;
 160 
 161         save_flags(flags);
 162         cli();
 163 
 164         for (s = nr_list; s != NULL; s = s->next) {
 165                 if (ax25cmp(&s->nr->source_addr, addr) == 0 && s->type == type && s->state == TCP_LISTEN) {
 166                         restore_flags(flags);
 167                         return s;
 168                 }
 169         }
 170 
 171         restore_flags(flags);
 172         return NULL;
 173 }
 174 
 175 /*
 176  *      Find a connected NET/ROM socket given my circuit IDs.
 177  */
 178 static struct sock *nr_find_socket(unsigned char index, unsigned char id, int type)
     /*  */
 179 {
 180         struct sock *s;
 181         unsigned long flags;
 182 
 183         save_flags(flags);
 184         cli();
 185 
 186         for (s = nr_list; s != NULL; s = s->next) {
 187                 if (s->nr->my_index == index && s->nr->my_id == id && s->type == type) {
 188                         restore_flags(flags);
 189                         return s;
 190                 }
 191         }
 192 
 193         restore_flags(flags);
 194 
 195         return NULL;
 196 }
 197 
 198 /*
 199  *      Find a connected NET/ROM socket given their circuit IDs.
 200  */
 201 static struct sock *nr_find_peer(unsigned char index, unsigned char id, int type)
     /*  */
 202 {
 203         struct sock *s;
 204         unsigned long flags;
 205 
 206         save_flags(flags);
 207         cli();
 208 
 209         for (s = nr_list; s != NULL; s = s->next) {
 210                 if (s->nr->your_index == index && s->nr->your_id == id && s->type == type) {
 211                         restore_flags(flags);
 212                         return s;
 213                 }
 214         }
 215 
 216         restore_flags(flags);
 217 
 218         return NULL;
 219 }
 220 
 221 /*
 222  *      Deferred destroy.
 223  */
 224 void nr_destory_socket(struct sock *);
 225 
 226 /*
 227  *      Handler for deferred kills.
 228  */
 229 static void nr_destroy_timer(unsigned long data)
     /*  */
 230 {
 231         nr_destroy_socket((struct sock *)data);
 232 }
 233 
 234 /*
 235  *      This is called from user mode and the timers. Thus it protects itself against
 236  *      interrupt users but doesn't worry about being called during work.
 237  *      Once it is removed from the queue no interrupt or bottom half will
 238  *      touch it and we are (fairly 8-) ) safe.
 239  */
 240 void nr_destroy_socket(struct sock *sk) /* Not static as its used by the timer */
     /*  */
 241 {
 242         struct sk_buff *skb;
 243         unsigned long flags;
 244         
 245         save_flags(flags);
 246         cli();
 247         
 248         del_timer(&sk->timer);
 249         
 250         nr_remove_socket(sk);
 251         nr_clear_queues(sk);            /* Flush the queues */
 252         
 253         while ((skb = skb_dequeue(&sk->receive_queue)) != NULL) {
 254                 if (skb->sk != sk) {                    /* A pending connection */
 255                         skb->sk->dead = 1;      /* Queue the unaccepted socket for death */
 256                         nr_set_timer(skb->sk);
 257                         skb->sk->nr->state = NR_STATE_0;
 258                 }
 259 
 260                 kfree_skb(skb, FREE_READ);
 261         }
 262         
 263         if (sk->wmem_alloc || sk->rmem_alloc) { /* Defer: outstanding buffers */
 264                 init_timer(&sk->timer);
 265                 sk->timer.expires  = jiffies + 10 * HZ;
 266                 sk->timer.function = nr_destroy_timer;
 267                 sk->timer.data     = (unsigned long)sk;
 268                 add_timer(&sk->timer);
 269         } else {
 270                 kfree_s(sk->nr, sizeof(*sk->nr));
 271                 kfree_s(sk, sizeof(*sk));
 272         }
 273 
 274         restore_flags(flags);
 275 }
 276 
 277 /*******************************************************************************************************************\
 278 *                                                                                                                   *
 279 * Handling for system calls applied via the various interfaces to a NET/ROM socket object                           *
 280 *                                                                                                                   *
 281 \*******************************************************************************************************************/
 282  
 283 static int nr_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
     /*  */
 284 {
 285         switch(cmd)
 286         {
 287                 default:
 288                         return(-EINVAL);
 289         }
 290 }
 291 
 292 static int nr_setsockopt(struct socket *sock, int level, int optname,
     /*  */
 293         char *optval, int optlen)
 294 {
 295         struct sock *sk;
 296         int err, opt;
 297 
 298         sk = (struct sock *)sock->data;
 299         
 300         if (level == SOL_SOCKET)
 301                 return sock_setsockopt(sk, level, optname, optval, optlen);
 302 
 303         if (level != SOL_NETROM)
 304                 return -EOPNOTSUPP;
 305 
 306         if (optval == NULL)
 307                 return -EINVAL;
 308 
 309         if ((err = verify_area(VERIFY_READ, optval, sizeof(int))) != 0)
 310                 return err;
 311 
 312         opt = get_fs_long((unsigned long *)optval);
 313         
 314         switch (optname) {
 315                 case NETROM_T1:
 316                         if (opt < 1)
 317                                 return -EINVAL;
 318                         sk->nr->rtt = (opt * PR_SLOWHZ) / 2;
 319                         return 0;
 320 
 321                 case NETROM_T2:
 322                         if (opt < 1)
 323                                 return -EINVAL;
 324                         sk->nr->t2 = opt * PR_SLOWHZ;
 325                         return 0;
 326                         
 327                 case NETROM_N2:
 328                         if (opt < 1 || opt > 31)
 329                                 return -EINVAL;
 330                         sk->nr->n2 = opt;
 331                         return 0;
 332                         
 333                 case NETROM_HDRINCL:
 334                         sk->nr->hdrincl = opt ? 1 : 0;
 335                         return 0;
 336                         
 337                 default:
 338                         return -ENOPROTOOPT;
 339         }
 340 }
 341 
 342 static int nr_getsockopt(struct socket *sock, int level, int optname,
     /*  */
 343         char *optval, int *optlen)
 344 {
 345         struct sock *sk;
 346         int val = 0;
 347         int err; 
 348 
 349         sk = (struct sock *)sock->data;
 350         
 351         if (level == SOL_SOCKET)
 352                 return sock_getsockopt(sk, level, optname, optval, optlen);
 353         
 354         if (level != SOL_NETROM)
 355                 return -EOPNOTSUPP;
 356         
 357         switch (optname) {
 358                 case NETROM_T1:
 359                         val = (sk->nr->t1 * 2) / PR_SLOWHZ;
 360                         break;
 361                         
 362                 case NETROM_T2:
 363                         val = sk->nr->t2 / PR_SLOWHZ;
 364                         break;
 365                         
 366                 case NETROM_N2:
 367                         val = sk->nr->n2;
 368                         break;
 369                                                 
 370                 case NETROM_HDRINCL:
 371                         val = sk->nr->hdrincl;
 372                         break;
 373 
 374                 default:
 375                         return -ENOPROTOOPT;
 376         }
 377 
 378         if ((err = verify_area(VERIFY_WRITE, optlen, sizeof(int))) != 0)
 379                 return err;
 380 
 381         put_fs_long(sizeof(int), (unsigned long *)optlen);
 382 
 383         if ((err = verify_area(VERIFY_WRITE, optval, sizeof(int))) != 0)
 384                 return err;
 385 
 386         put_fs_long(val, (unsigned long *)optval);
 387 
 388         return 0;
 389 }
 390 
 391 static int nr_listen(struct socket *sock, int backlog)
     /*  */
 392 {
 393         struct sock *sk = (struct sock *)sock->data;
 394 
 395         if (sk->type == SOCK_SEQPACKET && sk->state != TCP_LISTEN) {
 396                 memset(&sk->nr->user_addr, '\0', sizeof(ax25_address));
 397                 sk->max_ack_backlog = backlog;
 398                 sk->state           = TCP_LISTEN;
 399                 return 0;
 400         }
 401 
 402         return -EOPNOTSUPP;
 403 }
 404 
 405 static void def_callback1(struct sock *sk)
     /*  */
 406 {
 407         if (!sk->dead)
 408                 wake_up_interruptible(sk->sleep);
 409 }
 410 
 411 static void def_callback2(struct sock *sk, int len)
     /*  */
 412 {
 413         if (!sk->dead)
 414                 wake_up_interruptible(sk->sleep);
 415 }
 416 
 417 static int nr_create(struct socket *sock, int protocol)
     /*  */
 418 {
 419         struct sock *sk;
 420         nr_cb *nr;
 421 
 422         if ((sk = (struct sock *)kmalloc(sizeof(*sk), GFP_ATOMIC)) == NULL)
 423                 return -ENOMEM;
 424 
 425         if ((nr = (nr_cb *)kmalloc(sizeof(*nr), GFP_ATOMIC)) == NULL) {
 426                 kfree_s(sk, sizeof(*sk));
 427                 return -ENOMEM;
 428         }
 429 
 430         sk->type = sock->type;
 431 
 432         switch (sock->type) {
 433                 case SOCK_SEQPACKET:
 434                         break;
 435                 default:
 436                         kfree_s((void *)sk, sizeof(*sk));
 437                         kfree_s((void *)nr, sizeof(*nr));
 438                         return -ESOCKTNOSUPPORT;
 439         }
 440 
 441         skb_queue_head_init(&sk->receive_queue);
 442         skb_queue_head_init(&sk->write_queue);
 443         skb_queue_head_init(&sk->back_log);
 444 
 445         init_timer(&sk->timer);
 446 
 447         sk->socket        = sock;
 448         sk->protocol      = protocol;
 449         sk->dead          = 0;
 450         sk->next          = NULL;
 451         sk->broadcast     = 0;
 452         sk->rcvbuf        = SK_RMEM_MAX;
 453         sk->sndbuf        = SK_WMEM_MAX;
 454         sk->wmem_alloc    = 0;
 455         sk->rmem_alloc    = 0;
 456         sk->inuse         = 0;
 457         sk->debug         = 0;
 458         sk->prot          = NULL;       /* So we use default free mechanisms */
 459         sk->err           = 0;
 460         sk->localroute    = 0;
 461         sk->send_head     = NULL;
 462         sk->state         = TCP_CLOSE;
 463         sk->shutdown      = 0;
 464         sk->priority      = SOPRI_NORMAL;
 465         sk->ack_backlog   = 0;
 466         sk->mtu           = NETROM_MTU; /* 236 */
 467         sk->zapped        = 1;
 468         sk->window        = nr_default.window;
 469 
 470         sk->state_change = def_callback1;
 471         sk->data_ready   = def_callback2;
 472         sk->write_space  = def_callback1;
 473         sk->error_report = def_callback1;
 474 
 475         if (sock != NULL) {
 476                 sock->data = (void *)sk;
 477                 sk->sleep  = sock->wait;
 478         }
 479 
 480         skb_queue_head_init(&nr->ack_queue);
 481         skb_queue_head_init(&nr->reseq_queue);
 482         skb_queue_head_init(&nr->frag_queue);
 483 
 484         nr->my_index = 0;
 485         nr->my_id    = 0;
 486         nr->rtt      = nr_default.timeout;
 487         nr->t1       = nr_default.timeout;
 488         nr->t2       = nr_default.ack_delay;
 489         nr->n2       = nr_default.tries;
 490 
 491         nr->t1timer  = 0;
 492         nr->t2timer  = 0;
 493         nr->t4timer  = 0;
 494         nr->n2count  = 0;
 495 
 496         nr->va       = 0;
 497         nr->vr       = 0;
 498         nr->vs       = 0;
 499         nr->vl       = 0;
 500 
 501         nr->your_index = 0;
 502         nr->your_id    = 0;
 503 
 504         nr->my_index   = 0;
 505         nr->my_id      = 0;
 506 
 507         nr->bpqext     = 1;
 508         nr->fraglen    = 0;
 509         nr->hdrincl    = 0;
 510         nr->state      = NR_STATE_0;
 511         nr->device     = NULL;
 512 
 513         memset(&nr->source_addr, '\0', sizeof(ax25_address));
 514         memset(&nr->user_addr,   '\0', sizeof(ax25_address));
 515         memset(&nr->dest_addr,   '\0', sizeof(ax25_address));
 516 
 517         nr->sk = sk;
 518         sk->nr = nr;
 519 
 520         return 0;
 521 }
 522 
 523 static struct sock *nr_make_new(struct sock *osk)
     /*  */
 524 {
 525         struct sock *sk;
 526         nr_cb *nr;
 527 
 528         if ((sk = (struct sock *)kmalloc(sizeof(*sk), GFP_ATOMIC)) == NULL)
 529                 return NULL;
 530 
 531         if ((nr = (nr_cb *)kmalloc(sizeof(*nr), GFP_ATOMIC)) == NULL) {
 532                 kfree_s(sk, sizeof(*sk));
 533                 return NULL;
 534         }
 535 
 536         sk->type   = osk->type;
 537         sk->socket = osk->socket;
 538 
 539         switch (osk->type) {
 540                 case SOCK_SEQPACKET:
 541                         break;
 542                 default:
 543                         kfree_s((void *)sk, sizeof(*sk));
 544                         kfree_s((void *)nr, sizeof(*nr));
 545                         return NULL;
 546         }
 547 
 548         skb_queue_head_init(&sk->receive_queue);
 549         skb_queue_head_init(&sk->write_queue);
 550         skb_queue_head_init(&sk->back_log);
 551 
 552         init_timer(&sk->timer);
 553 
 554         sk->dead        = 0;
 555         sk->next        = NULL;
 556         sk->priority    = osk->priority;
 557         sk->broadcast   = 0;
 558         sk->protocol    = osk->protocol;
 559         sk->rcvbuf      = osk->rcvbuf;
 560         sk->sndbuf      = osk->sndbuf;
 561         sk->wmem_alloc  = 0;
 562         sk->rmem_alloc  = 0;
 563         sk->inuse       = 0;
 564         sk->ack_backlog = 0;
 565         sk->prot        = NULL; /* So we use default free mechanisms */
 566         sk->err         = 0;
 567         sk->localroute  = 0;
 568         sk->send_head   = NULL;
 569         sk->debug       = osk->debug;
 570         sk->state       = TCP_ESTABLISHED;
 571         sk->window      = osk->window;
 572         sk->shutdown    = 0;
 573         sk->mtu         = osk->mtu;
 574         sk->sleep       = osk->sleep;
 575         sk->zapped      = osk->zapped;
 576 
 577         sk->state_change = def_callback1;
 578         sk->data_ready   = def_callback2;
 579         sk->write_space  = def_callback1;
 580         sk->error_report = def_callback1;
 581 
 582         skb_queue_head_init(&nr->ack_queue);
 583         skb_queue_head_init(&nr->reseq_queue);
 584         skb_queue_head_init(&nr->frag_queue);
 585 
 586         nr->rtt      = osk->nr->rtt;
 587         nr->t1       = osk->nr->t1;
 588         nr->t2       = osk->nr->t2;
 589         nr->n2       = osk->nr->n2;
 590 
 591         nr->device   = osk->nr->device;
 592         nr->bpqext   = osk->nr->bpqext;
 593         nr->hdrincl  = osk->nr->hdrincl;
 594         nr->fraglen  = 0;
 595 
 596         nr->t1timer  = 0;
 597         nr->t2timer  = 0;
 598         nr->t4timer  = 0;
 599         nr->n2count  = 0;
 600 
 601         nr->va       = 0;
 602         nr->vr       = 0;
 603         nr->vs       = 0;
 604         nr->vl       = 0;
 605         
 606         sk->nr = nr;
 607         nr->sk = sk;
 608 
 609         return sk;
 610 }
 611 
 612 static int nr_dup(struct socket *newsock, struct socket *oldsock)
     /*  */
 613 {
 614         struct sock *sk = (struct sock *)oldsock->data;
 615 
 616         return nr_create(newsock, sk->protocol);
 617 }
 618 
 619 static int nr_release(struct socket *sock, struct socket *peer)
     /*  */
 620 {
 621         struct sock *sk = (struct sock *)sock->data;
 622 
 623         if (sk == NULL) return 0;
 624 
 625         if (sk->type == SOCK_SEQPACKET) {
 626                 switch (sk->nr->state) {
 627                         case NR_STATE_0:
 628                                 sk->dead      = 1;
 629                                 sk->state_change(sk);
 630                                 nr_destroy_socket(sk);
 631                                 break;
 632 
 633                         case NR_STATE_1:
 634                                 sk->nr->state = NR_STATE_0;
 635                                 sk->dead      = 1;
 636                                 sk->state_change(sk);
 637                                 nr_destroy_socket(sk);
 638                                 break;
 639 
 640                         case NR_STATE_2:
 641                                 nr_write_internal(sk, NR_DISCACK);
 642                                 sk->nr->state = NR_STATE_0;
 643                                 sk->dead      = 1;
 644                                 sk->state_change(sk);
 645                                 nr_destroy_socket(sk);
 646                                 break;                  
 647 
 648                         case NR_STATE_3:
 649                                 nr_clear_queues(sk);
 650                                 sk->nr->n2count = 0;
 651                                 nr_write_internal(sk, NR_DISCREQ);
 652                                 sk->nr->t1timer = sk->nr->t1 = nr_calculate_t1(sk);
 653                                 sk->nr->t2timer = 0;
 654                                 sk->nr->t4timer = 0;
 655                                 sk->nr->state   = NR_STATE_2;
 656                                 sk->state_change(sk);
 657                                 sk->dead        = 1;
 658                                 break;
 659 
 660                         default:
 661                                 break;
 662                 }
 663         } else {
 664                 sk->dead = 1;
 665                 sk->state_change(sk);
 666                 nr_destroy_socket(sk);
 667         }
 668 
 669         sock->data = NULL;      
 670 
 671         return 0;
 672 }
 673 
 674 static int nr_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
     /*  */
 675 {
 676         struct sock *sk;
 677         struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
 678         struct device *dev;
 679         ax25_address *user, *source;
 680         
 681         sk = (struct sock *)sock->data;
 682 
 683         if (sk->zapped == 0)
 684                 return -EIO;
 685                 
 686         if (addr_len != sizeof(struct sockaddr_ax25) && addr_len != sizeof(struct full_sockaddr_ax25))
 687                 return -EINVAL;
 688 
 689 #ifdef DONTDO
 690         if (nr_find_listener(&addr->fsa_ax25.sax25_call, sk->type) != NULL) {
 691                 if (sk->debug)
 692                         printk("NET/ROM: bind failed: in use\n");
 693                 return -EADDRINUSE;
 694         }
 695 #endif
 696 
 697         if ((dev = nr_dev_get(&addr->fsa_ax25.sax25_call)) == NULL) {
 698                 if (sk->debug)
 699                         printk("NET/ROM: bind failed: invalid node callsign\n");
 700                 return -EADDRNOTAVAIL;
 701         }
 702 
 703         /*
 704          * Only the super user can set an arbitrary user callsign.
 705          */
 706         if (addr->fsa_ax25.sax25_ndigis == 1) {
 707                 if (!suser())
 708                         return -EPERM;
 709                 memcpy(&sk->nr->user_addr,   &addr->fsa_digipeater[0],   sizeof(ax25_address));
 710                 memcpy(&sk->nr->source_addr, &addr->fsa_ax25.sax25_call, sizeof(ax25_address));
 711         } else {
 712                 source = &addr->fsa_ax25.sax25_call;
 713 
 714                 if ((user = ax25_findbyuid(current->euid)) == NULL) {
 715                         if (ax25_uid_policy && !suser())
 716                                 return -EPERM;
 717                         user = source;
 718                 }
 719 
 720                 memcpy(&sk->nr->user_addr,   user,   sizeof(ax25_address));
 721                 memcpy(&sk->nr->source_addr, source, sizeof(ax25_address));
 722         }
 723 
 724         sk->nr->device = dev;
 725         nr_insert_socket(sk);
 726 
 727         sk->zapped = 0;
 728 
 729         if (sk->debug)
 730                 printk("NET/ROM: socket is bound\n");
 731 
 732         return 0;
 733 }
 734 
 735 static int nr_connect(struct socket *sock, struct sockaddr *uaddr,
     /*  */
 736         int addr_len, int flags)
 737 {
 738         struct sock *sk = (struct sock *)sock->data;
 739         struct sockaddr_ax25 *addr = (struct sockaddr_ax25 *)uaddr;
 740         ax25_address *user, *source = NULL;
 741         struct device *dev;
 742         
 743         if (sk->state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
 744                 sock->state = SS_CONNECTED;
 745                 return 0;       /* Connect completed during a ERESTARTSYS event */
 746         }
 747         
 748         if (sk->state == TCP_CLOSE && sock->state == SS_CONNECTING) {
 749                 sock->state = SS_UNCONNECTED;
 750                 return -ECONNREFUSED;
 751         }
 752         
 753         if (sk->state == TCP_ESTABLISHED && sk->type == SOCK_SEQPACKET)
 754                 return -EISCONN;        /* No reconnect on a seqpacket socket */
 755                 
 756         sk->state   = TCP_CLOSE;        
 757         sock->state = SS_UNCONNECTED;
 758 
 759         if (addr_len != sizeof(struct sockaddr_ax25))
 760                 return -EINVAL;
 761 
 762         if ((dev = nr_dev_first()) == NULL)
 763                 return -ENETUNREACH;
 764                 
 765         if (sk->zapped) {       /* Must bind first - autobinding in this may or may not work */
 766                 sk->zapped = 0;
 767 
 768                 source = (ax25_address *)dev->dev_addr;
 769 
 770                 if ((user = ax25_findbyuid(current->euid)) == NULL) {
 771                         if (ax25_uid_policy && !suser())
 772                                 return -EPERM;
 773                         user = source;
 774                 }
 775 
 776                 memcpy(&sk->nr->user_addr,   user,   sizeof(ax25_address));
 777                 memcpy(&sk->nr->source_addr, source, sizeof(ax25_address));
 778 
 779                 nr_insert_socket(sk);           /* Finish the bind */
 780         }
 781                 
 782         memcpy(&sk->nr->dest_addr, &addr->sax25_call, sizeof(ax25_address));
 783 
 784         sk->nr->my_index = circuit / 256;
 785         sk->nr->my_id    = circuit % 256;
 786 
 787         circuit++;
 788         
 789         /* Move to connecting socket, start sending Connect Requests */
 790         sock->state   = SS_CONNECTING;
 791         sk->state     = TCP_SYN_SENT;
 792         nr_establish_data_link(sk);
 793         sk->nr->state = NR_STATE_1;
 794         nr_set_timer(sk);
 795         
 796         /* Now the loop */
 797         if (sk->state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
 798                 return -EINPROGRESS;
 799                 
 800         cli();  /* To avoid races on the sleep */
 801 
 802         /*
 803          * A Connect Ack with Choke or timeout or failed routing will go to closed.
 804          */
 805         while (sk->state == TCP_SYN_SENT) {
 806                 interruptible_sleep_on(sk->sleep);
 807                 if (current->signal & ~current->blocked) {
 808                         sti();
 809                         return -ERESTARTSYS;
 810                 }
 811         }
 812 
 813         if (sk->state != TCP_ESTABLISHED) {
 814                 sti();
 815                 sock->state = SS_UNCONNECTED;
 816                 return -sk->err;        /* Always set at this point */
 817         }
 818         
 819         sock->state = SS_CONNECTED;
 820 
 821         sti();
 822         
 823         return 0;
 824 }
 825         
 826 static int nr_socketpair(struct socket *sock1, struct socket *sock2)
     /*  */
 827 {
 828         return -EOPNOTSUPP;
 829 }
 830 
 831 static int nr_accept(struct socket *sock, struct socket *newsock, int flags)
     /*  */
 832 {
 833         struct sock *sk;
 834         struct sock *newsk;
 835         struct sk_buff *skb;
 836 
 837         if (newsock->data)
 838                 kfree_s(newsock->data, sizeof(struct sock));
 839 
 840         newsock->data = NULL;
 841         
 842         sk = (struct sock *)sock->data;
 843 
 844         if (sk->type != SOCK_SEQPACKET)
 845                 return -EOPNOTSUPP;
 846         
 847         if (sk->state != TCP_LISTEN)
 848                 return -EINVAL;
 849                 
 850         /* The write queue this time is holding sockets ready to use
 851            hooked into the SABM we saved */
 852         do {
 853                 cli();
 854                 if ((skb = skb_dequeue(&sk->receive_queue)) == NULL) {
 855                         if (flags & O_NONBLOCK) {
 856                                 sti();
 857                                 return 0;
 858                         }
 859                         interruptible_sleep_on(sk->sleep);
 860                         if (current->signal & ~current->blocked) {
 861                                 sti();
 862                                 return -ERESTARTSYS;
 863                         }
 864                 }
 865         } while (skb == NULL);
 866 
 867         newsk = skb->sk;
 868         newsk->pair = NULL;
 869         sti();
 870 
 871         /* Now attach up the new socket */
 872         skb->sk = NULL;
 873         kfree_skb(skb, FREE_READ);
 874         sk->ack_backlog--;
 875         newsock->data = newsk;
 876 
 877         return 0;
 878 }
 879 
 880 static int nr_getname(struct socket *sock, struct sockaddr *uaddr,
     /*  */
 881         int *uaddr_len, int peer)
 882 {
 883         struct full_sockaddr_ax25 *sax = (struct full_sockaddr_ax25 *)uaddr;
 884         struct sock *sk;
 885         
 886         sk = (struct sock *)sock->data;
 887         
 888         if (peer != 0) {
 889                 if (sk->state != TCP_ESTABLISHED)
 890                         return -ENOTCONN;
 891                 sax->fsa_ax25.sax25_family = AF_NETROM;
 892                 sax->fsa_ax25.sax25_ndigis = 1;
 893                 memcpy(&sax->fsa_ax25.sax25_call, &sk->nr->user_addr, sizeof(ax25_address));
 894                 memcpy(&sax->fsa_digipeater[0],   &sk->nr->dest_addr, sizeof(ax25_address));
 895                 *uaddr_len = sizeof(struct sockaddr_ax25) + sizeof(ax25_address);
 896         } else {
 897                 sax->fsa_ax25.sax25_family = AF_NETROM;
 898                 sax->fsa_ax25.sax25_ndigis = 0;
 899                 memcpy(&sax->fsa_ax25.sax25_call, &sk->nr->source_addr, sizeof(ax25_address));
 900                 *uaddr_len = sizeof(struct sockaddr_ax25);
 901         }
 902 
 903         return 0;
 904 }
 905  
 906 int nr_rx_frame(struct sk_buff *skb, struct device *dev)
     /*  */
 907 {
 908         struct sock *sk;
 909         struct sock *make;      
 910         ax25_address *src, *dest, *user;
 911         unsigned short circuit_index, circuit_id;
 912         unsigned short frametype, window, timeout;
 913 
 914         skb->sk = NULL;         /* Initially we don't know who its for */
 915 
 916         /*
 917          *      skb->data points to the netrom frame start
 918          */
 919         
 920         src  = (ax25_address *)(skb->data + 0);
 921         dest = (ax25_address *)(skb->data + 7);
 922 
 923         circuit_index = skb->data[15];
 924         circuit_id    = skb->data[16];
 925         frametype     = skb->data[19];
 926 
 927 #ifdef CONFIG_INET
 928         /*
 929          * Check for an incoming IP over NET/ROM frame.
 930          */
 931          if ((frametype & 0x0F) == NR_PROTOEXT && circuit_index == NR_PROTO_IP && circuit_id == NR_PROTO_IP) {
 932                 skb_pull(skb, NR_NETWORK_LEN + NR_TRANSPORT_LEN);
 933                 skb->h.raw = skb->data;
 934 
 935                 return nr_rx_ip(skb, dev);
 936          }
 937 #endif
 938 
 939         /*
 940          * Find an existing socket connection, based on circuit ID, if its
 941          * a Connect Request base it on their circuit ID.
 942          */
 943         if (((frametype & 0x0F) != NR_CONNREQ && (sk = nr_find_socket(circuit_index, circuit_id, SOCK_SEQPACKET)) != NULL) ||
 944             ((frametype & 0x0F) == NR_CONNREQ && (sk = nr_find_peer(circuit_index, circuit_id, SOCK_SEQPACKET)) != NULL)) {
 945                 skb->h.raw = skb->data;
 946 
 947                 if ((frametype & 0x0F) == NR_CONNACK && skb->len == 22)
 948                         sk->nr->bpqext = 1;
 949                 else
 950                         sk->nr->bpqext = 0;
 951 
 952                 return nr_process_rx_frame(sk, skb);
 953         }
 954 
 955         if ((frametype & 0x0F) != NR_CONNREQ)
 956                 return 0;
 957                 
 958         sk = nr_find_listener(dest, SOCK_SEQPACKET);
 959 
 960         if (sk == NULL || sk->ack_backlog == sk->max_ack_backlog || (make = nr_make_new(sk)) == NULL) {
 961                 nr_transmit_dm(skb);
 962                 return 0;
 963         }
 964 
 965         user   = (ax25_address *)(skb->data + 21);
 966         window = skb->data[20];
 967 
 968         skb->sk             = make;
 969         make->state         = TCP_ESTABLISHED;
 970 
 971         /* Fill in his circuit details */
 972         memcpy(&make->nr->source_addr, dest, sizeof(ax25_address));
 973         memcpy(&make->nr->dest_addr,   src,  sizeof(ax25_address));
 974         memcpy(&make->nr->user_addr,   user, sizeof(ax25_address));
 975                 
 976         make->nr->your_index = circuit_index;
 977         make->nr->your_id    = circuit_id;
 978 
 979         make->nr->my_index   = circuit / 256;
 980         make->nr->my_id      = circuit % 256;
 981         
 982         circuit++;
 983 
 984         /* Window negotiation */
 985         if (window < make->window)
 986                 make->window = window;
 987 
 988         /* L4 timeout negotiation */
 989         if (skb->len == 37) {
 990                 timeout = skb->data[36] * 256 + skb->data[35];
 991                 if (timeout * PR_SLOWHZ < make->nr->rtt * 2)
 992                         make->nr->rtt = (timeout * PR_SLOWHZ) / 2;
 993                 make->nr->bpqext = 1;
 994         } else {
 995                 make->nr->bpqext = 0;
 996         }
 997 
 998         nr_write_internal(make, NR_CONNACK);
 999 
1000         make->nr->condition = 0x00;
1001         make->nr->vs        = 0;
1002         make->nr->va        = 0;
1003         make->nr->vr        = 0;
1004         make->nr->vl        = 0;
1005         make->nr->state     = NR_STATE_3;
1006         sk->ack_backlog++;
1007         make->pair = sk;
1008 
1009         nr_insert_socket(make);
1010 
1011         skb_queue_head(&sk->receive_queue, skb);
1012 
1013         nr_set_timer(make);
1014 
1015         if (!sk->dead)
1016                 sk->data_ready(sk, skb->len);
1017 
1018         return 1;
1019 }
1020 
1021 static int nr_sendto(struct socket *sock, const void *ubuf, int len, int noblock,
     /*  */
1022         unsigned flags, struct sockaddr *usip, int addr_len)
1023 {
1024         struct sock *sk = (struct sock *)sock->data;
1025         struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)usip;
1026         int err;
1027         struct sockaddr_ax25 sax;
1028         struct sk_buff *skb;
1029         unsigned char *asmptr;
1030         int size;
1031         
1032         if (sk->err) {
1033                 err     = sk->err;
1034                 sk->err = 0;
1035                 return -err;
1036         }
1037 
1038         if (flags)
1039                 return -EINVAL;
1040 
1041         if (sk->zapped)
1042                 return -EADDRNOTAVAIL;
1043 
1044         if (sk->nr->device == NULL)
1045                 return -ENETUNREACH;
1046                 
1047         if (usax) {
1048                 if (addr_len < sizeof(sax))
1049                         return -EINVAL;
1050                 memcpy(&sax, usax, sizeof(sax));
1051                 if (sk->type == SOCK_SEQPACKET && memcmp(&sk->nr->dest_addr, &sax.sax25_call, sizeof(ax25_address)) != 0)
1052                         return -EISCONN;
1053                 if (sax.sax25_family != AF_NETROM)
1054                         return -EINVAL;
1055         } else {
1056                 if (sk->state != TCP_ESTABLISHED)
1057                         return -ENOTCONN;
1058                 sax.sax25_family = AF_NETROM;
1059                 memcpy(&sax.sax25_call, &sk->nr->dest_addr, sizeof(ax25_address));
1060         }
1061         
1062         if (sk->debug)
1063                 printk("NET/ROM: sendto: Addresses built.\n");
1064 
1065         /* Build a packet */
1066         if (sk->debug)
1067                 printk("NET/ROM: sendto: building packet.\n");
1068 
1069         size = len + AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + 3 + NR_NETWORK_LEN + NR_TRANSPORT_LEN;
1070 
1071         if ((skb = sock_alloc_send_skb(sk, size, 0, &err)) == NULL)
1072                 return err;
1073 
1074         skb->sk   = sk;
1075         skb->free = 1;
1076         skb->arp  = 1;
1077 
1078         skb_reserve(skb, size - len);
1079         
1080         /*
1081          *      Push down the NET/ROM header
1082          */
1083 
1084         asmptr = skb_push(skb, NR_TRANSPORT_LEN);
1085 
1086         if (sk->debug)
1087                 printk("Building NET/ROM Header.\n");
1088 
1089         /* Build a NET/ROM Transport header */
1090 
1091         *asmptr++ = sk->nr->your_index;
1092         *asmptr++ = sk->nr->your_id;
1093         *asmptr++ = 0;          /* To be filled in later */
1094         *asmptr++ = 0;          /*      Ditto            */
1095         *asmptr++ = NR_INFO;
1096         
1097         if (sk->debug)
1098                 printk("Built header.\n");
1099 
1100         /*
1101          *      Put the data on the end
1102          */
1103 
1104         skb->h.raw = skb_put(skb, len);
1105 
1106         asmptr = skb->h.raw;
1107         
1108         if (sk->debug)
1109                 printk("NET/ROM: Appending user data\n");
1110 
1111         /* User data follows immediately after the NET/ROM transport header */
1112         memcpy_fromfs(asmptr, ubuf, len);
1113 
1114         if (sk->debug)
1115                 printk("NET/ROM: Transmitting buffer\n");
1116 
1117         if (sk->state != TCP_ESTABLISHED) {
1118                 kfree_skb(skb, FREE_WRITE);
1119                 return -ENOTCONN;
1120         }
1121 
1122         nr_output(sk, skb);     /* Shove it onto the queue */
1123 
1124         return len;
1125 }
1126 
1127 static int nr_send(struct socket *sock, const void *ubuf, int size, int noblock, unsigned flags)
     /*  */
1128 {
1129         return nr_sendto(sock, ubuf, size, noblock, flags, NULL, 0);
1130 }
1131 
1132 static int nr_write(struct socket *sock, const char *ubuf, int size, int noblock)
     /*  */
1133 {
1134         return nr_send(sock, ubuf, size, noblock, 0);
1135 }
1136 
1137 static int nr_recvfrom(struct socket *sock, void *ubuf, int size, int noblock,
     /*  */
1138                    unsigned flags, struct sockaddr *sip, int *addr_len)
1139 {
1140         struct sock *sk = (struct sock *)sock->data;
1141         struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)sip;
1142         int copied;
1143         struct sk_buff *skb;
1144         int er;
1145 
1146         if (sk->err) {
1147                 er      = -sk->err;
1148                 sk->err = 0;
1149                 return er;
1150         }
1151         
1152         if (addr_len != NULL)
1153                 *addr_len = sizeof(*sax);
1154 
1155         /*
1156          * This works for seqpacket too. The receiver has ordered the queue for
1157          * us! We do one quick check first though
1158          */
1159         if (sk->type == SOCK_SEQPACKET && sk->state != TCP_ESTABLISHED)
1160                 return -ENOTCONN;
1161 
1162         /* Now we can treat all alike */
1163         if ((skb = skb_recv_datagram(sk, flags, noblock, &er)) == NULL)
1164                 return er;
1165 
1166         if (!sk->nr->hdrincl) {
1167                 skb_pull(skb, NR_NETWORK_LEN + NR_TRANSPORT_LEN);
1168                 skb->h.raw = skb->data;
1169         }
1170 
1171         copied = (size < skb->len) ? size : skb->len;
1172         skb_copy_datagram(skb, 0, ubuf, copied);
1173         
1174         if (sax != NULL) {
1175                 struct sockaddr_ax25 addr;
1176                 
1177                 addr.sax25_family = AF_NETROM;
1178                 memcpy(&addr.sax25_call, skb->data + 7, sizeof(ax25_address));
1179 
1180                 memcpy(sax, &addr, sizeof(*sax));
1181 
1182                 *addr_len = sizeof(*sax);
1183         }
1184 
1185         skb_free_datagram(skb);
1186 
1187         return copied;
1188 }               
1189 
1190 static int nr_recv(struct socket *sock, void *ubuf, int size , int noblock,
     /*  */
1191         unsigned flags)
1192 {
1193         struct sock *sk = (struct sock *)sock->data;
1194 
1195         if (sk->zapped)
1196                 return -ENOTCONN;
1197 
1198         return nr_recvfrom(sock, ubuf, size, noblock, flags, NULL, NULL);
1199 }
1200 
1201 static int nr_read(struct socket *sock, char *ubuf, int size, int noblock)
     /*  */
1202 {
1203         return nr_recv(sock, ubuf, size, noblock, 0);
1204 }
1205 
1206 static int nr_shutdown(struct socket *sk, int how)
     /*  */
1207 {
1208         return -EOPNOTSUPP;
1209 }
1210 
1211 static int nr_select(struct socket *sock , int sel_type, select_table *wait)
     /*  */
1212 {
1213         struct sock *sk = (struct sock *)sock->data;
1214 
1215         return datagram_select(sk, sel_type, wait);
1216 }
1217 
1218 static int nr_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
     /*  */
1219 {
1220         struct sock *sk = (struct sock *)sock->data;
1221         int err;
1222         long amount = 0;
1223 
1224         switch (cmd) {
1225                 case TIOCOUTQ:
1226                         if ((err = verify_area(VERIFY_WRITE, (void *)arg, sizeof(unsigned long))) != 0)
1227                                 return err;
1228                         amount = sk->sndbuf - sk->wmem_alloc;
1229                         if (amount < 0)
1230                                 amount = 0;
1231                         put_fs_long(amount, (unsigned long *)arg);
1232                         return 0;
1233 
1234                 case TIOCINQ:
1235                 {
1236                         struct sk_buff *skb;
1237                         /* These two are safe on a single CPU system as only user tasks fiddle here */
1238                         if ((skb = skb_peek(&sk->receive_queue)) != NULL)
1239                                 amount = skb->len - 20;
1240                         if ((err = verify_area(VERIFY_WRITE, (void *)arg, sizeof(unsigned long))) != 0)
1241                                 return err;
1242                         put_fs_long(amount, (unsigned long *)arg);
1243                         return 0;
1244                 }
1245 
1246                 case SIOCGSTAMP:
1247                         if (sk != NULL) {
1248                                 if (sk->stamp.tv_sec==0)
1249                                         return -ENOENT;
1250                                 if ((err = verify_area(VERIFY_WRITE,(void *)arg,sizeof(struct timeval))) != 0)
1251                                         return err;
1252                                 memcpy_tofs((void *)arg, &sk->stamp, sizeof(struct timeval));
1253                                 return 0;
1254                         }
1255                         return -EINVAL;
1256 
1257                 case SIOCGIFADDR:
1258                 case SIOCSIFADDR:
1259                 case SIOCGIFDSTADDR:
1260                 case SIOCSIFDSTADDR:
1261                 case SIOCGIFBRDADDR:
1262                 case SIOCSIFBRDADDR:
1263                 case SIOCGIFNETMASK:
1264                 case SIOCSIFNETMASK:
1265                 case SIOCGIFMETRIC:
1266                 case SIOCSIFMETRIC:
1267                         return -EINVAL;
1268 
1269                 case SIOCADDRT:
1270                 case SIOCDELRT:
1271                 case SIOCNRDECOBS:
1272                 case SIOCNRRTCTL:
1273                         if (!suser()) return -EPERM;
1274                         return nr_rt_ioctl(cmd, (void *)arg);
1275 
1276                 case SIOCNRGETPARMS:
1277                 {
1278                         struct nr_parms_struct nr_parms;
1279                         if ((err = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct nr_parms_struct))) != 0)
1280                                 return err;
1281                         memcpy_fromfs(&nr_parms, (void *)arg, sizeof(struct nr_parms_struct));
1282                         nr_parms = nr_default;
1283                         memcpy_tofs((void *)arg, &nr_parms, sizeof(struct nr_parms_struct));
1284                         return 0;
1285                 }
1286 
1287                 case SIOCNRSETPARMS:
1288                 {
1289                         struct nr_parms_struct nr_parms;
1290                         if (!suser()) return -EPERM;
1291                         if ((err = verify_area(VERIFY_READ, (void *)arg, sizeof(struct nr_parms_struct))) != 0)
1292                                 return err;
1293                         memcpy_fromfs(&nr_parms, (void *)arg, sizeof(struct nr_parms_struct));
1294                         nr_default = nr_parms;
1295                         return 0;
1296                 }
1297                 
1298                 default:
1299                         return dev_ioctl(cmd, (void *)arg);
1300         }
1301 
1302         /*NOTREACHED*/
1303         return(0);
1304 }
1305 
1306 static int nr_get_info(char *buffer, char **start, off_t offset, int length, int dummy)
     /*  */
1307 {
1308         struct sock *s;
1309         struct device *dev;
1310         const char *devname;
1311         int len = 0;
1312         off_t pos = 0;
1313         off_t begin = 0;
1314   
1315         cli();
1316 
1317         len += sprintf(buffer, "user_addr dest_node src_node  dev    my  your  st vs vr va    t1     t2    n2  rtt wnd Snd-Q Rcv-Q\n");
1318 
1319         for (s = nr_list; s != NULL; s = s->next) {
1320                 if ((dev = s->nr->device) == NULL)
1321                         devname = "???";
1322                 else
1323                         devname = dev->name;
1324         
1325                 len += sprintf(buffer + len, "%-9s ",
1326                         ax2asc(&s->nr->user_addr));
1327                 len += sprintf(buffer + len, "%-9s ",
1328                         ax2asc(&s->nr->dest_addr));
1329                 len += sprintf(buffer + len, "%-9s %-3s  %02X/%02X %02X/%02X %2d %2d %2d %2d %3d/%03d %2d/%02d %2d/%02d %3d %3d %5ld %5ld\n",
1330                         ax2asc(&s->nr->source_addr),
1331                         devname, s->nr->my_index, s->nr->my_id,
1332                         s->nr->your_index, s->nr->your_id,
1333                         s->nr->state,
1334                         s->nr->vs, s->nr->vr, s->nr->va,
1335                         s->nr->t1timer / PR_SLOWHZ,
1336                         s->nr->t1      / PR_SLOWHZ,
1337                         s->nr->t2timer / PR_SLOWHZ,
1338                         s->nr->t2      / PR_SLOWHZ,
1339                         s->nr->n2count, s->nr->n2,
1340                         s->nr->rtt     / PR_SLOWHZ,
1341                         s->window,
1342                         s->wmem_alloc, s->rmem_alloc);
1343                 
1344                 pos = begin + len;
1345 
1346                 if (pos < offset) {
1347                         len   = 0;
1348                         begin = pos;
1349                 }
1350                 
1351                 if (pos > offset + length)
1352                         break;
1353         }
1354 
1355         sti();
1356 
1357         *start = buffer + (offset - begin);
1358         len   -= (offset - begin);
1359 
1360         if (len > length) len = length;
1361 
1362         return(len);
1363 } 
1364 
1365 static struct proto_ops nr_proto_ops = {
1366         AF_NETROM,
1367         
1368         nr_create,
1369         nr_dup,
1370         nr_release,
1371         nr_bind,
1372         nr_connect,
1373         nr_socketpair,
1374         nr_accept,
1375         nr_getname,
1376         nr_read,
1377         nr_write,
1378         nr_select,
1379         nr_ioctl,
1380         nr_listen,
1381         nr_send,
1382         nr_recv,
1383         nr_sendto,
1384         nr_recvfrom,
1385         nr_shutdown,
1386         nr_setsockopt,
1387         nr_getsockopt,
1388         nr_fcntl,
1389 };
1390 
1391 static struct notifier_block nr_dev_notifier = {
1392         nr_device_event,
1393         0
1394 };
1395 
1396 void nr_proto_init(struct net_proto *pro)
     /*  */
1397 {
1398         sock_register(nr_proto_ops.family, &nr_proto_ops);
1399         register_netdevice_notifier(&nr_dev_notifier);
1400         printk("G4KLX NET/ROM for Linux. Version 0.3 ALPHA for AX25 030 Linux 1.3.0\n");
1401 
1402         nr_default.quality    = NR_DEFAULT_QUAL;
1403         nr_default.obs_count  = NR_DEFAULT_OBS;
1404         nr_default.ttl        = NR_DEFAULT_TTL;
1405         nr_default.timeout    = NR_DEFAULT_T1;
1406         nr_default.ack_delay  = NR_DEFAULT_T2;
1407         nr_default.busy_delay = NR_DEFAULT_T4;
1408         nr_default.tries      = NR_DEFAULT_N2;
1409         nr_default.window     = NR_DEFAULT_WINDOW;
1410 
1411         proc_net_register(&(struct proc_dir_entry) {
1412                 PROC_NET_NR, 2, "nr",
1413                 S_IFREG | S_IRUGO, 1, 0, 0,
1414                 nr_get_info
1415         });
1416         proc_net_register(&(struct proc_dir_entry) {
1417                 PROC_NET_NR_NEIGH, 8, "nr_neigh",
1418                 S_IFREG | S_IRUGO, 1, 0, 0,
1419                 nr_neigh_get_info
1420         });
1421         proc_net_register(&(struct proc_dir_entry) {
1422                 PROC_NET_NR_NODES, 8, "nr_nodes",
1423                 S_IFREG | S_IRUGO, 1, 0, 0,
1424                 nr_nodes_get_info
1425         });
1426 }
1427 
1428 #endif
/* */
root/net/netrom/af_netrom.c

DEFINITIONS
