1 /* 2 * This program is free software; you can redistribute it and/or modify 3 * it under the terms of the GNU General Public License as published by 4 * the Free Software Foundation; either version 2 of the License, or 5 * (at your option) any later version. 6 * 7 * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk) 8 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk) 9 * Copyright (C) Darryl Miles G7LED (dlm@g7led.demon.co.uk) 10 * Copyright (C) Steven Whitehouse GW7RRM (stevew@acm.org) 11 * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de) 12 * Copyright (C) Hans-Joachim Hetscher DD8NE (dd8ne@bnv-bamberg.de) 13 * Copyright (C) Hans Alblas PE1AYX (hans@esrac.ele.tue.nl) 14 * Copyright (C) Frederic Rible F1OAT (frible@teaser.fr) 15 */ 16 #include <linux/config.h> 17 #include <linux/module.h> 18 #include <linux/errno.h> 19 #include <linux/types.h> 20 #include <linux/socket.h> 21 #include <linux/in.h> 22 #include <linux/kernel.h> 23 #include <linux/sched.h> 24 #include <linux/timer.h> 25 #include <linux/string.h> 26 #include <linux/smp_lock.h> 27 #include <linux/sockios.h> 28 #include <linux/net.h> 29 #include <net/ax25.h> 30 #include <linux/inet.h> 31 #include <linux/netdevice.h> 32 #include <linux/if_arp.h> 33 #include <linux/skbuff.h> 34 #include <net/sock.h> 35 #include <asm/uaccess.h> 36 #include <asm/system.h> 37 #include <linux/fcntl.h> 38 #include <linux/termios.h> /* For TIOCINQ/OUTQ */ 39 #include <linux/mm.h> 40 #include <linux/interrupt.h> 41 #include <linux/notifier.h> 42 #include <linux/proc_fs.h> 43 #include <linux/stat.h> 44 #include <linux/netfilter.h> 45 #include <linux/sysctl.h> 46 #include <linux/init.h> 47 #include <linux/spinlock.h> 48 #include <net/tcp_states.h> 49 #include <net/ip.h> 50 #include <net/arp.h> 51 52 53 54 HLIST_HEAD(ax25_list); 55 DEFINE_SPINLOCK(ax25_list_lock); 56 57 static struct proto_ops ax25_proto_ops; 58 59 static void ax25_free_sock(struct sock *sk) 60 { 61 ax25_cb_put(ax25_sk(sk)); 62 } 63 64 /* 65 * Socket removal during an interrupt is now safe. 66 */ 67 static void ax25_cb_del(ax25_cb *ax25) 68 { 69 if (!hlist_unhashed(&ax25->ax25_node)) { 70 spin_lock_bh(&ax25_list_lock); 71 hlist_del_init(&ax25->ax25_node); 72 spin_unlock_bh(&ax25_list_lock); 73 ax25_cb_put(ax25); 74 } 75 } 76 77 /* 78 * Kill all bound sockets on a dropped device. 79 */ 80 static void ax25_kill_by_device(struct net_device *dev) 81 { 82 ax25_dev *ax25_dev; 83 ax25_cb *s; 84 struct hlist_node *node; 85 86 if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL) 87 return; 88 89 spin_lock_bh(&ax25_list_lock); 90 ax25_for_each(s, node, &ax25_list) { 91 if (s->ax25_dev == ax25_dev) { 92 s->ax25_dev = NULL; 93 ax25_disconnect(s, ENETUNREACH); 94 } 95 } 96 spin_unlock_bh(&ax25_list_lock); 97 } 98 99 /* 100 * Handle device status changes. 101 */ 102 static int ax25_device_event(struct notifier_block *this, unsigned long event, 103 void *ptr) 104 { 105 struct net_device *dev = (struct net_device *)ptr; 106 107 /* Reject non AX.25 devices */ 108 if (dev->type != ARPHRD_AX25) 109 return NOTIFY_DONE; 110 111 switch (event) { 112 case NETDEV_UP: 113 ax25_dev_device_up(dev); 114 break; 115 case NETDEV_DOWN: 116 ax25_kill_by_device(dev); 117 ax25_rt_device_down(dev); 118 ax25_dev_device_down(dev); 119 break; 120 default: 121 break; 122 } 123 124 return NOTIFY_DONE; 125 } 126 127 /* 128 * Add a socket to the bound sockets list. 129 */ 130 void ax25_cb_add(ax25_cb *ax25) 131 { 132 spin_lock_bh(&ax25_list_lock); 133 ax25_cb_hold(ax25); 134 hlist_add_head(&ax25->ax25_node, &ax25_list); 135 spin_unlock_bh(&ax25_list_lock); 136 } 137 138 /* 139 * Find a socket that wants to accept the SABM we have just 140 * received. 141 */ 142 struct sock *ax25_find_listener(ax25_address *addr, int digi, 143 struct net_device *dev, int type) 144 { 145 ax25_cb *s; 146 struct hlist_node *node; 147 148 spin_lock_bh(&ax25_list_lock); 149 ax25_for_each(s, node, &ax25_list) { 150 if ((s->iamdigi && !digi) || (!s->iamdigi && digi)) 151 continue; 152 if (s->sk && !ax25cmp(&s->source_addr, addr) && 153 s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) { 154 /* If device is null we match any device */ 155 if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) { 156 sock_hold(s->sk); 157 spin_unlock_bh(&ax25_list_lock); 158 return s->sk; 159 } 160 } 161 } 162 spin_unlock_bh(&ax25_list_lock); 163 164 return NULL; 165 } 166 167 /* 168 * Find an AX.25 socket given both ends. 169 */ 170 struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr, 171 int type) 172 { 173 struct sock *sk = NULL; 174 ax25_cb *s; 175 struct hlist_node *node; 176 177 spin_lock_bh(&ax25_list_lock); 178 ax25_for_each(s, node, &ax25_list) { 179 if (s->sk && !ax25cmp(&s->source_addr, my_addr) && 180 !ax25cmp(&s->dest_addr, dest_addr) && 181 s->sk->sk_type == type) { 182 sk = s->sk; 183 sock_hold(sk); 184 break; 185 } 186 } 187 188 spin_unlock_bh(&ax25_list_lock); 189 190 return sk; 191 } 192 193 /* 194 * Find an AX.25 control block given both ends. It will only pick up 195 * floating AX.25 control blocks or non Raw socket bound control blocks. 196 */ 197 ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr, 198 ax25_digi *digi, struct net_device *dev) 199 { 200 ax25_cb *s; 201 struct hlist_node *node; 202 203 spin_lock_bh(&ax25_list_lock); 204 ax25_for_each(s, node, &ax25_list) { 205 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET) 206 continue; 207 if (s->ax25_dev == NULL) 208 continue; 209 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) { 210 if (digi != NULL && digi->ndigi != 0) { 211 if (s->digipeat == NULL) 212 continue; 213 if (ax25digicmp(s->digipeat, digi) != 0) 214 continue; 215 } else { 216 if (s->digipeat != NULL && s->digipeat->ndigi != 0) 217 continue; 218 } 219 ax25_cb_hold(s); 220 spin_unlock_bh(&ax25_list_lock); 221 222 return s; 223 } 224 } 225 spin_unlock_bh(&ax25_list_lock); 226 227 return NULL; 228 } 229 230 void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto) 231 { 232 ax25_cb *s; 233 struct sk_buff *copy; 234 struct hlist_node *node; 235 236 spin_lock_bh(&ax25_list_lock); 237 ax25_for_each(s, node, &ax25_list) { 238 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 && 239 s->sk->sk_type == SOCK_RAW && 240 s->sk->sk_protocol == proto && 241 s->ax25_dev->dev == skb->dev && 242 atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) { 243 if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL) 244 continue; 245 if (sock_queue_rcv_skb(s->sk, copy) != 0) 246 kfree_skb(copy); 247 } 248 } 249 spin_unlock_bh(&ax25_list_lock); 250 } 251 252 /* 253 * Deferred destroy. 254 */ 255 void ax25_destroy_socket(ax25_cb *); 256 257 /* 258 * Handler for deferred kills. 259 */ 260 static void ax25_destroy_timer(unsigned long data) 261 { 262 ax25_cb *ax25=(ax25_cb *)data; 263 struct sock *sk; 264 265 sk=ax25->sk; 266 267 bh_lock_sock(sk); 268 sock_hold(sk); 269 ax25_destroy_socket(ax25); 270 bh_unlock_sock(sk); 271 sock_put(sk); 272 } 273 274 /* 275 * This is called from user mode and the timers. Thus it protects itself 276 * against interrupt users but doesn't worry about being called during 277 * work. Once it is removed from the queue no interrupt or bottom half 278 * will touch it and we are (fairly 8-) ) safe. 279 */ 280 void ax25_destroy_socket(ax25_cb *ax25) 281 { 282 struct sk_buff *skb; 283 284 ax25_cb_del(ax25); 285 286 ax25_stop_heartbeat(ax25); 287 ax25_stop_t1timer(ax25); 288 ax25_stop_t2timer(ax25); 289 ax25_stop_t3timer(ax25); 290 ax25_stop_idletimer(ax25); 291 292 ax25_clear_queues(ax25); /* Flush the queues */ 293 294 if (ax25->sk != NULL) { 295 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) { 296 if (skb->sk != ax25->sk) { 297 /* A pending connection */ 298 ax25_cb *sax25 = ax25_sk(skb->sk); 299 300 /* Queue the unaccepted socket for death */ 301 sock_orphan(skb->sk); 302 303 ax25_start_heartbeat(sax25); 304 sax25->state = AX25_STATE_0; 305 } 306 307 kfree_skb(skb); 308 } 309 skb_queue_purge(&ax25->sk->sk_write_queue); 310 } 311 312 if (ax25->sk != NULL) { 313 if (atomic_read(&ax25->sk->sk_wmem_alloc) || 314 atomic_read(&ax25->sk->sk_rmem_alloc)) { 315 /* Defer: outstanding buffers */ 316 init_timer(&ax25->dtimer); 317 ax25->dtimer.expires = jiffies + 2 * HZ; 318 ax25->dtimer.function = ax25_destroy_timer; 319 ax25->dtimer.data = (unsigned long)ax25; 320 add_timer(&ax25->dtimer); 321 } else { 322 struct sock *sk=ax25->sk; 323 ax25->sk=NULL; 324 sock_put(sk); 325 } 326 } else { 327 ax25_cb_put(ax25); 328 } 329 } 330 331 /* 332 * dl1bke 960311: set parameters for existing AX.25 connections, 333 * includes a KILL command to abort any connection. 334 * VERY useful for debugging ;-) 335 */ 336 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg) 337 { 338 struct ax25_ctl_struct ax25_ctl; 339 ax25_digi digi; 340 ax25_dev *ax25_dev; 341 ax25_cb *ax25; 342 unsigned int k; 343 344 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl))) 345 return -EFAULT; 346 347 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL) 348 return -ENODEV; 349 350 if (ax25_ctl.digi_count > AX25_MAX_DIGIS) 351 return -EINVAL; 352 353 digi.ndigi = ax25_ctl.digi_count; 354 for (k = 0; k < digi.ndigi; k++) 355 digi.calls[k] = ax25_ctl.digi_addr[k]; 356 357 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL) 358 return -ENOTCONN; 359 360 switch (ax25_ctl.cmd) { 361 case AX25_KILL: 362 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND); 363 #ifdef CONFIG_AX25_DAMA_SLAVE 364 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE) 365 ax25_dama_off(ax25); 366 #endif 367 ax25_disconnect(ax25, ENETRESET); 368 break; 369 370 case AX25_WINDOW: 371 if (ax25->modulus == AX25_MODULUS) { 372 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7) 373 return -EINVAL; 374 } else { 375 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63) 376 return -EINVAL; 377 } 378 ax25->window = ax25_ctl.arg; 379 break; 380 381 case AX25_T1: 382 if (ax25_ctl.arg < 1) 383 return -EINVAL; 384 ax25->rtt = (ax25_ctl.arg * HZ) / 2; 385 ax25->t1 = ax25_ctl.arg * HZ; 386 break; 387 388 case AX25_T2: 389 if (ax25_ctl.arg < 1) 390 return -EINVAL; 391 ax25->t2 = ax25_ctl.arg * HZ; 392 break; 393 394 case AX25_N2: 395 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31) 396 return -EINVAL; 397 ax25->n2count = 0; 398 ax25->n2 = ax25_ctl.arg; 399 break; 400 401 case AX25_T3: 402 if (ax25_ctl.arg < 0) 403 return -EINVAL; 404 ax25->t3 = ax25_ctl.arg * HZ; 405 break; 406 407 case AX25_IDLE: 408 if (ax25_ctl.arg < 0) 409 return -EINVAL; 410 ax25->idle = ax25_ctl.arg * 60 * HZ; 411 break; 412 413 case AX25_PACLEN: 414 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535) 415 return -EINVAL; 416 ax25->paclen = ax25_ctl.arg; 417 break; 418 419 default: 420 return -EINVAL; 421 } 422 423 return 0; 424 } 425 426 /* 427 * Fill in a created AX.25 created control block with the default 428 * values for a particular device. 429 */ 430 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev) 431 { 432 ax25->ax25_dev = ax25_dev; 433 434 if (ax25->ax25_dev != NULL) { 435 ax25->rtt = ax25_dev->values[AX25_VALUES_T1] / 2; 436 ax25->t1 = ax25_dev->values[AX25_VALUES_T1]; 437 ax25->t2 = ax25_dev->values[AX25_VALUES_T2]; 438 ax25->t3 = ax25_dev->values[AX25_VALUES_T3]; 439 ax25->n2 = ax25_dev->values[AX25_VALUES_N2]; 440 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN]; 441 ax25->idle = ax25_dev->values[AX25_VALUES_IDLE]; 442 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF]; 443 444 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) { 445 ax25->modulus = AX25_EMODULUS; 446 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW]; 447 } else { 448 ax25->modulus = AX25_MODULUS; 449 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW]; 450 } 451 } else { 452 ax25->rtt = AX25_DEF_T1 / 2; 453 ax25->t1 = AX25_DEF_T1; 454 ax25->t2 = AX25_DEF_T2; 455 ax25->t3 = AX25_DEF_T3; 456 ax25->n2 = AX25_DEF_N2; 457 ax25->paclen = AX25_DEF_PACLEN; 458 ax25->idle = AX25_DEF_IDLE; 459 ax25->backoff = AX25_DEF_BACKOFF; 460 461 if (AX25_DEF_AXDEFMODE) { 462 ax25->modulus = AX25_EMODULUS; 463 ax25->window = AX25_DEF_EWINDOW; 464 } else { 465 ax25->modulus = AX25_MODULUS; 466 ax25->window = AX25_DEF_WINDOW; 467 } 468 } 469 } 470 471 /* 472 * Create an empty AX.25 control block. 473 */ 474 ax25_cb *ax25_create_cb(void) 475 { 476 ax25_cb *ax25; 477 478 if ((ax25 = kmalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL) 479 return NULL; 480 481 memset(ax25, 0x00, sizeof(*ax25)); 482 atomic_set(&ax25->refcount, 1); 483 484 skb_queue_head_init(&ax25->write_queue); 485 skb_queue_head_init(&ax25->frag_queue); 486 skb_queue_head_init(&ax25->ack_queue); 487 skb_queue_head_init(&ax25->reseq_queue); 488 489 init_timer(&ax25->timer); 490 init_timer(&ax25->t1timer); 491 init_timer(&ax25->t2timer); 492 init_timer(&ax25->t3timer); 493 init_timer(&ax25->idletimer); 494 495 ax25_fillin_cb(ax25, NULL); 496 497 ax25->state = AX25_STATE_0; 498 499 return ax25; 500 } 501 502 /* 503 * Handling for system calls applied via the various interfaces to an 504 * AX25 socket object 505 */ 506 507 static int ax25_setsockopt(struct socket *sock, int level, int optname, 508 char __user *optval, int optlen) 509 { 510 struct sock *sk = sock->sk; 511 ax25_cb *ax25; 512 struct net_device *dev; 513 char devname[IFNAMSIZ]; 514 int opt, res = 0; 515 516 if (level != SOL_AX25) 517 return -ENOPROTOOPT; 518 519 if (optlen < sizeof(int)) 520 return -EINVAL; 521 522 if (get_user(opt, (int __user *)optval)) 523 return -EFAULT; 524 525 lock_sock(sk); 526 ax25 = ax25_sk(sk); 527 528 switch (optname) { 529 case AX25_WINDOW: 530 if (ax25->modulus == AX25_MODULUS) { 531 if (opt < 1 || opt > 7) { 532 res = -EINVAL; 533 break; 534 } 535 } else { 536 if (opt < 1 || opt > 63) { 537 res = -EINVAL; 538 break; 539 } 540 } 541 ax25->window = opt; 542 break; 543 544 case AX25_T1: 545 if (opt < 1) { 546 res = -EINVAL; 547 break; 548 } 549 ax25->rtt = (opt * HZ) / 2; 550 ax25->t1 = opt * HZ; 551 break; 552 553 case AX25_T2: 554 if (opt < 1) { 555 res = -EINVAL; 556 break; 557 } 558 ax25->t2 = opt * HZ; 559 break; 560 561 case AX25_N2: 562 if (opt < 1 || opt > 31) { 563 res = -EINVAL; 564 break; 565 } 566 ax25->n2 = opt; 567 break; 568 569 case AX25_T3: 570 if (opt < 1) { 571 res = -EINVAL; 572 break; 573 } 574 ax25->t3 = opt * HZ; 575 break; 576 577 case AX25_IDLE: 578 if (opt < 0) { 579 res = -EINVAL; 580 break; 581 } 582 ax25->idle = opt * 60 * HZ; 583 break; 584 585 case AX25_BACKOFF: 586 if (opt < 0 || opt > 2) { 587 res = -EINVAL; 588 break; 589 } 590 ax25->backoff = opt; 591 break; 592 593 case AX25_EXTSEQ: 594 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS; 595 break; 596 597 case AX25_PIDINCL: 598 ax25->pidincl = opt ? 1 : 0; 599 break; 600 601 case AX25_IAMDIGI: 602 ax25->iamdigi = opt ? 1 : 0; 603 break; 604 605 case AX25_PACLEN: 606 if (opt < 16 || opt > 65535) { 607 res = -EINVAL; 608 break; 609 } 610 ax25->paclen = opt; 611 break; 612 613 case SO_BINDTODEVICE: 614 if (optlen > IFNAMSIZ) 615 optlen=IFNAMSIZ; 616 if (copy_from_user(devname, optval, optlen)) { 617 res = -EFAULT; 618 break; 619 } 620 621 dev = dev_get_by_name(devname); 622 if (dev == NULL) { 623 res = -ENODEV; 624 break; 625 } 626 627 if (sk->sk_type == SOCK_SEQPACKET && 628 (sock->state != SS_UNCONNECTED || 629 sk->sk_state == TCP_LISTEN)) { 630 res = -EADDRNOTAVAIL; 631 dev_put(dev); 632 break; 633 } 634 635 ax25->ax25_dev = ax25_dev_ax25dev(dev); 636 ax25_fillin_cb(ax25, ax25->ax25_dev); 637 break; 638 639 default: 640 res = -ENOPROTOOPT; 641 } 642 release_sock(sk); 643 644 return res; 645 } 646 647 static int ax25_getsockopt(struct socket *sock, int level, int optname, 648 char __user *optval, int __user *optlen) 649 { 650 struct sock *sk = sock->sk; 651 ax25_cb *ax25; 652 struct ax25_dev *ax25_dev; 653 char devname[IFNAMSIZ]; 654 void *valptr; 655 int val = 0; 656 int maxlen, length; 657 658 if (level != SOL_AX25) 659 return -ENOPROTOOPT; 660 661 if (get_user(maxlen, optlen)) 662 return -EFAULT; 663 664 if (maxlen < 1) 665 return -EFAULT; 666 667 valptr = (void *) &val; 668 length = min_t(unsigned int, maxlen, sizeof(int)); 669 670 lock_sock(sk); 671 ax25 = ax25_sk(sk); 672 673 switch (optname) { 674 case AX25_WINDOW: 675 val = ax25->window; 676 break; 677 678 case AX25_T1: 679 val = ax25->t1 / HZ; 680 break; 681 682 case AX25_T2: 683 val = ax25->t2 / HZ; 684 break; 685 686 case AX25_N2: 687 val = ax25->n2; 688 break; 689 690 case AX25_T3: 691 val = ax25->t3 / HZ; 692 break; 693 694 case AX25_IDLE: 695 val = ax25->idle / (60 * HZ); 696 break; 697 698 case AX25_BACKOFF: 699 val = ax25->backoff; 700 break; 701 702 case AX25_EXTSEQ: 703 val = (ax25->modulus == AX25_EMODULUS); 704 break; 705 706 case AX25_PIDINCL: 707 val = ax25->pidincl; 708 break; 709 710 case AX25_IAMDIGI: 711 val = ax25->iamdigi; 712 break; 713 714 case AX25_PACLEN: 715 val = ax25->paclen; 716 break; 717 718 case SO_BINDTODEVICE: 719 ax25_dev = ax25->ax25_dev; 720 721 if (ax25_dev != NULL && ax25_dev->dev != NULL) { 722 strlcpy(devname, ax25_dev->dev->name, sizeof(devname)); 723 length = strlen(devname) + 1; 724 } else { 725 *devname = '\0'; 726 length = 1; 727 } 728 729 valptr = (void *) devname; 730 break; 731 732 default: 733 release_sock(sk); 734 return -ENOPROTOOPT; 735 } 736 release_sock(sk); 737 738 if (put_user(length, optlen)) 739 return -EFAULT; 740 741 return copy_to_user(optval, valptr, length) ? -EFAULT : 0; 742 } 743 744 static int ax25_listen(struct socket *sock, int backlog) 745 { 746 struct sock *sk = sock->sk; 747 int res = 0; 748 749 lock_sock(sk); 750 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) { 751 sk->sk_max_ack_backlog = backlog; 752 sk->sk_state = TCP_LISTEN; 753 goto out; 754 } 755 res = -EOPNOTSUPP; 756 757 out: 758 release_sock(sk); 759 760 return res; 761 } 762 763 /* 764 * XXX: when creating ax25_sock we should update the .obj_size setting 765 * below. 766 */ 767 static struct proto ax25_proto = { 768 .name = "AX25", 769 .owner = THIS_MODULE, 770 .obj_size = sizeof(struct sock), 771 }; 772 773 static int ax25_create(struct socket *sock, int protocol) 774 { 775 struct sock *sk; 776 ax25_cb *ax25; 777 778 switch (sock->type) { 779 case SOCK_DGRAM: 780 if (protocol == 0 || protocol == PF_AX25) 781 protocol = AX25_P_TEXT; 782 break; 783 784 case SOCK_SEQPACKET: 785 switch (protocol) { 786 case 0: 787 case PF_AX25: /* For CLX */ 788 protocol = AX25_P_TEXT; 789 break; 790 case AX25_P_SEGMENT: 791 #ifdef CONFIG_INET 792 case AX25_P_ARP: 793 case AX25_P_IP: 794 #endif 795 #ifdef CONFIG_NETROM 796 case AX25_P_NETROM: 797 #endif 798 #ifdef CONFIG_ROSE 799 case AX25_P_ROSE: 800 #endif 801 return -ESOCKTNOSUPPORT; 802 #ifdef CONFIG_NETROM_MODULE 803 case AX25_P_NETROM: 804 if (ax25_protocol_is_registered(AX25_P_NETROM)) 805 return -ESOCKTNOSUPPORT; 806 #endif 807 #ifdef CONFIG_ROSE_MODULE 808 case AX25_P_ROSE: 809 if (ax25_protocol_is_registered(AX25_P_ROSE)) 810 return -ESOCKTNOSUPPORT; 811 #endif 812 default: 813 break; 814 } 815 break; 816 817 case SOCK_RAW: 818 break; 819 default: 820 return -ESOCKTNOSUPPORT; 821 } 822 823 if ((sk = sk_alloc(PF_AX25, GFP_ATOMIC, &ax25_proto, 1)) == NULL) 824 return -ENOMEM; 825 826 ax25 = sk->sk_protinfo = ax25_create_cb(); 827 if (!ax25) { 828 sk_free(sk); 829 return -ENOMEM; 830 } 831 832 sock_init_data(sock, sk); 833 834 sk->sk_destruct = ax25_free_sock; 835 sock->ops = &ax25_proto_ops; 836 sk->sk_protocol = protocol; 837 838 ax25->sk = sk; 839 840 return 0; 841 } 842 843 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev) 844 { 845 struct sock *sk; 846 ax25_cb *ax25, *oax25; 847 848 if ((sk = sk_alloc(PF_AX25, GFP_ATOMIC, osk->sk_prot, 1)) == NULL) 849 return NULL; 850 851 if ((ax25 = ax25_create_cb()) == NULL) { 852 sk_free(sk); 853 return NULL; 854 } 855 856 switch (osk->sk_type) { 857 case SOCK_DGRAM: 858 break; 859 case SOCK_SEQPACKET: 860 break; 861 default: 862 sk_free(sk); 863 ax25_cb_put(ax25); 864 return NULL; 865 } 866 867 sock_init_data(NULL, sk); 868 869 sk->sk_destruct = ax25_free_sock; 870 sk->sk_type = osk->sk_type; 871 sk->sk_socket = osk->sk_socket; 872 sk->sk_priority = osk->sk_priority; 873 sk->sk_protocol = osk->sk_protocol; 874 sk->sk_rcvbuf = osk->sk_rcvbuf; 875 sk->sk_sndbuf = osk->sk_sndbuf; 876 sk->sk_state = TCP_ESTABLISHED; 877 sk->sk_sleep = osk->sk_sleep; 878 sock_copy_flags(sk, osk); 879 880 oax25 = ax25_sk(osk); 881 882 ax25->modulus = oax25->modulus; 883 ax25->backoff = oax25->backoff; 884 ax25->pidincl = oax25->pidincl; 885 ax25->iamdigi = oax25->iamdigi; 886 ax25->rtt = oax25->rtt; 887 ax25->t1 = oax25->t1; 888 ax25->t2 = oax25->t2; 889 ax25->t3 = oax25->t3; 890 ax25->n2 = oax25->n2; 891 ax25->idle = oax25->idle; 892 ax25->paclen = oax25->paclen; 893 ax25->window = oax25->window; 894 895 ax25->ax25_dev = ax25_dev; 896 ax25->source_addr = oax25->source_addr; 897 898 if (oax25->digipeat != NULL) { 899 if ((ax25->digipeat = kmalloc(sizeof(ax25_digi), GFP_ATOMIC)) == NULL) { 900 sk_free(sk); 901 ax25_cb_put(ax25); 902 return NULL; 903 } 904 905 memcpy(ax25->digipeat, oax25->digipeat, sizeof(ax25_digi)); 906 } 907 908 sk->sk_protinfo = ax25; 909 ax25->sk = sk; 910 911 return sk; 912 } 913 914 static int ax25_release(struct socket *sock) 915 { 916 struct sock *sk = sock->sk; 917 ax25_cb *ax25; 918 919 if (sk == NULL) 920 return 0; 921 922 sock_hold(sk); 923 sock_orphan(sk); 924 lock_sock(sk); 925 ax25 = ax25_sk(sk); 926 927 if (sk->sk_type == SOCK_SEQPACKET) { 928 switch (ax25->state) { 929 case AX25_STATE_0: 930 release_sock(sk); 931 ax25_disconnect(ax25, 0); 932 lock_sock(sk); 933 ax25_destroy_socket(ax25); 934 break; 935 936 case AX25_STATE_1: 937 case AX25_STATE_2: 938 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND); 939 release_sock(sk); 940 ax25_disconnect(ax25, 0); 941 lock_sock(sk); 942 ax25_destroy_socket(ax25); 943 break; 944 945 case AX25_STATE_3: 946 case AX25_STATE_4: 947 ax25_clear_queues(ax25); 948 ax25->n2count = 0; 949 950 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) { 951 case AX25_PROTO_STD_SIMPLEX: 952 case AX25_PROTO_STD_DUPLEX: 953 ax25_send_control(ax25, 954 AX25_DISC, 955 AX25_POLLON, 956 AX25_COMMAND); 957 ax25_stop_t2timer(ax25); 958 ax25_stop_t3timer(ax25); 959 ax25_stop_idletimer(ax25); 960 break; 961 #ifdef CONFIG_AX25_DAMA_SLAVE 962 case AX25_PROTO_DAMA_SLAVE: 963 ax25_stop_t3timer(ax25); 964 ax25_stop_idletimer(ax25); 965 break; 966 #endif 967 } 968 ax25_calculate_t1(ax25); 969 ax25_start_t1timer(ax25); 970 ax25->state = AX25_STATE_2; 971 sk->sk_state = TCP_CLOSE; 972 sk->sk_shutdown |= SEND_SHUTDOWN; 973 sk->sk_state_change(sk); 974 sock_set_flag(sk, SOCK_DESTROY); 975 break; 976 977 default: 978 break; 979 } 980 } else { 981 sk->sk_state = TCP_CLOSE; 982 sk->sk_shutdown |= SEND_SHUTDOWN; 983 sk->sk_state_change(sk); 984 ax25_destroy_socket(ax25); 985 } 986 987 sock->sk = NULL; 988 release_sock(sk); 989 sock_put(sk); 990 991 return 0; 992 } 993 994 /* 995 * We support a funny extension here so you can (as root) give any callsign 996 * digipeated via a local address as source. This hack is obsolete now 997 * that we've implemented support for SO_BINDTODEVICE. It is however small 998 * and trivially backward compatible. 999 */ 1000 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) 1001 { 1002 struct sock *sk = sock->sk; 1003 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr; 1004 ax25_dev *ax25_dev = NULL; 1005 ax25_uid_assoc *user; 1006 ax25_address call; 1007 ax25_cb *ax25; 1008 int err = 0; 1009 1010 if (addr_len != sizeof(struct sockaddr_ax25) && 1011 addr_len != sizeof(struct full_sockaddr_ax25)) { 1012 /* support for old structure may go away some time */ 1013 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) || 1014 (addr_len > sizeof(struct full_sockaddr_ax25))) { 1015 return -EINVAL; 1016 } 1017 1018 printk(KERN_WARNING "ax25_bind(): %s uses old (6 digipeater) socket structure.\n", 1019 current->comm); 1020 } 1021 1022 if (addr->fsa_ax25.sax25_family != AF_AX25) 1023 return -EINVAL; 1024 1025 user = ax25_findbyuid(current->euid); 1026 if (user) { 1027 call = user->call; 1028 ax25_uid_put(user); 1029 } else { 1030 if (ax25_uid_policy && !capable(CAP_NET_ADMIN)) 1031 return -EACCES; 1032 1033 call = addr->fsa_ax25.sax25_call; 1034 } 1035 1036 lock_sock(sk); 1037 1038 ax25 = ax25_sk(sk); 1039 if (!sock_flag(sk, SOCK_ZAPPED)) { 1040 err = -EINVAL; 1041 goto out; 1042 } 1043 1044 ax25->source_addr = call; 1045 1046 /* 1047 * User already set interface with SO_BINDTODEVICE 1048 */ 1049 if (ax25->ax25_dev != NULL) 1050 goto done; 1051 1052 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) { 1053 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 && 1054 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) { 1055 err = -EADDRNOTAVAIL; 1056 goto out; 1057 } 1058 } else { 1059 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) { 1060 err = -EADDRNOTAVAIL; 1061 goto out; 1062 } 1063 } 1064 1065 if (ax25_dev != NULL) 1066 ax25_fillin_cb(ax25, ax25_dev); 1067 1068 done: 1069 ax25_cb_add(ax25); 1070 sock_reset_flag(sk, SOCK_ZAPPED); 1071 1072 out: 1073 release_sock(sk); 1074 1075 return 0; 1076 } 1077 1078 /* 1079 * FIXME: nonblock behaviour looks like it may have a bug. 1080 */ 1081 static int ax25_connect(struct socket *sock, struct sockaddr *uaddr, 1082 int addr_len, int flags) 1083 { 1084 struct sock *sk = sock->sk; 1085 ax25_cb *ax25 = ax25_sk(sk), *ax25t; 1086 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr; 1087 ax25_digi *digi = NULL; 1088 int ct = 0, err = 0; 1089 1090 /* 1091 * some sanity checks. code further down depends on this 1092 */ 1093 1094 if (addr_len == sizeof(struct sockaddr_ax25)) { 1095 /* support for this will go away in early 2.5.x */ 1096 printk(KERN_WARNING "ax25_connect(): %s uses obsolete socket structure\n", 1097 current->comm); 1098 } 1099 else if (addr_len != sizeof(struct full_sockaddr_ax25)) { 1100 /* support for old structure may go away some time */ 1101 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) || 1102 (addr_len > sizeof(struct full_sockaddr_ax25))) { 1103 return -EINVAL; 1104 } 1105 1106 printk(KERN_WARNING "ax25_connect(): %s uses old (6 digipeater) socket structure.\n", 1107 current->comm); 1108 } 1109 1110 if (fsa->fsa_ax25.sax25_family != AF_AX25) 1111 return -EINVAL; 1112 1113 lock_sock(sk); 1114 1115 /* deal with restarts */ 1116 if (sock->state == SS_CONNECTING) { 1117 switch (sk->sk_state) { 1118 case TCP_SYN_SENT: /* still trying */ 1119 err = -EINPROGRESS; 1120 goto out; 1121 1122 case TCP_ESTABLISHED: /* connection established */ 1123 sock->state = SS_CONNECTED; 1124 goto out; 1125 1126 case TCP_CLOSE: /* connection refused */ 1127 sock->state = SS_UNCONNECTED; 1128 err = -ECONNREFUSED; 1129 goto out; 1130 } 1131 } 1132 1133 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) { 1134 err = -EISCONN; /* No reconnect on a seqpacket socket */ 1135 goto out; 1136 } 1137 1138 sk->sk_state = TCP_CLOSE; 1139 sock->state = SS_UNCONNECTED; 1140 1141 kfree(ax25->digipeat); 1142 ax25->digipeat = NULL; 1143 1144 /* 1145 * Handle digi-peaters to be used. 1146 */ 1147 if (addr_len > sizeof(struct sockaddr_ax25) && 1148 fsa->fsa_ax25.sax25_ndigis != 0) { 1149 /* Valid number of digipeaters ? */ 1150 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) { 1151 err = -EINVAL; 1152 goto out; 1153 } 1154 1155 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) { 1156 err = -ENOBUFS; 1157 goto out; 1158 } 1159 1160 digi->ndigi = fsa->fsa_ax25.sax25_ndigis; 1161 digi->lastrepeat = -1; 1162 1163 while (ct < fsa->fsa_ax25.sax25_ndigis) { 1164 if ((fsa->fsa_digipeater[ct].ax25_call[6] & 1165 AX25_HBIT) && ax25->iamdigi) { 1166 digi->repeated[ct] = 1; 1167 digi->lastrepeat = ct; 1168 } else { 1169 digi->repeated[ct] = 0; 1170 } 1171 digi->calls[ct] = fsa->fsa_digipeater[ct]; 1172 ct++; 1173 } 1174 } 1175 1176 /* 1177 * Must bind first - autobinding in this may or may not work. If 1178 * the socket is already bound, check to see if the device has 1179 * been filled in, error if it hasn't. 1180 */ 1181 if (sock_flag(sk, SOCK_ZAPPED)) { 1182 /* check if we can remove this feature. It is broken. */ 1183 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n", 1184 current->comm); 1185 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) { 1186 kfree(digi); 1187 goto out; 1188 } 1189 1190 ax25_fillin_cb(ax25, ax25->ax25_dev); 1191 ax25_cb_add(ax25); 1192 } else { 1193 if (ax25->ax25_dev == NULL) { 1194 kfree(digi); 1195 err = -EHOSTUNREACH; 1196 goto out; 1197 } 1198 } 1199 1200 if (sk->sk_type == SOCK_SEQPACKET && 1201 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi, 1202 ax25->ax25_dev->dev))) { 1203 kfree(digi); 1204 err = -EADDRINUSE; /* Already such a connection */ 1205 ax25_cb_put(ax25t); 1206 goto out; 1207 } 1208 1209 ax25->dest_addr = fsa->fsa_ax25.sax25_call; 1210 ax25->digipeat = digi; 1211 1212 /* First the easy one */ 1213 if (sk->sk_type != SOCK_SEQPACKET) { 1214 sock->state = SS_CONNECTED; 1215 sk->sk_state = TCP_ESTABLISHED; 1216 goto out; 1217 } 1218 1219 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */ 1220 sock->state = SS_CONNECTING; 1221 sk->sk_state = TCP_SYN_SENT; 1222 1223 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) { 1224 case AX25_PROTO_STD_SIMPLEX: 1225 case AX25_PROTO_STD_DUPLEX: 1226 ax25_std_establish_data_link(ax25); 1227 break; 1228 1229 #ifdef CONFIG_AX25_DAMA_SLAVE 1230 case AX25_PROTO_DAMA_SLAVE: 1231 ax25->modulus = AX25_MODULUS; 1232 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW]; 1233 if (ax25->ax25_dev->dama.slave) 1234 ax25_ds_establish_data_link(ax25); 1235 else 1236 ax25_std_establish_data_link(ax25); 1237 break; 1238 #endif 1239 } 1240 1241 ax25->state = AX25_STATE_1; 1242 1243 ax25_start_heartbeat(ax25); 1244 1245 /* Now the loop */ 1246 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) { 1247 err = -EINPROGRESS; 1248 goto out; 1249 } 1250 1251 if (sk->sk_state == TCP_SYN_SENT) { 1252 struct task_struct *tsk = current; 1253 DECLARE_WAITQUEUE(wait, tsk); 1254 1255 add_wait_queue(sk->sk_sleep, &wait); 1256 for (;;) { 1257 if (sk->sk_state != TCP_SYN_SENT) 1258 break; 1259 set_current_state(TASK_INTERRUPTIBLE); 1260 release_sock(sk); 1261 if (!signal_pending(tsk)) { 1262 schedule(); 1263 lock_sock(sk); 1264 continue; 1265 } 1266 current->state = TASK_RUNNING; 1267 remove_wait_queue(sk->sk_sleep, &wait); 1268 return -ERESTARTSYS; 1269 } 1270 current->state = TASK_RUNNING; 1271 remove_wait_queue(sk->sk_sleep, &wait); 1272 } 1273 1274 if (sk->sk_state != TCP_ESTABLISHED) { 1275 /* Not in ABM, not in WAIT_UA -> failed */ 1276 sock->state = SS_UNCONNECTED; 1277 err = sock_error(sk); /* Always set at this point */ 1278 goto out; 1279 } 1280 1281 sock->state = SS_CONNECTED; 1282 1283 err=0; 1284 out: 1285 release_sock(sk); 1286 1287 return err; 1288 } 1289 1290 1291 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags) 1292 { 1293 struct task_struct *tsk = current; 1294 DECLARE_WAITQUEUE(wait, tsk); 1295 struct sk_buff *skb; 1296 struct sock *newsk; 1297 struct sock *sk; 1298 int err = 0; 1299 1300 if (sock->state != SS_UNCONNECTED) 1301 return -EINVAL; 1302 1303 if ((sk = sock->sk) == NULL) 1304 return -EINVAL; 1305 1306 lock_sock(sk); 1307 if (sk->sk_type != SOCK_SEQPACKET) { 1308 err = -EOPNOTSUPP; 1309 goto out; 1310 } 1311 1312 if (sk->sk_state != TCP_LISTEN) { 1313 err = -EINVAL; 1314 goto out; 1315 } 1316 1317 /* 1318 * The read queue this time is holding sockets ready to use 1319 * hooked into the SABM we saved 1320 */ 1321 add_wait_queue(sk->sk_sleep, &wait); 1322 for (;;) { 1323 skb = skb_dequeue(&sk->sk_receive_queue); 1324 if (skb) 1325 break; 1326 1327 release_sock(sk); 1328 current->state = TASK_INTERRUPTIBLE; 1329 if (flags & O_NONBLOCK) { 1330 current->state = TASK_RUNNING; 1331 remove_wait_queue(sk->sk_sleep, &wait); 1332 return -EWOULDBLOCK; 1333 } 1334 if (!signal_pending(tsk)) { 1335 schedule(); 1336 lock_sock(sk); 1337 continue; 1338 } 1339 current->state = TASK_RUNNING; 1340 remove_wait_queue(sk->sk_sleep, &wait); 1341 return -ERESTARTSYS; 1342 } 1343 current->state = TASK_RUNNING; 1344 remove_wait_queue(sk->sk_sleep, &wait); 1345 1346 newsk = skb->sk; 1347 newsk->sk_socket = newsock; 1348 newsk->sk_sleep = &newsock->wait; 1349 1350 /* Now attach up the new socket */ 1351 kfree_skb(skb); 1352 sk->sk_ack_backlog--; 1353 newsock->sk = newsk; 1354 newsock->state = SS_CONNECTED; 1355 1356 out: 1357 release_sock(sk); 1358 1359 return err; 1360 } 1361 1362 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr, 1363 int *uaddr_len, int peer) 1364 { 1365 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr; 1366 struct sock *sk = sock->sk; 1367 unsigned char ndigi, i; 1368 ax25_cb *ax25; 1369 int err = 0; 1370 1371 lock_sock(sk); 1372 ax25 = ax25_sk(sk); 1373 1374 if (peer != 0) { 1375 if (sk->sk_state != TCP_ESTABLISHED) { 1376 err = -ENOTCONN; 1377 goto out; 1378 } 1379 1380 fsa->fsa_ax25.sax25_family = AF_AX25; 1381 fsa->fsa_ax25.sax25_call = ax25->dest_addr; 1382 fsa->fsa_ax25.sax25_ndigis = 0; 1383 1384 if (ax25->digipeat != NULL) { 1385 ndigi = ax25->digipeat->ndigi; 1386 fsa->fsa_ax25.sax25_ndigis = ndigi; 1387 for (i = 0; i < ndigi; i++) 1388 fsa->fsa_digipeater[i] = 1389 ax25->digipeat->calls[i]; 1390 } 1391 } else { 1392 fsa->fsa_ax25.sax25_family = AF_AX25; 1393 fsa->fsa_ax25.sax25_call = ax25->source_addr; 1394 fsa->fsa_ax25.sax25_ndigis = 1; 1395 if (ax25->ax25_dev != NULL) { 1396 memcpy(&fsa->fsa_digipeater[0], 1397 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN); 1398 } else { 1399 fsa->fsa_digipeater[0] = null_ax25_address; 1400 } 1401 } 1402 *uaddr_len = sizeof (struct full_sockaddr_ax25); 1403 1404 out: 1405 release_sock(sk); 1406 1407 return err; 1408 } 1409 1410 static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock, 1411 struct msghdr *msg, size_t len) 1412 { 1413 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name; 1414 struct sock *sk = sock->sk; 1415 struct sockaddr_ax25 sax; 1416 struct sk_buff *skb; 1417 ax25_digi dtmp, *dp; 1418 unsigned char *asmptr; 1419 ax25_cb *ax25; 1420 size_t size; 1421 int lv, err, addr_len = msg->msg_namelen; 1422 1423 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT)) 1424 return -EINVAL; 1425 1426 lock_sock(sk); 1427 ax25 = ax25_sk(sk); 1428 1429 if (sock_flag(sk, SOCK_ZAPPED)) { 1430 err = -EADDRNOTAVAIL; 1431 goto out; 1432 } 1433 1434 if (sk->sk_shutdown & SEND_SHUTDOWN) { 1435 send_sig(SIGPIPE, current, 0); 1436 err = -EPIPE; 1437 goto out; 1438 } 1439 1440 if (ax25->ax25_dev == NULL) { 1441 err = -ENETUNREACH; 1442 goto out; 1443 } 1444 1445 if (len > ax25->ax25_dev->dev->mtu) { 1446 err = -EMSGSIZE; 1447 goto out; 1448 } 1449 1450 if (usax != NULL) { 1451 if (usax->sax25_family != AF_AX25) { 1452 err = -EINVAL; 1453 goto out; 1454 } 1455 1456 if (addr_len == sizeof(struct sockaddr_ax25)) { 1457 printk(KERN_WARNING "ax25_sendmsg(): %s uses obsolete socket structure\n", 1458 current->comm); 1459 } 1460 else if (addr_len != sizeof(struct full_sockaddr_ax25)) { 1461 /* support for old structure may go away some time */ 1462 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) || 1463 (addr_len > sizeof(struct full_sockaddr_ax25))) { 1464 err = -EINVAL; 1465 goto out; 1466 } 1467 1468 printk(KERN_WARNING "ax25_sendmsg(): %s uses old (6 digipeater) socket structure.\n", 1469 current->comm); 1470 } 1471 1472 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) { 1473 int ct = 0; 1474 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax; 1475 1476 /* Valid number of digipeaters ? */ 1477 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) { 1478 err = -EINVAL; 1479 goto out; 1480 } 1481 1482 dtmp.ndigi = usax->sax25_ndigis; 1483 1484 while (ct < usax->sax25_ndigis) { 1485 dtmp.repeated[ct] = 0; 1486 dtmp.calls[ct] = fsa->fsa_digipeater[ct]; 1487 ct++; 1488 } 1489 1490 dtmp.lastrepeat = 0; 1491 } 1492 1493 sax = *usax; 1494 if (sk->sk_type == SOCK_SEQPACKET && 1495 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) { 1496 err = -EISCONN; 1497 goto out; 1498 } 1499 if (usax->sax25_ndigis == 0) 1500 dp = NULL; 1501 else 1502 dp = &dtmp; 1503 } else { 1504 /* 1505 * FIXME: 1003.1g - if the socket is like this because 1506 * it has become closed (not started closed) and is VC 1507 * we ought to SIGPIPE, EPIPE 1508 */ 1509 if (sk->sk_state != TCP_ESTABLISHED) { 1510 err = -ENOTCONN; 1511 goto out; 1512 } 1513 sax.sax25_family = AF_AX25; 1514 sax.sax25_call = ax25->dest_addr; 1515 dp = ax25->digipeat; 1516 } 1517 1518 SOCK_DEBUG(sk, "AX.25: sendto: Addresses built.\n"); 1519 1520 /* Build a packet */ 1521 SOCK_DEBUG(sk, "AX.25: sendto: building packet.\n"); 1522 1523 /* Assume the worst case */ 1524 size = len + ax25->ax25_dev->dev->hard_header_len; 1525 1526 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err); 1527 if (skb == NULL) 1528 goto out; 1529 1530 skb_reserve(skb, size - len); 1531 1532 SOCK_DEBUG(sk, "AX.25: Appending user data\n"); 1533 1534 /* User data follows immediately after the AX.25 data */ 1535 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) { 1536 err = -EFAULT; 1537 kfree_skb(skb); 1538 goto out; 1539 } 1540 1541 skb->nh.raw = skb->data; 1542 1543 /* Add the PID if one is not supplied by the user in the skb */ 1544 if (!ax25->pidincl) { 1545 asmptr = skb_push(skb, 1); 1546 *asmptr = sk->sk_protocol; 1547 } 1548 1549 SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n"); 1550 1551 if (sk->sk_type == SOCK_SEQPACKET) { 1552 /* Connected mode sockets go via the LAPB machine */ 1553 if (sk->sk_state != TCP_ESTABLISHED) { 1554 kfree_skb(skb); 1555 err = -ENOTCONN; 1556 goto out; 1557 } 1558 1559 /* Shove it onto the queue and kick */ 1560 ax25_output(ax25, ax25->paclen, skb); 1561 1562 err = len; 1563 goto out; 1564 } 1565 1566 asmptr = skb_push(skb, 1 + ax25_addr_size(dp)); 1567 1568 SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp); 1569 1570 if (dp != NULL) 1571 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi); 1572 1573 /* Build an AX.25 header */ 1574 asmptr += (lv = ax25_addr_build(asmptr, &ax25->source_addr, 1575 &sax.sax25_call, dp, 1576 AX25_COMMAND, AX25_MODULUS)); 1577 1578 SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv); 1579 1580 skb->h.raw = asmptr; 1581 1582 SOCK_DEBUG(sk, "base=%p pos=%p\n", skb->data, asmptr); 1583 1584 *asmptr = AX25_UI; 1585 1586 /* Datagram frames go straight out of the door as UI */ 1587 ax25_queue_xmit(skb, ax25->ax25_dev->dev); 1588 1589 err = len; 1590 1591 out: 1592 release_sock(sk); 1593 1594 return err; 1595 } 1596 1597 static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock, 1598 struct msghdr *msg, size_t size, int flags) 1599 { 1600 struct sock *sk = sock->sk; 1601 struct sk_buff *skb; 1602 int copied; 1603 int err = 0; 1604 1605 lock_sock(sk); 1606 /* 1607 * This works for seqpacket too. The receiver has ordered the 1608 * queue for us! We do one quick check first though 1609 */ 1610 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) { 1611 err = -ENOTCONN; 1612 goto out; 1613 } 1614 1615 /* Now we can treat all alike */ 1616 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, 1617 flags & MSG_DONTWAIT, &err); 1618 if (skb == NULL) 1619 goto out; 1620 1621 if (!ax25_sk(sk)->pidincl) 1622 skb_pull(skb, 1); /* Remove PID */ 1623 1624 skb->h.raw = skb->data; 1625 copied = skb->len; 1626 1627 if (copied > size) { 1628 copied = size; 1629 msg->msg_flags |= MSG_TRUNC; 1630 } 1631 1632 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 1633 1634 if (msg->msg_namelen != 0) { 1635 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name; 1636 ax25_digi digi; 1637 ax25_address src; 1638 1639 ax25_addr_parse(skb->mac.raw+1, skb->data-skb->mac.raw-1, &src, NULL, &digi, NULL, NULL); 1640 1641 sax->sax25_family = AF_AX25; 1642 /* We set this correctly, even though we may not let the 1643 application know the digi calls further down (because it 1644 did NOT ask to know them). This could get political... **/ 1645 sax->sax25_ndigis = digi.ndigi; 1646 sax->sax25_call = src; 1647 1648 if (sax->sax25_ndigis != 0) { 1649 int ct; 1650 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax; 1651 1652 for (ct = 0; ct < digi.ndigi; ct++) 1653 fsa->fsa_digipeater[ct] = digi.calls[ct]; 1654 } 1655 msg->msg_namelen = sizeof(struct full_sockaddr_ax25); 1656 } 1657 1658 skb_free_datagram(sk, skb); 1659 err = copied; 1660 1661 out: 1662 release_sock(sk); 1663 1664 return err; 1665 } 1666 1667 static int ax25_shutdown(struct socket *sk, int how) 1668 { 1669 /* FIXME - generate DM and RNR states */ 1670 return -EOPNOTSUPP; 1671 } 1672 1673 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 1674 { 1675 struct sock *sk = sock->sk; 1676 void __user *argp = (void __user *)arg; 1677 int res = 0; 1678 1679 lock_sock(sk); 1680 switch (cmd) { 1681 case TIOCOUTQ: { 1682 long amount; 1683 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc); 1684 if (amount < 0) 1685 amount = 0; 1686 res = put_user(amount, (int __user *)argp); 1687 break; 1688 } 1689 1690 case TIOCINQ: { 1691 struct sk_buff *skb; 1692 long amount = 0L; 1693 /* These two are safe on a single CPU system as only user tasks fiddle here */ 1694 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL) 1695 amount = skb->len; 1696 res = put_user(amount, (int __user *) argp); 1697 break; 1698 } 1699 1700 case SIOCGSTAMP: 1701 res = sock_get_timestamp(sk, argp); 1702 break; 1703 1704 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */ 1705 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */ 1706 case SIOCAX25GETUID: { 1707 struct sockaddr_ax25 sax25; 1708 if (copy_from_user(&sax25, argp, sizeof(sax25))) { 1709 res = -EFAULT; 1710 break; 1711 } 1712 res = ax25_uid_ioctl(cmd, &sax25); 1713 break; 1714 } 1715 1716 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */ 1717 long amount; 1718 if (!capable(CAP_NET_ADMIN)) { 1719 res = -EPERM; 1720 break; 1721 } 1722 if (get_user(amount, (long __user *)argp)) { 1723 res = -EFAULT; 1724 break; 1725 } 1726 if (amount > AX25_NOUID_BLOCK) { 1727 res = -EINVAL; 1728 break; 1729 } 1730 ax25_uid_policy = amount; 1731 res = 0; 1732 break; 1733 } 1734 1735 case SIOCADDRT: 1736 case SIOCDELRT: 1737 case SIOCAX25OPTRT: 1738 if (!capable(CAP_NET_ADMIN)) { 1739 res = -EPERM; 1740 break; 1741 } 1742 res = ax25_rt_ioctl(cmd, argp); 1743 break; 1744 1745 case SIOCAX25CTLCON: 1746 if (!capable(CAP_NET_ADMIN)) { 1747 res = -EPERM; 1748 break; 1749 } 1750 res = ax25_ctl_ioctl(cmd, argp); 1751 break; 1752 1753 case SIOCAX25GETINFO: 1754 case SIOCAX25GETINFOOLD: { 1755 ax25_cb *ax25 = ax25_sk(sk); 1756 struct ax25_info_struct ax25_info; 1757 1758 ax25_info.t1 = ax25->t1 / HZ; 1759 ax25_info.t2 = ax25->t2 / HZ; 1760 ax25_info.t3 = ax25->t3 / HZ; 1761 ax25_info.idle = ax25->idle / (60 * HZ); 1762 ax25_info.n2 = ax25->n2; 1763 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ; 1764 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ; 1765 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ; 1766 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ); 1767 ax25_info.n2count = ax25->n2count; 1768 ax25_info.state = ax25->state; 1769 ax25_info.rcv_q = atomic_read(&sk->sk_rmem_alloc); 1770 ax25_info.snd_q = atomic_read(&sk->sk_wmem_alloc); 1771 ax25_info.vs = ax25->vs; 1772 ax25_info.vr = ax25->vr; 1773 ax25_info.va = ax25->va; 1774 ax25_info.vs_max = ax25->vs; /* reserved */ 1775 ax25_info.paclen = ax25->paclen; 1776 ax25_info.window = ax25->window; 1777 1778 /* old structure? */ 1779 if (cmd == SIOCAX25GETINFOOLD) { 1780 static int warned = 0; 1781 if (!warned) { 1782 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n", 1783 current->comm); 1784 warned=1; 1785 } 1786 1787 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) { 1788 res = -EFAULT; 1789 break; 1790 } 1791 } else { 1792 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) { 1793 res = -EINVAL; 1794 break; 1795 } 1796 } 1797 res = 0; 1798 break; 1799 } 1800 1801 case SIOCAX25ADDFWD: 1802 case SIOCAX25DELFWD: { 1803 struct ax25_fwd_struct ax25_fwd; 1804 if (!capable(CAP_NET_ADMIN)) { 1805 res = -EPERM; 1806 break; 1807 } 1808 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) { 1809 res = -EFAULT; 1810 break; 1811 } 1812 res = ax25_fwd_ioctl(cmd, &ax25_fwd); 1813 break; 1814 } 1815 1816 case SIOCGIFADDR: 1817 case SIOCSIFADDR: 1818 case SIOCGIFDSTADDR: 1819 case SIOCSIFDSTADDR: 1820 case SIOCGIFBRDADDR: 1821 case SIOCSIFBRDADDR: 1822 case SIOCGIFNETMASK: 1823 case SIOCSIFNETMASK: 1824 case SIOCGIFMETRIC: 1825 case SIOCSIFMETRIC: 1826 res = -EINVAL; 1827 break; 1828 1829 default: 1830 res = dev_ioctl(cmd, argp); 1831 break; 1832 } 1833 release_sock(sk); 1834 1835 return res; 1836 } 1837 1838 #ifdef CONFIG_PROC_FS 1839 1840 static void *ax25_info_start(struct seq_file *seq, loff_t *pos) 1841 { 1842 struct ax25_cb *ax25; 1843 struct hlist_node *node; 1844 int i = 0; 1845 1846 spin_lock_bh(&ax25_list_lock); 1847 ax25_for_each(ax25, node, &ax25_list) { 1848 if (i == *pos) 1849 return ax25; 1850 ++i; 1851 } 1852 return NULL; 1853 } 1854 1855 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos) 1856 { 1857 ++*pos; 1858 1859 return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next, 1860 struct ax25_cb, ax25_node); 1861 } 1862 1863 static void ax25_info_stop(struct seq_file *seq, void *v) 1864 { 1865 spin_unlock_bh(&ax25_list_lock); 1866 } 1867 1868 static int ax25_info_show(struct seq_file *seq, void *v) 1869 { 1870 ax25_cb *ax25 = v; 1871 char buf[11]; 1872 int k; 1873 1874 1875 /* 1876 * New format: 1877 * magic dev src_addr dest_addr,digi1,digi2,.. st vs vr va t1 t1 t2 t2 t3 t3 idle idle n2 n2 rtt window paclen Snd-Q Rcv-Q inode 1878 */ 1879 1880 seq_printf(seq, "%8.8lx %s %s%s ", 1881 (long) ax25, 1882 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name, 1883 ax2asc(buf, &ax25->source_addr), 1884 ax25->iamdigi? "*":""); 1885 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr)); 1886 1887 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) { 1888 seq_printf(seq, ",%s%s", 1889 ax2asc(buf, &ax25->digipeat->calls[k]), 1890 ax25->digipeat->repeated[k]? "*":""); 1891 } 1892 1893 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d", 1894 ax25->state, 1895 ax25->vs, ax25->vr, ax25->va, 1896 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ, 1897 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ, 1898 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ, 1899 ax25_display_timer(&ax25->idletimer) / (60 * HZ), 1900 ax25->idle / (60 * HZ), 1901 ax25->n2count, ax25->n2, 1902 ax25->rtt / HZ, 1903 ax25->window, 1904 ax25->paclen); 1905 1906 if (ax25->sk != NULL) { 1907 bh_lock_sock(ax25->sk); 1908 seq_printf(seq," %d %d %ld\n", 1909 atomic_read(&ax25->sk->sk_wmem_alloc), 1910 atomic_read(&ax25->sk->sk_rmem_alloc), 1911 ax25->sk->sk_socket != NULL ? SOCK_INODE(ax25->sk->sk_socket)->i_ino : 0L); 1912 bh_unlock_sock(ax25->sk); 1913 } else { 1914 seq_puts(seq, " * * *\n"); 1915 } 1916 return 0; 1917 } 1918 1919 static struct seq_operations ax25_info_seqops = { 1920 .start = ax25_info_start, 1921 .next = ax25_info_next, 1922 .stop = ax25_info_stop, 1923 .show = ax25_info_show, 1924 }; 1925 1926 static int ax25_info_open(struct inode *inode, struct file *file) 1927 { 1928 return seq_open(file, &ax25_info_seqops); 1929 } 1930 1931 static struct file_operations ax25_info_fops = { 1932 .owner = THIS_MODULE, 1933 .open = ax25_info_open, 1934 .read = seq_read, 1935 .llseek = seq_lseek, 1936 .release = seq_release, 1937 }; 1938 1939 #endif 1940 1941 static struct net_proto_family ax25_family_ops = { 1942 .family = PF_AX25, 1943 .create = ax25_create, 1944 .owner = THIS_MODULE, 1945 }; 1946 1947 static struct proto_ops ax25_proto_ops = { 1948 .family = PF_AX25, 1949 .owner = THIS_MODULE, 1950 .release = ax25_release, 1951 .bind = ax25_bind, 1952 .connect = ax25_connect, 1953 .socketpair = sock_no_socketpair, 1954 .accept = ax25_accept, 1955 .getname = ax25_getname, 1956 .poll = datagram_poll, 1957 .ioctl = ax25_ioctl, 1958 .listen = ax25_listen, 1959 .shutdown = ax25_shutdown, 1960 .setsockopt = ax25_setsockopt, 1961 .getsockopt = ax25_getsockopt, 1962 .sendmsg = ax25_sendmsg, 1963 .recvmsg = ax25_recvmsg, 1964 .mmap = sock_no_mmap, 1965 .sendpage = sock_no_sendpage, 1966 }; 1967 1968 /* 1969 * Called by socket.c on kernel start up 1970 */ 1971 static struct packet_type ax25_packet_type = { 1972 .type = __constant_htons(ETH_P_AX25), 1973 .dev = NULL, /* All devices */ 1974 .func = ax25_kiss_rcv, 1975 }; 1976 1977 static struct notifier_block ax25_dev_notifier = { 1978 .notifier_call =ax25_device_event, 1979 }; 1980 1981 EXPORT_SYMBOL(ax25_hard_header); 1982 EXPORT_SYMBOL(ax25_rebuild_header); 1983 EXPORT_SYMBOL(ax25_findbyuid); 1984 EXPORT_SYMBOL(ax25_find_cb); 1985 EXPORT_SYMBOL(ax25_linkfail_register); 1986 EXPORT_SYMBOL(ax25_linkfail_release); 1987 EXPORT_SYMBOL(ax25_listen_register); 1988 EXPORT_SYMBOL(ax25_listen_release); 1989 EXPORT_SYMBOL(ax25_protocol_register); 1990 EXPORT_SYMBOL(ax25_protocol_release); 1991 EXPORT_SYMBOL(ax25_send_frame); 1992 EXPORT_SYMBOL(ax25_uid_policy); 1993 EXPORT_SYMBOL(ax25cmp); 1994 EXPORT_SYMBOL(ax2asc); 1995 EXPORT_SYMBOL(asc2ax); 1996 EXPORT_SYMBOL(null_ax25_address); 1997 EXPORT_SYMBOL(ax25_display_timer); 1998 1999 static int __init ax25_init(void) 2000 { 2001 int rc = proto_register(&ax25_proto, 0); 2002 2003 if (rc != 0) 2004 goto out; 2005 2006 sock_register(&ax25_family_ops); 2007 dev_add_pack(&ax25_packet_type); 2008 register_netdevice_notifier(&ax25_dev_notifier); 2009 ax25_register_sysctl(); 2010 2011 proc_net_fops_create("ax25_route", S_IRUGO, &ax25_route_fops); 2012 proc_net_fops_create("ax25", S_IRUGO, &ax25_info_fops); 2013 proc_net_fops_create("ax25_calls", S_IRUGO, &ax25_uid_fops); 2014 out: 2015 return rc; 2016 } 2017 module_init(ax25_init); 2018 2019 2020 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>"); 2021 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol"); 2022 MODULE_LICENSE("GPL"); 2023 MODULE_ALIAS_NETPROTO(PF_AX25); 2024 2025 static void __exit ax25_exit(void) 2026 { 2027 proc_net_remove("ax25_route"); 2028 proc_net_remove("ax25"); 2029 proc_net_remove("ax25_calls"); 2030 ax25_rt_free(); 2031 ax25_uid_free(); 2032 ax25_dev_free(); 2033 2034 ax25_unregister_sysctl(); 2035 unregister_netdevice_notifier(&ax25_dev_notifier); 2036 2037 dev_remove_pack(&ax25_packet_type); 2038 2039 sock_unregister(PF_AX25); 2040 proto_unregister(&ax25_proto); 2041 } 2042 module_exit(ax25_exit); 2043