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