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