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_kill_by_device
  3. nr_device_event
  4. nr_insert_socket
  5. nr_find_listener
  6. nr_find_socket
  7. nr_find_peer
  8. nr_destroy_timer
  9. nr_destroy_socket
  10. nr_fcntl
  11. nr_setsockopt
  12. nr_getsockopt
  13. nr_listen
  14. def_callback1
  15. def_callback2
  16. nr_create
  17. nr_make_new
  18. nr_dup
  19. nr_release
  20. nr_bind
  21. nr_connect
  22. nr_socketpair
  23. nr_accept
  24. nr_getname
  25. nr_rx_frame
  26. nr_sendmsg
  27. nr_sendto
  28. nr_send
  29. nr_write
  30. nr_recvmsg
  31. nr_recvfrom
  32. nr_recv
  33. nr_read
  34. nr_shutdown
  35. nr_select
  36. nr_ioctl
  37. nr_get_info
  38. nr_proto_init

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

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