net/netrom/af_netrom.c

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