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