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