root/net/netrom/af_netrom.c

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

DEFINITIONS

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

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