net/netrom/af_netrom.c

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

DEFINITIONS
