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 (!net_eq(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 /* 9A4GL: hack to release unaccepted sockets */ 321 skb->sk->sk_state = TCP_LISTEN; 322 323 ax25_start_heartbeat(sax25); 324 sax25->state = AX25_STATE_0; 325 } 326 327 kfree_skb(skb); 328 } 329 skb_queue_purge(&ax25->sk->sk_write_queue); 330 } 331 332 if (ax25->sk != NULL) { 333 if (sk_has_allocations(ax25->sk)) { 334 /* Defer: outstanding buffers */ 335 setup_timer(&ax25->dtimer, ax25_destroy_timer, 336 (unsigned long)ax25); 337 ax25->dtimer.expires = jiffies + 2 * HZ; 338 add_timer(&ax25->dtimer); 339 } else { 340 struct sock *sk=ax25->sk; 341 ax25->sk=NULL; 342 sock_put(sk); 343 } 344 } else { 345 ax25_cb_put(ax25); 346 } 347 } 348 349 /* 350 * dl1bke 960311: set parameters for existing AX.25 connections, 351 * includes a KILL command to abort any connection. 352 * VERY useful for debugging ;-) 353 */ 354 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg) 355 { 356 struct ax25_ctl_struct ax25_ctl; 357 ax25_digi digi; 358 ax25_dev *ax25_dev; 359 ax25_cb *ax25; 360 unsigned int k; 361 362 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl))) 363 return -EFAULT; 364 365 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL) 366 return -ENODEV; 367 368 if (ax25_ctl.digi_count > AX25_MAX_DIGIS) 369 return -EINVAL; 370 371 digi.ndigi = ax25_ctl.digi_count; 372 for (k = 0; k < digi.ndigi; k++) 373 digi.calls[k] = ax25_ctl.digi_addr[k]; 374 375 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL) 376 return -ENOTCONN; 377 378 switch (ax25_ctl.cmd) { 379 case AX25_KILL: 380 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND); 381 #ifdef CONFIG_AX25_DAMA_SLAVE 382 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE) 383 ax25_dama_off(ax25); 384 #endif 385 ax25_disconnect(ax25, ENETRESET); 386 break; 387 388 case AX25_WINDOW: 389 if (ax25->modulus == AX25_MODULUS) { 390 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7) 391 return -EINVAL; 392 } else { 393 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63) 394 return -EINVAL; 395 } 396 ax25->window = ax25_ctl.arg; 397 break; 398 399 case AX25_T1: 400 if (ax25_ctl.arg < 1) 401 return -EINVAL; 402 ax25->rtt = (ax25_ctl.arg * HZ) / 2; 403 ax25->t1 = ax25_ctl.arg * HZ; 404 break; 405 406 case AX25_T2: 407 if (ax25_ctl.arg < 1) 408 return -EINVAL; 409 ax25->t2 = ax25_ctl.arg * HZ; 410 break; 411 412 case AX25_N2: 413 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31) 414 return -EINVAL; 415 ax25->n2count = 0; 416 ax25->n2 = ax25_ctl.arg; 417 break; 418 419 case AX25_T3: 420 if (ax25_ctl.arg < 0) 421 return -EINVAL; 422 ax25->t3 = ax25_ctl.arg * HZ; 423 break; 424 425 case AX25_IDLE: 426 if (ax25_ctl.arg < 0) 427 return -EINVAL; 428 ax25->idle = ax25_ctl.arg * 60 * HZ; 429 break; 430 431 case AX25_PACLEN: 432 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535) 433 return -EINVAL; 434 ax25->paclen = ax25_ctl.arg; 435 break; 436 437 default: 438 return -EINVAL; 439 } 440 441 return 0; 442 } 443 444 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev) 445 { 446 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2; 447 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]); 448 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]); 449 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]); 450 ax25->n2 = ax25_dev->values[AX25_VALUES_N2]; 451 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN]; 452 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]); 453 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF]; 454 455 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) { 456 ax25->modulus = AX25_EMODULUS; 457 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW]; 458 } else { 459 ax25->modulus = AX25_MODULUS; 460 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW]; 461 } 462 } 463 464 /* 465 * Fill in a created AX.25 created control block with the default 466 * values for a particular device. 467 */ 468 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev) 469 { 470 ax25->ax25_dev = ax25_dev; 471 472 if (ax25->ax25_dev != NULL) { 473 ax25_fillin_cb_from_dev(ax25, ax25_dev); 474 return; 475 } 476 477 /* 478 * No device, use kernel / AX.25 spec default values 479 */ 480 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2; 481 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1); 482 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2); 483 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3); 484 ax25->n2 = AX25_DEF_N2; 485 ax25->paclen = AX25_DEF_PACLEN; 486 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE); 487 ax25->backoff = AX25_DEF_BACKOFF; 488 489 if (AX25_DEF_AXDEFMODE) { 490 ax25->modulus = AX25_EMODULUS; 491 ax25->window = AX25_DEF_EWINDOW; 492 } else { 493 ax25->modulus = AX25_MODULUS; 494 ax25->window = AX25_DEF_WINDOW; 495 } 496 } 497 498 /* 499 * Create an empty AX.25 control block. 500 */ 501 ax25_cb *ax25_create_cb(void) 502 { 503 ax25_cb *ax25; 504 505 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL) 506 return NULL; 507 508 atomic_set(&ax25->refcount, 1); 509 510 skb_queue_head_init(&ax25->write_queue); 511 skb_queue_head_init(&ax25->frag_queue); 512 skb_queue_head_init(&ax25->ack_queue); 513 skb_queue_head_init(&ax25->reseq_queue); 514 515 ax25_setup_timers(ax25); 516 517 ax25_fillin_cb(ax25, NULL); 518 519 ax25->state = AX25_STATE_0; 520 521 return ax25; 522 } 523 524 /* 525 * Handling for system calls applied via the various interfaces to an 526 * AX25 socket object 527 */ 528 529 static int ax25_setsockopt(struct socket *sock, int level, int optname, 530 char __user *optval, int optlen) 531 { 532 struct sock *sk = sock->sk; 533 ax25_cb *ax25; 534 struct net_device *dev; 535 char devname[IFNAMSIZ]; 536 int opt, res = 0; 537 538 if (level != SOL_AX25) 539 return -ENOPROTOOPT; 540 541 if (optlen < sizeof(int)) 542 return -EINVAL; 543 544 if (get_user(opt, (int __user *)optval)) 545 return -EFAULT; 546 547 lock_sock(sk); 548 ax25 = ax25_sk(sk); 549 550 switch (optname) { 551 case AX25_WINDOW: 552 if (ax25->modulus == AX25_MODULUS) { 553 if (opt < 1 || opt > 7) { 554 res = -EINVAL; 555 break; 556 } 557 } else { 558 if (opt < 1 || opt > 63) { 559 res = -EINVAL; 560 break; 561 } 562 } 563 ax25->window = opt; 564 break; 565 566 case AX25_T1: 567 if (opt < 1) { 568 res = -EINVAL; 569 break; 570 } 571 ax25->rtt = (opt * HZ) >> 1; 572 ax25->t1 = opt * HZ; 573 break; 574 575 case AX25_T2: 576 if (opt < 1) { 577 res = -EINVAL; 578 break; 579 } 580 ax25->t2 = opt * HZ; 581 break; 582 583 case AX25_N2: 584 if (opt < 1 || opt > 31) { 585 res = -EINVAL; 586 break; 587 } 588 ax25->n2 = opt; 589 break; 590 591 case AX25_T3: 592 if (opt < 1) { 593 res = -EINVAL; 594 break; 595 } 596 ax25->t3 = opt * HZ; 597 break; 598 599 case AX25_IDLE: 600 if (opt < 0) { 601 res = -EINVAL; 602 break; 603 } 604 ax25->idle = opt * 60 * HZ; 605 break; 606 607 case AX25_BACKOFF: 608 if (opt < 0 || opt > 2) { 609 res = -EINVAL; 610 break; 611 } 612 ax25->backoff = opt; 613 break; 614 615 case AX25_EXTSEQ: 616 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS; 617 break; 618 619 case AX25_PIDINCL: 620 ax25->pidincl = opt ? 1 : 0; 621 break; 622 623 case AX25_IAMDIGI: 624 ax25->iamdigi = opt ? 1 : 0; 625 break; 626 627 case AX25_PACLEN: 628 if (opt < 16 || opt > 65535) { 629 res = -EINVAL; 630 break; 631 } 632 ax25->paclen = opt; 633 break; 634 635 case SO_BINDTODEVICE: 636 if (optlen > IFNAMSIZ) 637 optlen=IFNAMSIZ; 638 if (copy_from_user(devname, optval, optlen)) { 639 res = -EFAULT; 640 break; 641 } 642 643 dev = dev_get_by_name(&init_net, devname); 644 if (dev == NULL) { 645 res = -ENODEV; 646 break; 647 } 648 649 if (sk->sk_type == SOCK_SEQPACKET && 650 (sock->state != SS_UNCONNECTED || 651 sk->sk_state == TCP_LISTEN)) { 652 res = -EADDRNOTAVAIL; 653 dev_put(dev); 654 break; 655 } 656 657 ax25->ax25_dev = ax25_dev_ax25dev(dev); 658 ax25_fillin_cb(ax25, ax25->ax25_dev); 659 break; 660 661 default: 662 res = -ENOPROTOOPT; 663 } 664 release_sock(sk); 665 666 return res; 667 } 668 669 static int ax25_getsockopt(struct socket *sock, int level, int optname, 670 char __user *optval, int __user *optlen) 671 { 672 struct sock *sk = sock->sk; 673 ax25_cb *ax25; 674 struct ax25_dev *ax25_dev; 675 char devname[IFNAMSIZ]; 676 void *valptr; 677 int val = 0; 678 int maxlen, length; 679 680 if (level != SOL_AX25) 681 return -ENOPROTOOPT; 682 683 if (get_user(maxlen, optlen)) 684 return -EFAULT; 685 686 if (maxlen < 1) 687 return -EFAULT; 688 689 valptr = (void *) &val; 690 length = min_t(unsigned int, maxlen, sizeof(int)); 691 692 lock_sock(sk); 693 ax25 = ax25_sk(sk); 694 695 switch (optname) { 696 case AX25_WINDOW: 697 val = ax25->window; 698 break; 699 700 case AX25_T1: 701 val = ax25->t1 / HZ; 702 break; 703 704 case AX25_T2: 705 val = ax25->t2 / HZ; 706 break; 707 708 case AX25_N2: 709 val = ax25->n2; 710 break; 711 712 case AX25_T3: 713 val = ax25->t3 / HZ; 714 break; 715 716 case AX25_IDLE: 717 val = ax25->idle / (60 * HZ); 718 break; 719 720 case AX25_BACKOFF: 721 val = ax25->backoff; 722 break; 723 724 case AX25_EXTSEQ: 725 val = (ax25->modulus == AX25_EMODULUS); 726 break; 727 728 case AX25_PIDINCL: 729 val = ax25->pidincl; 730 break; 731 732 case AX25_IAMDIGI: 733 val = ax25->iamdigi; 734 break; 735 736 case AX25_PACLEN: 737 val = ax25->paclen; 738 break; 739 740 case SO_BINDTODEVICE: 741 ax25_dev = ax25->ax25_dev; 742 743 if (ax25_dev != NULL && ax25_dev->dev != NULL) { 744 strlcpy(devname, ax25_dev->dev->name, sizeof(devname)); 745 length = strlen(devname) + 1; 746 } else { 747 *devname = '\0'; 748 length = 1; 749 } 750 751 valptr = (void *) devname; 752 break; 753 754 default: 755 release_sock(sk); 756 return -ENOPROTOOPT; 757 } 758 release_sock(sk); 759 760 if (put_user(length, optlen)) 761 return -EFAULT; 762 763 return copy_to_user(optval, valptr, length) ? -EFAULT : 0; 764 } 765 766 static int ax25_listen(struct socket *sock, int backlog) 767 { 768 struct sock *sk = sock->sk; 769 int res = 0; 770 771 lock_sock(sk); 772 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) { 773 sk->sk_max_ack_backlog = backlog; 774 sk->sk_state = TCP_LISTEN; 775 goto out; 776 } 777 res = -EOPNOTSUPP; 778 779 out: 780 release_sock(sk); 781 782 return res; 783 } 784 785 /* 786 * XXX: when creating ax25_sock we should update the .obj_size setting 787 * below. 788 */ 789 static struct proto ax25_proto = { 790 .name = "AX25", 791 .owner = THIS_MODULE, 792 .obj_size = sizeof(struct sock), 793 }; 794 795 static int ax25_create(struct net *net, struct socket *sock, int protocol) 796 { 797 struct sock *sk; 798 ax25_cb *ax25; 799 800 if (net != &init_net) 801 return -EAFNOSUPPORT; 802 803 switch (sock->type) { 804 case SOCK_DGRAM: 805 if (protocol == 0 || protocol == PF_AX25) 806 protocol = AX25_P_TEXT; 807 break; 808 809 case SOCK_SEQPACKET: 810 switch (protocol) { 811 case 0: 812 case PF_AX25: /* For CLX */ 813 protocol = AX25_P_TEXT; 814 break; 815 case AX25_P_SEGMENT: 816 #ifdef CONFIG_INET 817 case AX25_P_ARP: 818 case AX25_P_IP: 819 #endif 820 #ifdef CONFIG_NETROM 821 case AX25_P_NETROM: 822 #endif 823 #ifdef CONFIG_ROSE 824 case AX25_P_ROSE: 825 #endif 826 return -ESOCKTNOSUPPORT; 827 #ifdef CONFIG_NETROM_MODULE 828 case AX25_P_NETROM: 829 if (ax25_protocol_is_registered(AX25_P_NETROM)) 830 return -ESOCKTNOSUPPORT; 831 #endif 832 #ifdef CONFIG_ROSE_MODULE 833 case AX25_P_ROSE: 834 if (ax25_protocol_is_registered(AX25_P_ROSE)) 835 return -ESOCKTNOSUPPORT; 836 #endif 837 default: 838 break; 839 } 840 break; 841 842 case SOCK_RAW: 843 break; 844 default: 845 return -ESOCKTNOSUPPORT; 846 } 847 848 sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto); 849 if (sk == NULL) 850 return -ENOMEM; 851 852 ax25 = sk->sk_protinfo = ax25_create_cb(); 853 if (!ax25) { 854 sk_free(sk); 855 return -ENOMEM; 856 } 857 858 sock_init_data(sock, sk); 859 860 sk->sk_destruct = ax25_free_sock; 861 sock->ops = &ax25_proto_ops; 862 sk->sk_protocol = protocol; 863 864 ax25->sk = sk; 865 866 return 0; 867 } 868 869 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev) 870 { 871 struct sock *sk; 872 ax25_cb *ax25, *oax25; 873 874 sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot); 875 if (sk == NULL) 876 return NULL; 877 878 if ((ax25 = ax25_create_cb()) == NULL) { 879 sk_free(sk); 880 return NULL; 881 } 882 883 switch (osk->sk_type) { 884 case SOCK_DGRAM: 885 break; 886 case SOCK_SEQPACKET: 887 break; 888 default: 889 sk_free(sk); 890 ax25_cb_put(ax25); 891 return NULL; 892 } 893 894 sock_init_data(NULL, sk); 895 896 sk->sk_destruct = ax25_free_sock; 897 sk->sk_type = osk->sk_type; 898 sk->sk_priority = osk->sk_priority; 899 sk->sk_protocol = osk->sk_protocol; 900 sk->sk_rcvbuf = osk->sk_rcvbuf; 901 sk->sk_sndbuf = osk->sk_sndbuf; 902 sk->sk_state = TCP_ESTABLISHED; 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 sock_graft(newsk, newsock); 1365 1366 /* Now attach up the new socket */ 1367 kfree_skb(skb); 1368 sk->sk_ack_backlog--; 1369 newsock->state = SS_CONNECTED; 1370 1371 out: 1372 release_sock(sk); 1373 1374 return err; 1375 } 1376 1377 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr, 1378 int *uaddr_len, int peer) 1379 { 1380 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr; 1381 struct sock *sk = sock->sk; 1382 unsigned char ndigi, i; 1383 ax25_cb *ax25; 1384 int err = 0; 1385 1386 lock_sock(sk); 1387 ax25 = ax25_sk(sk); 1388 1389 if (peer != 0) { 1390 if (sk->sk_state != TCP_ESTABLISHED) { 1391 err = -ENOTCONN; 1392 goto out; 1393 } 1394 1395 fsa->fsa_ax25.sax25_family = AF_AX25; 1396 fsa->fsa_ax25.sax25_call = ax25->dest_addr; 1397 fsa->fsa_ax25.sax25_ndigis = 0; 1398 1399 if (ax25->digipeat != NULL) { 1400 ndigi = ax25->digipeat->ndigi; 1401 fsa->fsa_ax25.sax25_ndigis = ndigi; 1402 for (i = 0; i < ndigi; i++) 1403 fsa->fsa_digipeater[i] = 1404 ax25->digipeat->calls[i]; 1405 } 1406 } else { 1407 fsa->fsa_ax25.sax25_family = AF_AX25; 1408 fsa->fsa_ax25.sax25_call = ax25->source_addr; 1409 fsa->fsa_ax25.sax25_ndigis = 1; 1410 if (ax25->ax25_dev != NULL) { 1411 memcpy(&fsa->fsa_digipeater[0], 1412 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN); 1413 } else { 1414 fsa->fsa_digipeater[0] = null_ax25_address; 1415 } 1416 } 1417 *uaddr_len = sizeof (struct full_sockaddr_ax25); 1418 1419 out: 1420 release_sock(sk); 1421 1422 return err; 1423 } 1424 1425 static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock, 1426 struct msghdr *msg, size_t len) 1427 { 1428 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name; 1429 struct sock *sk = sock->sk; 1430 struct sockaddr_ax25 sax; 1431 struct sk_buff *skb; 1432 ax25_digi dtmp, *dp; 1433 ax25_cb *ax25; 1434 size_t size; 1435 int lv, err, addr_len = msg->msg_namelen; 1436 1437 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT)) 1438 return -EINVAL; 1439 1440 lock_sock(sk); 1441 ax25 = ax25_sk(sk); 1442 1443 if (sock_flag(sk, SOCK_ZAPPED)) { 1444 err = -EADDRNOTAVAIL; 1445 goto out; 1446 } 1447 1448 if (sk->sk_shutdown & SEND_SHUTDOWN) { 1449 send_sig(SIGPIPE, current, 0); 1450 err = -EPIPE; 1451 goto out; 1452 } 1453 1454 if (ax25->ax25_dev == NULL) { 1455 err = -ENETUNREACH; 1456 goto out; 1457 } 1458 1459 if (len > ax25->ax25_dev->dev->mtu) { 1460 err = -EMSGSIZE; 1461 goto out; 1462 } 1463 1464 if (usax != NULL) { 1465 if (usax->sax25_family != AF_AX25) { 1466 err = -EINVAL; 1467 goto out; 1468 } 1469 1470 if (addr_len == sizeof(struct sockaddr_ax25)) 1471 /* ax25_sendmsg(): uses obsolete socket structure */ 1472 ; 1473 else if (addr_len != sizeof(struct full_sockaddr_ax25)) 1474 /* support for old structure may go away some time 1475 * ax25_sendmsg(): uses old (6 digipeater) 1476 * socket structure. 1477 */ 1478 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) || 1479 (addr_len > sizeof(struct full_sockaddr_ax25))) { 1480 err = -EINVAL; 1481 goto out; 1482 } 1483 1484 1485 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) { 1486 int ct = 0; 1487 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax; 1488 1489 /* Valid number of digipeaters ? */ 1490 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) { 1491 err = -EINVAL; 1492 goto out; 1493 } 1494 1495 dtmp.ndigi = usax->sax25_ndigis; 1496 1497 while (ct < usax->sax25_ndigis) { 1498 dtmp.repeated[ct] = 0; 1499 dtmp.calls[ct] = fsa->fsa_digipeater[ct]; 1500 ct++; 1501 } 1502 1503 dtmp.lastrepeat = 0; 1504 } 1505 1506 sax = *usax; 1507 if (sk->sk_type == SOCK_SEQPACKET && 1508 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) { 1509 err = -EISCONN; 1510 goto out; 1511 } 1512 if (usax->sax25_ndigis == 0) 1513 dp = NULL; 1514 else 1515 dp = &dtmp; 1516 } else { 1517 /* 1518 * FIXME: 1003.1g - if the socket is like this because 1519 * it has become closed (not started closed) and is VC 1520 * we ought to SIGPIPE, EPIPE 1521 */ 1522 if (sk->sk_state != TCP_ESTABLISHED) { 1523 err = -ENOTCONN; 1524 goto out; 1525 } 1526 sax.sax25_family = AF_AX25; 1527 sax.sax25_call = ax25->dest_addr; 1528 dp = ax25->digipeat; 1529 } 1530 1531 /* Build a packet */ 1532 SOCK_DEBUG(sk, "AX.25: sendto: Addresses built. Building packet.\n"); 1533 1534 /* Assume the worst case */ 1535 size = len + ax25->ax25_dev->dev->hard_header_len; 1536 1537 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err); 1538 if (skb == NULL) 1539 goto out; 1540 1541 skb_reserve(skb, size - len); 1542 1543 SOCK_DEBUG(sk, "AX.25: Appending user data\n"); 1544 1545 /* User data follows immediately after the AX.25 data */ 1546 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) { 1547 err = -EFAULT; 1548 kfree_skb(skb); 1549 goto out; 1550 } 1551 1552 skb_reset_network_header(skb); 1553 1554 /* Add the PID if one is not supplied by the user in the skb */ 1555 if (!ax25->pidincl) 1556 *skb_push(skb, 1) = sk->sk_protocol; 1557 1558 SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n"); 1559 1560 if (sk->sk_type == SOCK_SEQPACKET) { 1561 /* Connected mode sockets go via the LAPB machine */ 1562 if (sk->sk_state != TCP_ESTABLISHED) { 1563 kfree_skb(skb); 1564 err = -ENOTCONN; 1565 goto out; 1566 } 1567 1568 /* Shove it onto the queue and kick */ 1569 ax25_output(ax25, ax25->paclen, skb); 1570 1571 err = len; 1572 goto out; 1573 } 1574 1575 skb_push(skb, 1 + ax25_addr_size(dp)); 1576 1577 SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp); 1578 1579 if (dp != NULL) 1580 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi); 1581 1582 /* Build an AX.25 header */ 1583 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call, 1584 dp, AX25_COMMAND, AX25_MODULUS); 1585 1586 SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv); 1587 1588 skb_set_transport_header(skb, lv); 1589 1590 SOCK_DEBUG(sk, "base=%p pos=%p\n", 1591 skb->data, skb_transport_header(skb)); 1592 1593 *skb_transport_header(skb) = AX25_UI; 1594 1595 /* Datagram frames go straight out of the door as UI */ 1596 ax25_queue_xmit(skb, ax25->ax25_dev->dev); 1597 1598 err = len; 1599 1600 out: 1601 release_sock(sk); 1602 1603 return err; 1604 } 1605 1606 static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock, 1607 struct msghdr *msg, size_t size, int flags) 1608 { 1609 struct sock *sk = sock->sk; 1610 struct sk_buff *skb; 1611 int copied; 1612 int err = 0; 1613 1614 lock_sock(sk); 1615 /* 1616 * This works for seqpacket too. The receiver has ordered the 1617 * queue for us! We do one quick check first though 1618 */ 1619 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) { 1620 err = -ENOTCONN; 1621 goto out; 1622 } 1623 1624 /* Now we can treat all alike */ 1625 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, 1626 flags & MSG_DONTWAIT, &err); 1627 if (skb == NULL) 1628 goto out; 1629 1630 if (!ax25_sk(sk)->pidincl) 1631 skb_pull(skb, 1); /* Remove PID */ 1632 1633 skb_reset_transport_header(skb); 1634 copied = skb->len; 1635 1636 if (copied > size) { 1637 copied = size; 1638 msg->msg_flags |= MSG_TRUNC; 1639 } 1640 1641 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 1642 1643 if (msg->msg_namelen != 0) { 1644 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name; 1645 ax25_digi digi; 1646 ax25_address src; 1647 const unsigned char *mac = skb_mac_header(skb); 1648 1649 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL, 1650 &digi, NULL, NULL); 1651 sax->sax25_family = AF_AX25; 1652 /* We set this correctly, even though we may not let the 1653 application know the digi calls further down (because it 1654 did NOT ask to know them). This could get political... **/ 1655 sax->sax25_ndigis = digi.ndigi; 1656 sax->sax25_call = src; 1657 1658 if (sax->sax25_ndigis != 0) { 1659 int ct; 1660 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax; 1661 1662 for (ct = 0; ct < digi.ndigi; ct++) 1663 fsa->fsa_digipeater[ct] = digi.calls[ct]; 1664 } 1665 msg->msg_namelen = sizeof(struct full_sockaddr_ax25); 1666 } 1667 1668 skb_free_datagram(sk, skb); 1669 err = copied; 1670 1671 out: 1672 release_sock(sk); 1673 1674 return err; 1675 } 1676 1677 static int ax25_shutdown(struct socket *sk, int how) 1678 { 1679 /* FIXME - generate DM and RNR states */ 1680 return -EOPNOTSUPP; 1681 } 1682 1683 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 1684 { 1685 struct sock *sk = sock->sk; 1686 void __user *argp = (void __user *)arg; 1687 int res = 0; 1688 1689 lock_sock(sk); 1690 switch (cmd) { 1691 case TIOCOUTQ: { 1692 long amount; 1693 1694 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk); 1695 if (amount < 0) 1696 amount = 0; 1697 res = put_user(amount, (int __user *)argp); 1698 break; 1699 } 1700 1701 case TIOCINQ: { 1702 struct sk_buff *skb; 1703 long amount = 0L; 1704 /* These two are safe on a single CPU system as only user tasks fiddle here */ 1705 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL) 1706 amount = skb->len; 1707 res = put_user(amount, (int __user *) argp); 1708 break; 1709 } 1710 1711 case SIOCGSTAMP: 1712 res = sock_get_timestamp(sk, argp); 1713 break; 1714 1715 case SIOCGSTAMPNS: 1716 res = sock_get_timestampns(sk, argp); 1717 break; 1718 1719 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */ 1720 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */ 1721 case SIOCAX25GETUID: { 1722 struct sockaddr_ax25 sax25; 1723 if (copy_from_user(&sax25, argp, sizeof(sax25))) { 1724 res = -EFAULT; 1725 break; 1726 } 1727 res = ax25_uid_ioctl(cmd, &sax25); 1728 break; 1729 } 1730 1731 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */ 1732 long amount; 1733 if (!capable(CAP_NET_ADMIN)) { 1734 res = -EPERM; 1735 break; 1736 } 1737 if (get_user(amount, (long __user *)argp)) { 1738 res = -EFAULT; 1739 break; 1740 } 1741 if (amount > AX25_NOUID_BLOCK) { 1742 res = -EINVAL; 1743 break; 1744 } 1745 ax25_uid_policy = amount; 1746 res = 0; 1747 break; 1748 } 1749 1750 case SIOCADDRT: 1751 case SIOCDELRT: 1752 case SIOCAX25OPTRT: 1753 if (!capable(CAP_NET_ADMIN)) { 1754 res = -EPERM; 1755 break; 1756 } 1757 res = ax25_rt_ioctl(cmd, argp); 1758 break; 1759 1760 case SIOCAX25CTLCON: 1761 if (!capable(CAP_NET_ADMIN)) { 1762 res = -EPERM; 1763 break; 1764 } 1765 res = ax25_ctl_ioctl(cmd, argp); 1766 break; 1767 1768 case SIOCAX25GETINFO: 1769 case SIOCAX25GETINFOOLD: { 1770 ax25_cb *ax25 = ax25_sk(sk); 1771 struct ax25_info_struct ax25_info; 1772 1773 ax25_info.t1 = ax25->t1 / HZ; 1774 ax25_info.t2 = ax25->t2 / HZ; 1775 ax25_info.t3 = ax25->t3 / HZ; 1776 ax25_info.idle = ax25->idle / (60 * HZ); 1777 ax25_info.n2 = ax25->n2; 1778 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ; 1779 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ; 1780 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ; 1781 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ); 1782 ax25_info.n2count = ax25->n2count; 1783 ax25_info.state = ax25->state; 1784 ax25_info.rcv_q = sk_wmem_alloc_get(sk); 1785 ax25_info.snd_q = sk_rmem_alloc_get(sk); 1786 ax25_info.vs = ax25->vs; 1787 ax25_info.vr = ax25->vr; 1788 ax25_info.va = ax25->va; 1789 ax25_info.vs_max = ax25->vs; /* reserved */ 1790 ax25_info.paclen = ax25->paclen; 1791 ax25_info.window = ax25->window; 1792 1793 /* old structure? */ 1794 if (cmd == SIOCAX25GETINFOOLD) { 1795 static int warned = 0; 1796 if (!warned) { 1797 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n", 1798 current->comm); 1799 warned=1; 1800 } 1801 1802 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) { 1803 res = -EFAULT; 1804 break; 1805 } 1806 } else { 1807 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) { 1808 res = -EINVAL; 1809 break; 1810 } 1811 } 1812 res = 0; 1813 break; 1814 } 1815 1816 case SIOCAX25ADDFWD: 1817 case SIOCAX25DELFWD: { 1818 struct ax25_fwd_struct ax25_fwd; 1819 if (!capable(CAP_NET_ADMIN)) { 1820 res = -EPERM; 1821 break; 1822 } 1823 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) { 1824 res = -EFAULT; 1825 break; 1826 } 1827 res = ax25_fwd_ioctl(cmd, &ax25_fwd); 1828 break; 1829 } 1830 1831 case SIOCGIFADDR: 1832 case SIOCSIFADDR: 1833 case SIOCGIFDSTADDR: 1834 case SIOCSIFDSTADDR: 1835 case SIOCGIFBRDADDR: 1836 case SIOCSIFBRDADDR: 1837 case SIOCGIFNETMASK: 1838 case SIOCSIFNETMASK: 1839 case SIOCGIFMETRIC: 1840 case SIOCSIFMETRIC: 1841 res = -EINVAL; 1842 break; 1843 1844 default: 1845 res = -ENOIOCTLCMD; 1846 break; 1847 } 1848 release_sock(sk); 1849 1850 return res; 1851 } 1852 1853 #ifdef CONFIG_PROC_FS 1854 1855 static void *ax25_info_start(struct seq_file *seq, loff_t *pos) 1856 __acquires(ax25_list_lock) 1857 { 1858 struct ax25_cb *ax25; 1859 struct hlist_node *node; 1860 int i = 0; 1861 1862 spin_lock_bh(&ax25_list_lock); 1863 ax25_for_each(ax25, node, &ax25_list) { 1864 if (i == *pos) 1865 return ax25; 1866 ++i; 1867 } 1868 return NULL; 1869 } 1870 1871 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos) 1872 { 1873 ++*pos; 1874 1875 return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next, 1876 struct ax25_cb, ax25_node); 1877 } 1878 1879 static void ax25_info_stop(struct seq_file *seq, void *v) 1880 __releases(ax25_list_lock) 1881 { 1882 spin_unlock_bh(&ax25_list_lock); 1883 } 1884 1885 static int ax25_info_show(struct seq_file *seq, void *v) 1886 { 1887 ax25_cb *ax25 = v; 1888 char buf[11]; 1889 int k; 1890 1891 1892 /* 1893 * New format: 1894 * 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 1895 */ 1896 1897 seq_printf(seq, "%8.8lx %s %s%s ", 1898 (long) ax25, 1899 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name, 1900 ax2asc(buf, &ax25->source_addr), 1901 ax25->iamdigi? "*":""); 1902 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr)); 1903 1904 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) { 1905 seq_printf(seq, ",%s%s", 1906 ax2asc(buf, &ax25->digipeat->calls[k]), 1907 ax25->digipeat->repeated[k]? "*":""); 1908 } 1909 1910 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d", 1911 ax25->state, 1912 ax25->vs, ax25->vr, ax25->va, 1913 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ, 1914 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ, 1915 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ, 1916 ax25_display_timer(&ax25->idletimer) / (60 * HZ), 1917 ax25->idle / (60 * HZ), 1918 ax25->n2count, ax25->n2, 1919 ax25->rtt / HZ, 1920 ax25->window, 1921 ax25->paclen); 1922 1923 if (ax25->sk != NULL) { 1924 seq_printf(seq, " %d %d %lu\n", 1925 sk_wmem_alloc_get(ax25->sk), 1926 sk_rmem_alloc_get(ax25->sk), 1927 sock_i_ino(ax25->sk)); 1928 } else { 1929 seq_puts(seq, " * * *\n"); 1930 } 1931 return 0; 1932 } 1933 1934 static const struct seq_operations ax25_info_seqops = { 1935 .start = ax25_info_start, 1936 .next = ax25_info_next, 1937 .stop = ax25_info_stop, 1938 .show = ax25_info_show, 1939 }; 1940 1941 static int ax25_info_open(struct inode *inode, struct file *file) 1942 { 1943 return seq_open(file, &ax25_info_seqops); 1944 } 1945 1946 static const struct file_operations ax25_info_fops = { 1947 .owner = THIS_MODULE, 1948 .open = ax25_info_open, 1949 .read = seq_read, 1950 .llseek = seq_lseek, 1951 .release = seq_release, 1952 }; 1953 1954 #endif 1955 1956 static struct net_proto_family ax25_family_ops = { 1957 .family = PF_AX25, 1958 .create = ax25_create, 1959 .owner = THIS_MODULE, 1960 }; 1961 1962 static const struct proto_ops ax25_proto_ops = { 1963 .family = PF_AX25, 1964 .owner = THIS_MODULE, 1965 .release = ax25_release, 1966 .bind = ax25_bind, 1967 .connect = ax25_connect, 1968 .socketpair = sock_no_socketpair, 1969 .accept = ax25_accept, 1970 .getname = ax25_getname, 1971 .poll = datagram_poll, 1972 .ioctl = ax25_ioctl, 1973 .listen = ax25_listen, 1974 .shutdown = ax25_shutdown, 1975 .setsockopt = ax25_setsockopt, 1976 .getsockopt = ax25_getsockopt, 1977 .sendmsg = ax25_sendmsg, 1978 .recvmsg = ax25_recvmsg, 1979 .mmap = sock_no_mmap, 1980 .sendpage = sock_no_sendpage, 1981 }; 1982 1983 /* 1984 * Called by socket.c on kernel start up 1985 */ 1986 static struct packet_type ax25_packet_type __read_mostly = { 1987 .type = cpu_to_be16(ETH_P_AX25), 1988 .func = ax25_kiss_rcv, 1989 }; 1990 1991 static struct notifier_block ax25_dev_notifier = { 1992 .notifier_call =ax25_device_event, 1993 }; 1994 1995 static int __init ax25_init(void) 1996 { 1997 int rc = proto_register(&ax25_proto, 0); 1998 1999 if (rc != 0) 2000 goto out; 2001 2002 sock_register(&ax25_family_ops); 2003 dev_add_pack(&ax25_packet_type); 2004 register_netdevice_notifier(&ax25_dev_notifier); 2005 ax25_register_sysctl(); 2006 2007 proc_net_fops_create(&init_net, "ax25_route", S_IRUGO, &ax25_route_fops); 2008 proc_net_fops_create(&init_net, "ax25", S_IRUGO, &ax25_info_fops); 2009 proc_net_fops_create(&init_net, "ax25_calls", S_IRUGO, &ax25_uid_fops); 2010 out: 2011 return rc; 2012 } 2013 module_init(ax25_init); 2014 2015 2016 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>"); 2017 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol"); 2018 MODULE_LICENSE("GPL"); 2019 MODULE_ALIAS_NETPROTO(PF_AX25); 2020 2021 static void __exit ax25_exit(void) 2022 { 2023 proc_net_remove(&init_net, "ax25_route"); 2024 proc_net_remove(&init_net, "ax25"); 2025 proc_net_remove(&init_net, "ax25_calls"); 2026 ax25_rt_free(); 2027 ax25_uid_free(); 2028 ax25_dev_free(); 2029 2030 ax25_unregister_sysctl(); 2031 unregister_netdevice_notifier(&ax25_dev_notifier); 2032 2033 dev_remove_pack(&ax25_packet_type); 2034 2035 sock_unregister(PF_AX25); 2036 proto_unregister(&ax25_proto); 2037 } 2038 module_exit(ax25_exit); 2039