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

DEFINITIONS
