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