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