1/* 2 * AX.25 release 038 3 * 4 * This code REQUIRES 2.1.15 or higher/ NET3.038 5 * 6 * This module: 7 * This module is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 10 * 2 of the License, or (at your option) any later version. 11 * 12 * History 13 * AX.25 006 Alan(GW4PTS) Nearly died of shock - it's working 8-) 14 * AX.25 007 Alan(GW4PTS) Removed the silliest bugs 15 * AX.25 008 Alan(GW4PTS) Cleaned up, fixed a few state machine problems, added callbacks 16 * AX.25 009 Alan(GW4PTS) Emergency patch kit to fix memory corruption 17 * AX.25 010 Alan(GW4PTS) Added RAW sockets/Digipeat. 18 * AX.25 011 Alan(GW4PTS) RAW socket and datagram fixes (thanks) - Raw sendto now gets PID right 19 * datagram sendto uses correct target address. 20 * AX.25 012 Alan(GW4PTS) Correct incoming connection handling, send DM to failed connects. 21 * Use skb->data not skb+1. Support sk->priority correctly. 22 * Correct receive on SOCK_DGRAM. 23 * AX.25 013 Alan(GW4PTS) Send DM to all unknown frames, missing initialiser fixed 24 * Leave spare SSID bits set (DAMA etc) - thanks for bug report, 25 * removed device registration (it's not used or needed). Clean up for 26 * gcc 2.5.8. PID to AX25_P_ 27 * AX.25 014 Alan(GW4PTS) Cleanup and NET3 merge 28 * AX.25 015 Alan(GW4PTS) Internal test version. 29 * AX.25 016 Alan(GW4PTS) Semi Internal version for PI card 30 * work. 31 * AX.25 017 Alan(GW4PTS) Fixed some small bugs reported by 32 * G4KLX 33 * AX.25 018 Alan(GW4PTS) Fixed a small error in SOCK_DGRAM 34 * AX.25 019 Alan(GW4PTS) Clean ups for the non INET kernel and device ioctls in AX.25 35 * AX.25 020 Jonathan(G4KLX) /proc support and other changes. 36 * AX.25 021 Alan(GW4PTS) Added AX25_T1, AX25_N2, AX25_T3 as requested. 37 * AX.25 022 Jonathan(G4KLX) More work on the ax25 auto router and /proc improved (again)! 38 * Alan(GW4PTS) Added TIOCINQ/OUTQ 39 * AX.25 023 Alan(GW4PTS) Fixed shutdown bug 40 * AX.25 023 Alan(GW4PTS) Linus changed timers 41 * AX.25 024 Alan(GW4PTS) Small bug fixes 42 * AX.25 025 Alan(GW4PTS) More fixes, Linux 1.1.51 compatibility stuff, timers again! 43 * AX.25 026 Alan(GW4PTS) Small state fix. 44 * AX.25 027 Alan(GW4PTS) Socket close crash fixes. 45 * AX.25 028 Alan(GW4PTS) Callsign control including settings per uid. 46 * Small bug fixes. 47 * Protocol set by sockets only. 48 * Small changes to allow for start of NET/ROM layer. 49 * AX.25 028a Jonathan(G4KLX) Changes to state machine. 50 * AX.25 028b Jonathan(G4KLX) Extracted ax25 control block 51 * from sock structure. 52 * AX.25 029 Alan(GW4PTS) Combined 028b and some KA9Q code 53 * Jonathan(G4KLX) and removed all the old Berkeley, added IP mode registration. 54 * Darryl(G7LED) stuff. Cross-port digipeating. Minor fixes and enhancements. 55 * Alan(GW4PTS) Missed suser() on axassociate checks 56 * AX.25 030 Alan(GW4PTS) Added variable length headers. 57 * Jonathan(G4KLX) Added BPQ Ethernet interface. 58 * Steven(GW7RRM) Added digi-peating control ioctl. 59 * Added extended AX.25 support. 60 * Added AX.25 frame segmentation. 61 * Darryl(G7LED) Changed connect(), recvfrom(), sendto() sockaddr/addrlen to 62 * fall inline with bind() and new policy. 63 * Moved digipeating ctl to new ax25_dev structs. 64 * Fixed ax25_release(), set TCP_CLOSE, wakeup app 65 * context, THEN make the sock dead. 66 * Alan(GW4PTS) Cleaned up for single recvmsg methods. 67 * Alan(GW4PTS) Fixed not clearing error on connect failure. 68 * AX.25 031 Jonathan(G4KLX) Added binding to any device. 69 * Joerg(DL1BKE) Added DAMA support, fixed (?) digipeating, fixed buffer locking 70 * for "virtual connect" mode... Result: Probably the 71 * "Most Buggiest Code You've Ever Seen" (TM) 72 * HaJo(DD8NE) Implementation of a T5 (idle) timer 73 * Joerg(DL1BKE) Renamed T5 to IDLE and changed behaviour: 74 * the timer gets reloaded on every received or transmitted 75 * I frame for IP or NETROM. The idle timer is not active 76 * on "vanilla AX.25" connections. Furthermore added PACLEN 77 * to provide AX.25-layer based fragmentation (like WAMPES) 78 * AX.25 032 Joerg(DL1BKE) Fixed DAMA timeout error. 79 * ax25_send_frame() limits the number of enqueued 80 * datagrams per socket. 81 * AX.25 033 Jonathan(G4KLX) Removed auto-router. 82 * Hans(PE1AYX) Converted to Module. 83 * Joerg(DL1BKE) Moved BPQ Ethernet to separate driver. 84 * AX.25 034 Jonathan(G4KLX) 2.1 changes 85 * Alan(GW4PTS) Small POSIXisations 86 * AX.25 035 Alan(GW4PTS) Started fixing to the new 87 * format. 88 * Hans(PE1AYX) Fixed interface to IP layer. 89 * Alan(GW4PTS) Added asynchronous support. 90 * Frederic(F1OAT) Support for pseudo-digipeating. 91 * Jonathan(G4KLX) Support for packet forwarding. 92 * AX.25 036 Jonathan(G4KLX) Major restructuring. 93 * Joerg(DL1BKE) Fixed DAMA Slave. 94 * Jonathan(G4KLX) Fix wildcard listen parameter setting. 95 * AX.25 037 Jonathan(G4KLX) New timer architecture. 96 * AX.25 038 Matthias(DG2FEF) Small fixes to the syscall interface to make kernel 97 * independent of AX25_MAX_DIGIS used by applications. 98 * Tomi(OH2BNS) Fixed ax25_getname(). 99 * Joerg(DL1BKE) Starting to phase out the support for full_sockaddr_ax25 100 * with only 6 digipeaters and sockaddr_ax25 in ax25_bind(), 101 * ax25_connect() and ax25_sendmsg() 102 * Joerg(DL1BKE) Added support for SO_BINDTODEVICE 103 * Arnaldo C. Melo s/suser/capable(CAP_NET_ADMIN)/, some more cleanups 104 * Michal Ostrowski Module initialization cleanup. 105 * Jeroen(PE1RXQ) Use sock_orphan() on release. 106 */ 107 108#include <linux/config.h> 109#include <linux/module.h> 110#include <linux/errno.h> 111#include <linux/types.h> 112#include <linux/socket.h> 113#include <linux/in.h> 114#include <linux/kernel.h> 115#include <linux/sched.h> 116#include <linux/timer.h> 117#include <linux/string.h> 118#include <linux/sockios.h> 119#include <linux/net.h> 120#include <net/ax25.h> 121#include <linux/inet.h> 122#include <linux/netdevice.h> 123#include <linux/if_arp.h> 124#include <linux/skbuff.h> 125#include <net/sock.h> 126#include <asm/uaccess.h> 127#include <asm/system.h> 128#include <linux/fcntl.h> 129#include <linux/termios.h> /* For TIOCINQ/OUTQ */ 130#include <linux/mm.h> 131#include <linux/interrupt.h> 132#include <linux/notifier.h> 133#include <linux/proc_fs.h> 134#include <linux/stat.h> 135#include <linux/netfilter.h> 136#include <linux/sysctl.h> 137#include <linux/init.h> 138#include <net/ip.h> 139#include <net/arp.h> 140 141 142 143ax25_cb *volatile ax25_list; 144 145static struct proto_ops ax25_proto_ops; 146 147/* 148 * Free an allocated ax25 control block. This is done to centralise 149 * the MOD count code. 150 */ 151void ax25_free_cb(ax25_cb *ax25) 152{ 153 if (ax25->digipeat != NULL) { 154 kfree(ax25->digipeat); 155 ax25->digipeat = NULL; 156 } 157 158 kfree(ax25); 159 160 MOD_DEC_USE_COUNT; 161} 162 163static void ax25_free_sock(struct sock *sk) 164{ 165 ax25_free_cb(sk->protinfo.ax25); 166} 167 168/* 169 * Socket removal during an interrupt is now safe. 170 */ 171static void ax25_remove_socket(ax25_cb *ax25) 172{ 173 ax25_cb *s; 174 unsigned long flags; 175 176 save_flags(flags); cli(); 177 178 if ((s = ax25_list) == ax25) { 179 ax25_list = s->next; 180 restore_flags(flags); 181 return; 182 } 183 184 while (s != NULL && s->next != NULL) { 185 if (s->next == ax25) { 186 s->next = ax25->next; 187 restore_flags(flags); 188 return; 189 } 190 191 s = s->next; 192 } 193 194 restore_flags(flags); 195} 196 197/* 198 * Kill all bound sockets on a dropped device. 199 */ 200static void ax25_kill_by_device(struct net_device *dev) 201{ 202 ax25_dev *ax25_dev; 203 ax25_cb *s; 204 205 if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL) 206 return; 207 208 for (s = ax25_list; s != NULL; s = s->next) { 209 if (s->ax25_dev == ax25_dev) { 210 s->ax25_dev = NULL; 211 ax25_disconnect(s, ENETUNREACH); 212 } 213 } 214} 215 216/* 217 * Handle device status changes. 218 */ 219static int ax25_device_event(struct notifier_block *this,unsigned long event, void *ptr) 220{ 221 struct net_device *dev = (struct net_device *)ptr; 222 223 /* Reject non AX.25 devices */ 224 if (dev->type != ARPHRD_AX25) 225 return NOTIFY_DONE; 226 227 switch (event) { 228 case NETDEV_UP: 229 ax25_dev_device_up(dev); 230 break; 231 case NETDEV_DOWN: 232 ax25_kill_by_device(dev); 233 ax25_rt_device_down(dev); 234 ax25_dev_device_down(dev); 235 break; 236 default: 237 break; 238 } 239 240 return NOTIFY_DONE; 241} 242 243/* 244 * Add a socket to the bound sockets list. 245 */ 246void ax25_insert_socket(ax25_cb *ax25) 247{ 248 unsigned long flags; 249 250 save_flags(flags); 251 cli(); 252 253 ax25->next = ax25_list; 254 ax25_list = ax25; 255 256 restore_flags(flags); 257} 258 259/* 260 * Find a socket that wants to accept the SABM we have just 261 * received. 262 */ 263struct sock *ax25_find_listener(ax25_address *addr, int digi, struct net_device *dev, int type) 264{ 265 unsigned long flags; 266 ax25_cb *s; 267 268 save_flags(flags); 269 cli(); 270 271 for (s = ax25_list; s != NULL; s = s->next) { 272 if ((s->iamdigi && !digi) || (!s->iamdigi && digi)) 273 continue; 274 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 && s->sk->type == type && s->sk->state == TCP_LISTEN) { 275 /* If device is null we match any device */ 276 if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) { 277 restore_flags(flags); 278 return s->sk; 279 } 280 } 281 } 282 283 restore_flags(flags); 284 return NULL; 285} 286 287/* 288 * Find an AX.25 socket given both ends. 289 */ 290struct sock *ax25_find_socket(ax25_address *my_addr, ax25_address *dest_addr, int type) 291{ 292 ax25_cb *s; 293 unsigned long flags; 294 295 save_flags(flags); 296 cli(); 297 298 for (s = ax25_list; s != NULL; s = s->next) { 299 if (s->sk != NULL && ax25cmp(&s->source_addr, my_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->sk->type == type) { 300 restore_flags(flags); 301 return s->sk; 302 } 303 } 304 305 restore_flags(flags); 306 307 return NULL; 308} 309 310/* 311 * Find an AX.25 control block given both ends. It will only pick up 312 * floating AX.25 control blocks or non Raw socket bound control blocks. 313 */ 314ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr, ax25_digi *digi, struct net_device *dev) 315{ 316 ax25_cb *s; 317 unsigned long flags; 318 319 save_flags(flags); 320 cli(); 321 322 for (s = ax25_list; s != NULL; s = s->next) { 323 if (s->sk != NULL && s->sk->type != SOCK_SEQPACKET) 324 continue; 325 if (s->ax25_dev == NULL) 326 continue; 327 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) { 328 if (digi != NULL && digi->ndigi != 0) { 329 if (s->digipeat == NULL) 330 continue; 331 if (ax25digicmp(s->digipeat, digi) != 0) 332 continue; 333 } else { 334 if (s->digipeat != NULL && s->digipeat->ndigi != 0) 335 continue; 336 } 337 restore_flags(flags); 338 return s; 339 } 340 } 341 342 restore_flags(flags); 343 344 return NULL; 345} 346 347/* 348 * Look for any matching address - RAW sockets can bind to arbitrary names 349 */ 350struct sock *ax25_addr_match(ax25_address *addr) 351{ 352 unsigned long flags; 353 ax25_cb *s; 354 355 save_flags(flags); 356 cli(); 357 358 for (s = ax25_list; s != NULL; s = s->next) { 359 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 && s->sk->type == SOCK_RAW) { 360 restore_flags(flags); 361 return s->sk; 362 } 363 } 364 365 restore_flags(flags); 366 367 return NULL; 368} 369 370void ax25_send_to_raw(struct sock *sk, struct sk_buff *skb, int proto) 371{ 372 struct sk_buff *copy; 373 374 while (sk != NULL) { 375 if (sk->type == SOCK_RAW && 376 sk->protocol == proto && 377 atomic_read(&sk->rmem_alloc) <= sk->rcvbuf) { 378 if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL) 379 return; 380 381 if (sock_queue_rcv_skb(sk, copy) != 0) 382 kfree_skb(copy); 383 } 384 385 sk = sk->next; 386 } 387} 388 389/* 390 * Deferred destroy. 391 */ 392void ax25_destroy_socket(ax25_cb *); 393 394/* 395 * Handler for deferred kills. 396 */ 397static void ax25_destroy_timer(unsigned long data) 398{ 399 ax25_destroy_socket((ax25_cb *)data); 400} 401 402/* 403 * This is called from user mode and the timers. Thus it protects itself against 404 * interrupt users but doesn't worry about being called during work. 405 * Once it is removed from the queue no interrupt or bottom half will 406 * touch it and we are (fairly 8-) ) safe. 407 */ 408void ax25_destroy_socket(ax25_cb *ax25) /* Not static as it's used by the timer */ 409{ 410 struct sk_buff *skb; 411 unsigned long flags; 412 413 save_flags(flags); cli(); 414 415 ax25_stop_heartbeat(ax25); 416 ax25_stop_t1timer(ax25); 417 ax25_stop_t2timer(ax25); 418 ax25_stop_t3timer(ax25); 419 ax25_stop_idletimer(ax25); 420 421 ax25_remove_socket(ax25); 422 ax25_clear_queues(ax25); /* Flush the queues */ 423 424 if (ax25->sk != NULL) { 425 while ((skb = skb_dequeue(&ax25->sk->receive_queue)) != NULL) { 426 if (skb->sk != ax25->sk) { /* A pending connection */ 427 skb->sk->dead = 1; /* Queue the unaccepted socket for death */ 428 ax25_start_heartbeat(skb->sk->protinfo.ax25); 429 skb->sk->protinfo.ax25->state = AX25_STATE_0; 430 } 431 432 kfree_skb(skb); 433 } 434 } 435 436 if (ax25->sk != NULL) { 437 if (atomic_read(&ax25->sk->wmem_alloc) != 0 || 438 atomic_read(&ax25->sk->rmem_alloc) != 0) { 439 /* Defer: outstanding buffers */ 440 init_timer(&ax25->timer); 441 ax25->timer.expires = jiffies + 10 * HZ; 442 ax25->timer.function = ax25_destroy_timer; 443 ax25->timer.data = (unsigned long)ax25; 444 add_timer(&ax25->timer); 445 } else { 446 sk_free(ax25->sk); 447 } 448 } else { 449 ax25_free_cb(ax25); 450 } 451 452 restore_flags(flags); 453} 454 455/* 456 * dl1bke 960311: set parameters for existing AX.25 connections, 457 * includes a KILL command to abort any connection. 458 * VERY useful for debugging ;-) 459 */ 460static int ax25_ctl_ioctl(const unsigned int cmd, void *arg) 461{ 462 struct ax25_ctl_struct ax25_ctl; 463 ax25_digi digi; 464 ax25_dev *ax25_dev; 465 ax25_cb *ax25; 466 unsigned int k; 467 468 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl))) 469 return -EFAULT; 470 471 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL) 472 return -ENODEV; 473 474 if (ax25_ctl.digi_count > AX25_MAX_DIGIS) 475 return -EINVAL; 476 477 digi.ndigi = ax25_ctl.digi_count; 478 for (k = 0; k < digi.ndigi; k++) 479 digi.calls[k] = ax25_ctl.digi_addr[k]; 480 481 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL) 482 return -ENOTCONN; 483 484 switch (ax25_ctl.cmd) { 485 case AX25_KILL: 486 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND); 487#ifdef CONFIG_AX25_DAMA_SLAVE 488 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE) 489 ax25_dama_off(ax25); 490#endif 491 ax25_disconnect(ax25, ENETRESET); 492 break; 493 494 case AX25_WINDOW: 495 if (ax25->modulus == AX25_MODULUS) { 496 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7) 497 return -EINVAL; 498 } else { 499 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63) 500 return -EINVAL; 501 } 502 ax25->window = ax25_ctl.arg; 503 break; 504 505 case AX25_T1: 506 if (ax25_ctl.arg < 1) 507 return -EINVAL; 508 ax25->rtt = (ax25_ctl.arg * HZ) / 2; 509 ax25->t1 = ax25_ctl.arg * HZ; 510 break; 511 512 case AX25_T2: 513 if (ax25_ctl.arg < 1) 514 return -EINVAL; 515 ax25->t2 = ax25_ctl.arg * HZ; 516 break; 517 518 case AX25_N2: 519 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31) 520 return -EINVAL; 521 ax25->n2count = 0; 522 ax25->n2 = ax25_ctl.arg; 523 break; 524 525 case AX25_T3: 526 if (ax25_ctl.arg < 0) 527 return -EINVAL; 528 ax25->t3 = ax25_ctl.arg * HZ; 529 break; 530 531 case AX25_IDLE: 532 if (ax25_ctl.arg < 0) 533 return -EINVAL; 534 ax25->idle = ax25_ctl.arg * 60 * HZ; 535 break; 536 537 case AX25_PACLEN: 538 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535) 539 return -EINVAL; 540 ax25->paclen = ax25_ctl.arg; 541 break; 542 543 default: 544 return -EINVAL; 545 } 546 547 return 0; 548} 549 550/* 551 * Fill in a created AX.25 created control block with the default 552 * values for a particular device. 553 */ 554void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev) 555{ 556 ax25->ax25_dev = ax25_dev; 557 558 if (ax25->ax25_dev != NULL) { 559 ax25->rtt = ax25_dev->values[AX25_VALUES_T1] / 2; 560 ax25->t1 = ax25_dev->values[AX25_VALUES_T1]; 561 ax25->t2 = ax25_dev->values[AX25_VALUES_T2]; 562 ax25->t3 = ax25_dev->values[AX25_VALUES_T3]; 563 ax25->n2 = ax25_dev->values[AX25_VALUES_N2]; 564 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN]; 565 ax25->idle = ax25_dev->values[AX25_VALUES_IDLE]; 566 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF]; 567 568 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) { 569 ax25->modulus = AX25_EMODULUS; 570 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW]; 571 } else { 572 ax25->modulus = AX25_MODULUS; 573 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW]; 574 } 575 } else { 576 ax25->rtt = AX25_DEF_T1 / 2; 577 ax25->t1 = AX25_DEF_T1; 578 ax25->t2 = AX25_DEF_T2; 579 ax25->t3 = AX25_DEF_T3; 580 ax25->n2 = AX25_DEF_N2; 581 ax25->paclen = AX25_DEF_PACLEN; 582 ax25->idle = AX25_DEF_IDLE; 583 ax25->backoff = AX25_DEF_BACKOFF; 584 585 if (AX25_DEF_AXDEFMODE) { 586 ax25->modulus = AX25_EMODULUS; 587 ax25->window = AX25_DEF_EWINDOW; 588 } else { 589 ax25->modulus = AX25_MODULUS; 590 ax25->window = AX25_DEF_WINDOW; 591 } 592 } 593} 594 595/* 596 * Create an empty AX.25 control block. 597 */ 598ax25_cb *ax25_create_cb(void) 599{ 600 ax25_cb *ax25; 601 602 if ((ax25 = kmalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL) 603 return NULL; 604 605 MOD_INC_USE_COUNT; 606 607 memset(ax25, 0x00, sizeof(*ax25)); 608 609 skb_queue_head_init(&ax25->write_queue); 610 skb_queue_head_init(&ax25->frag_queue); 611 skb_queue_head_init(&ax25->ack_queue); 612 skb_queue_head_init(&ax25->reseq_queue); 613 614 init_timer(&ax25->timer); 615 init_timer(&ax25->t1timer); 616 init_timer(&ax25->t2timer); 617 init_timer(&ax25->t3timer); 618 init_timer(&ax25->idletimer); 619 620 ax25_fillin_cb(ax25, NULL); 621 622 ax25->state = AX25_STATE_0; 623 624 return ax25; 625} 626 627/* 628 * Handling for system calls applied via the various interfaces to an 629 * AX25 socket object 630 */ 631 632static int ax25_setsockopt(struct socket *sock, int level, int optname, char *optval, int optlen) 633{ 634 struct sock *sk = sock->sk; 635 struct net_device *dev; 636 char devname[IFNAMSIZ]; 637 int opt; 638 639 if (level != SOL_AX25) 640 return -ENOPROTOOPT; 641 642 if (optlen < sizeof(int)) 643 return -EINVAL; 644 645 if (get_user(opt, (int *)optval)) 646 return -EFAULT; 647 648 switch (optname) { 649 case AX25_WINDOW: 650 if (sk->protinfo.ax25->modulus == AX25_MODULUS) { 651 if (opt < 1 || opt > 7) 652 return -EINVAL; 653 } else { 654 if (opt < 1 || opt > 63) 655 return -EINVAL; 656 } 657 sk->protinfo.ax25->window = opt; 658 return 0; 659 660 case AX25_T1: 661 if (opt < 1) 662 return -EINVAL; 663 sk->protinfo.ax25->rtt = (opt * HZ) / 2; 664 sk->protinfo.ax25->t1 = opt * HZ; 665 return 0; 666 667 case AX25_T2: 668 if (opt < 1) 669 return -EINVAL; 670 sk->protinfo.ax25->t2 = opt * HZ; 671 return 0; 672 673 case AX25_N2: 674 if (opt < 1 || opt > 31) 675 return -EINVAL; 676 sk->protinfo.ax25->n2 = opt; 677 return 0; 678 679 case AX25_T3: 680 if (opt < 1) 681 return -EINVAL; 682 sk->protinfo.ax25->t3 = opt * HZ; 683 return 0; 684 685 case AX25_IDLE: 686 if (opt < 0) 687 return -EINVAL; 688 sk->protinfo.ax25->idle = opt * 60 * HZ; 689 return 0; 690 691 case AX25_BACKOFF: 692 if (opt < 0 || opt > 2) 693 return -EINVAL; 694 sk->protinfo.ax25->backoff = opt; 695 return 0; 696 697 case AX25_EXTSEQ: 698 sk->protinfo.ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS; 699 return 0; 700 701 case AX25_PIDINCL: 702 sk->protinfo.ax25->pidincl = opt ? 1 : 0; 703 return 0; 704 705 case AX25_IAMDIGI: 706 sk->protinfo.ax25->iamdigi = opt ? 1 : 0; 707 return 0; 708 709 case AX25_PACLEN: 710 if (opt < 16 || opt > 65535) 711 return -EINVAL; 712 sk->protinfo.ax25->paclen = opt; 713 return 0; 714 715 case SO_BINDTODEVICE: 716 if (optlen > IFNAMSIZ) optlen=IFNAMSIZ; 717 if (copy_from_user(devname, optval, optlen)) 718 return -EFAULT; 719 720 dev = dev_get_by_name(devname); 721 if (dev == NULL) return -ENODEV; 722 723 if (sk->type == SOCK_SEQPACKET && 724 (sock->state != SS_UNCONNECTED || sk->state == TCP_LISTEN)) 725 return -EADDRNOTAVAIL; 726 727 sk->protinfo.ax25->ax25_dev = ax25_dev_ax25dev(dev); 728 ax25_fillin_cb(sk->protinfo.ax25, sk->protinfo.ax25->ax25_dev); 729 return 0; 730 731 default: 732 return -ENOPROTOOPT; 733 } 734} 735 736static int ax25_getsockopt(struct socket *sock, int level, int optname, char *optval, int *optlen) 737{ 738 struct sock *sk = sock->sk; 739 struct ax25_dev *ax25_dev; 740 char devname[IFNAMSIZ]; 741 void *valptr; 742 int val = 0; 743 int maxlen, length; 744 745 if (level != SOL_AX25) 746 return -ENOPROTOOPT; 747 748 if (get_user(maxlen, optlen)) 749 return -EFAULT; 750 751 if (maxlen < 1) 752 return -EFAULT; 753 754 valptr = (void *) &val; 755 length = min_t(unsigned int, maxlen, sizeof(int)); 756 757 switch (optname) { 758 case AX25_WINDOW: 759 val = sk->protinfo.ax25->window; 760 break; 761 762 case AX25_T1: 763 val = sk->protinfo.ax25->t1 / HZ; 764 break; 765 766 case AX25_T2: 767 val = sk->protinfo.ax25->t2 / HZ; 768 break; 769 770 case AX25_N2: 771 val = sk->protinfo.ax25->n2; 772 break; 773 774 case AX25_T3: 775 val = sk->protinfo.ax25->t3 / HZ; 776 break; 777 778 case AX25_IDLE: 779 val = sk->protinfo.ax25->idle / (60 * HZ); 780 break; 781 782 case AX25_BACKOFF: 783 val = sk->protinfo.ax25->backoff; 784 break; 785 786 case AX25_EXTSEQ: 787 val = (sk->protinfo.ax25->modulus == AX25_EMODULUS); 788 break; 789 790 case AX25_PIDINCL: 791 val = sk->protinfo.ax25->pidincl; 792 break; 793 794 case AX25_IAMDIGI: 795 val = sk->protinfo.ax25->iamdigi; 796 break; 797 798 case AX25_PACLEN: 799 val = sk->protinfo.ax25->paclen; 800 break; 801 802 case SO_BINDTODEVICE: 803 ax25_dev = sk->protinfo.ax25->ax25_dev; 804 805 if (ax25_dev != NULL && ax25_dev->dev != NULL) { 806 strncpy(devname, ax25_dev->dev->name, IFNAMSIZ); 807 length = min_t(unsigned int, strlen(ax25_dev->dev->name)+1, maxlen); 808 devname[length-1] = '\0'; 809 } else { 810 *devname = '\0'; 811 length = 1; 812 } 813 814 valptr = (void *) devname; 815 break; 816 817 default: 818 return -ENOPROTOOPT; 819 } 820 821 if (put_user(length, optlen)) 822 return -EFAULT; 823 824 return copy_to_user(optval, valptr, length) ? -EFAULT : 0; 825} 826 827static int ax25_listen(struct socket *sock, int backlog) 828{ 829 struct sock *sk = sock->sk; 830 831 if (sk->type == SOCK_SEQPACKET && sk->state != TCP_LISTEN) { 832 sk->max_ack_backlog = backlog; 833 sk->state = TCP_LISTEN; 834 return 0; 835 } 836 837 return -EOPNOTSUPP; 838} 839 840int ax25_create(struct socket *sock, int protocol) 841{ 842 struct sock *sk; 843 ax25_cb *ax25; 844 845 switch (sock->type) { 846 case SOCK_DGRAM: 847 if (protocol == 0 || protocol == PF_AX25) 848 protocol = AX25_P_TEXT; 849 break; 850 case SOCK_SEQPACKET: 851 switch (protocol) { 852 case 0: 853 case PF_AX25: /* For CLX */ 854 protocol = AX25_P_TEXT; 855 break; 856 case AX25_P_SEGMENT: 857#ifdef CONFIG_INET 858 case AX25_P_ARP: 859 case AX25_P_IP: 860#endif 861#ifdef CONFIG_NETROM 862 case AX25_P_NETROM: 863#endif 864#ifdef CONFIG_ROSE 865 case AX25_P_ROSE: 866#endif 867 return -ESOCKTNOSUPPORT; 868#ifdef CONFIG_NETROM_MODULE 869 case AX25_P_NETROM: 870 if (ax25_protocol_is_registered(AX25_P_NETROM)) 871 return -ESOCKTNOSUPPORT; 872#endif 873#ifdef CONFIG_ROSE_MODULE 874 case AX25_P_ROSE: 875 if (ax25_protocol_is_registered(AX25_P_ROSE)) 876 return -ESOCKTNOSUPPORT; 877#endif 878 default: 879 break; 880 } 881 break; 882 case SOCK_RAW: 883 break; 884 default: 885 return -ESOCKTNOSUPPORT; 886 } 887 888 if ((sk = sk_alloc(PF_AX25, GFP_ATOMIC, 1)) == NULL) 889 return -ENOMEM; 890 891 if ((ax25 = ax25_create_cb()) == NULL) { 892 sk_free(sk); 893 return -ENOMEM; 894 } 895 896 sock_init_data(sock, sk); 897 898 sk->destruct = ax25_free_sock; 899 sock->ops = &ax25_proto_ops; 900 sk->protocol = protocol; 901 902 ax25->sk = sk; 903 sk->protinfo.ax25 = ax25; 904 905 return 0; 906} 907 908struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev) 909{ 910 struct sock *sk; 911 ax25_cb *ax25; 912 913 if ((sk = sk_alloc(PF_AX25, GFP_ATOMIC, 1)) == NULL) 914 return NULL; 915 916 if ((ax25 = ax25_create_cb()) == NULL) { 917 sk_free(sk); 918 return NULL; 919 } 920 921 switch (osk->type) { 922 case SOCK_DGRAM: 923 break; 924 case SOCK_SEQPACKET: 925 break; 926 default: 927 sk_free(sk); 928 ax25_free_cb(ax25); 929 return NULL; 930 } 931 932 sock_init_data(NULL, sk); 933 934 sk->destruct = ax25_free_sock; 935 sk->type = osk->type; 936 sk->socket = osk->socket; 937 sk->priority = osk->priority; 938 sk->protocol = osk->protocol; 939 sk->rcvbuf = osk->rcvbuf; 940 sk->sndbuf = osk->sndbuf; 941 sk->debug = osk->debug; 942 sk->state = TCP_ESTABLISHED; 943 sk->sleep = osk->sleep; 944 sk->zapped = osk->zapped; 945 946 ax25->modulus = osk->protinfo.ax25->modulus; 947 ax25->backoff = osk->protinfo.ax25->backoff; 948 ax25->pidincl = osk->protinfo.ax25->pidincl; 949 ax25->iamdigi = osk->protinfo.ax25->iamdigi; 950 ax25->rtt = osk->protinfo.ax25->rtt; 951 ax25->t1 = osk->protinfo.ax25->t1; 952 ax25->t2 = osk->protinfo.ax25->t2; 953 ax25->t3 = osk->protinfo.ax25->t3; 954 ax25->n2 = osk->protinfo.ax25->n2; 955 ax25->idle = osk->protinfo.ax25->idle; 956 ax25->paclen = osk->protinfo.ax25->paclen; 957 ax25->window = osk->protinfo.ax25->window; 958 959 ax25->ax25_dev = ax25_dev; 960 ax25->source_addr = osk->protinfo.ax25->source_addr; 961 962 if (osk->protinfo.ax25->digipeat != NULL) { 963 if ((ax25->digipeat = kmalloc(sizeof(ax25_digi), GFP_ATOMIC)) == NULL) { 964 sk_free(sk); 965 return NULL; 966 } 967 968 memcpy(ax25->digipeat, osk->protinfo.ax25->digipeat, sizeof(ax25_digi)); 969 } 970 971 sk->protinfo.ax25 = ax25; 972 ax25->sk = sk; 973 974 return sk; 975} 976 977static int ax25_release(struct socket *sock) 978{ 979 struct sock *sk = sock->sk; 980 981 if (sk == NULL) return 0; 982 983 if (sk->type == SOCK_SEQPACKET) { 984 switch (sk->protinfo.ax25->state) { 985 case AX25_STATE_0: 986 ax25_disconnect(sk->protinfo.ax25, 0); 987 ax25_destroy_socket(sk->protinfo.ax25); 988 break; 989 990 case AX25_STATE_1: 991 case AX25_STATE_2: 992 ax25_send_control(sk->protinfo.ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND); 993 ax25_disconnect(sk->protinfo.ax25, 0); 994 ax25_destroy_socket(sk->protinfo.ax25); 995 break; 996 997 case AX25_STATE_3: 998 case AX25_STATE_4: 999 ax25_clear_queues(sk->protinfo.ax25); 1000 sk->protinfo.ax25->n2count = 0; 1001 switch (sk->protinfo.ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) { 1002 case AX25_PROTO_STD_SIMPLEX: 1003 case AX25_PROTO_STD_DUPLEX: 1004 ax25_send_control(sk->protinfo.ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND); 1005 ax25_stop_t2timer(sk->protinfo.ax25); 1006 ax25_stop_t3timer(sk->protinfo.ax25); 1007 ax25_stop_idletimer(sk->protinfo.ax25); 1008 break; 1009#ifdef CONFIG_AX25_DAMA_SLAVE 1010 case AX25_PROTO_DAMA_SLAVE: 1011 ax25_stop_t3timer(sk->protinfo.ax25); 1012 ax25_stop_idletimer(sk->protinfo.ax25); 1013 break; 1014#endif 1015 } 1016 ax25_calculate_t1(sk->protinfo.ax25); 1017 ax25_start_t1timer(sk->protinfo.ax25); 1018 sk->protinfo.ax25->state = AX25_STATE_2; 1019 sk->state = TCP_CLOSE; 1020 sk->shutdown |= SEND_SHUTDOWN; 1021 sk->state_change(sk); 1022 sock_orphan(sk); 1023 sk->destroy = 1; 1024 break; 1025 1026 default: 1027 break; 1028 } 1029 } else { 1030 sk->state = TCP_CLOSE; 1031 sk->shutdown |= SEND_SHUTDOWN; 1032 sk->state_change(sk); 1033 sock_orphan(sk); 1034 ax25_destroy_socket(sk->protinfo.ax25); 1035 } 1036 1037 sock->sk = NULL; 1038 sk->socket = NULL; /* Not used, but we should do this */ 1039 1040 return 0; 1041} 1042 1043/* 1044 * We support a funny extension here so you can (as root) give any callsign 1045 * digipeated via a local address as source. This hack is obsolete now 1046 * that we've implemented support for SO_BINDTODEVICE. It is however small 1047 * and trivially backward compatible. 1048 */ 1049static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) 1050{ 1051 struct sock *sk = sock->sk; 1052 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr; 1053 ax25_address *call; 1054 ax25_dev *ax25_dev = NULL; 1055 1056 if (sk->zapped == 0) 1057 return -EINVAL; 1058 1059 if (addr_len != sizeof(struct sockaddr_ax25) && 1060 addr_len != sizeof(struct full_sockaddr_ax25)) { 1061 /* support for old structure may go away some time */ 1062 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) || 1063 (addr_len > sizeof(struct full_sockaddr_ax25))) 1064 return -EINVAL; 1065 1066 printk(KERN_WARNING "ax25_bind(): %s uses old (6 digipeater) socket structure.\n", 1067 current->comm); 1068 } 1069 1070 if (addr->fsa_ax25.sax25_family != AF_AX25) 1071 return -EINVAL; 1072 1073 call = ax25_findbyuid(current->euid); 1074 if (call == NULL && ax25_uid_policy && !capable(CAP_NET_ADMIN)) 1075 return -EACCES; 1076 1077 if (call == NULL) 1078 sk->protinfo.ax25->source_addr = addr->fsa_ax25.sax25_call; 1079 else 1080 sk->protinfo.ax25->source_addr = *call; 1081 1082 /* 1083 * User already set interface with SO_BINDTODEVICE 1084 */ 1085 1086 if (sk->protinfo.ax25->ax25_dev != NULL) 1087 goto done; 1088 1089 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) { 1090 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 && 1091 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) 1092 return -EADDRNOTAVAIL; 1093 } else { 1094 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) 1095 return -EADDRNOTAVAIL; 1096 } 1097 1098 if (ax25_dev != NULL) 1099 ax25_fillin_cb(sk->protinfo.ax25, ax25_dev); 1100 1101done: 1102 ax25_insert_socket(sk->protinfo.ax25); 1103 sk->zapped = 0; 1104 return 0; 1105} 1106 1107static int ax25_connect(struct socket *sock, struct sockaddr *uaddr, int addr_len, int flags) 1108{ 1109 struct sock *sk = sock->sk; 1110 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr; 1111 ax25_digi *digi = NULL; 1112 int ct = 0, err; 1113 1114 /* deal with restarts */ 1115 if (sock->state == SS_CONNECTING) { 1116 switch (sk->state) { 1117 case TCP_SYN_SENT: /* still trying */ 1118 return -EINPROGRESS; 1119 1120 case TCP_ESTABLISHED: /* connection established */ 1121 sock->state = SS_CONNECTED; 1122 return 0; 1123 1124 case TCP_CLOSE: /* connection refused */ 1125 sock->state = SS_UNCONNECTED; 1126 return -ECONNREFUSED; 1127 } 1128 } 1129 1130 if (sk->state == TCP_ESTABLISHED && sk->type == SOCK_SEQPACKET) 1131 return -EISCONN; /* No reconnect on a seqpacket socket */ 1132 1133 sk->state = TCP_CLOSE; 1134 sock->state = SS_UNCONNECTED; 1135 1136 /* 1137 * some sanity checks. code further down depends on this 1138 */ 1139 1140 if (addr_len == sizeof(struct sockaddr_ax25)) { 1141 /* support for this will go away in early 2.5.x */ 1142 printk(KERN_WARNING "ax25_connect(): %s uses obsolete socket structure\n", 1143 current->comm); 1144 } 1145 else if (addr_len != sizeof(struct full_sockaddr_ax25)) { 1146 /* support for old structure may go away some time */ 1147 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) || 1148 (addr_len > sizeof(struct full_sockaddr_ax25))) 1149 return -EINVAL; 1150 1151 printk(KERN_WARNING "ax25_connect(): %s uses old (6 digipeater) socket structure.\n", 1152 current->comm); 1153 } 1154 1155 if (fsa->fsa_ax25.sax25_family != AF_AX25) 1156 return -EINVAL; 1157 1158 if (sk->protinfo.ax25->digipeat != NULL) { 1159 kfree(sk->protinfo.ax25->digipeat); 1160 sk->protinfo.ax25->digipeat = NULL; 1161 } 1162 1163 /* 1164 * Handle digi-peaters to be used. 1165 */ 1166 if (addr_len > sizeof(struct sockaddr_ax25) && fsa->fsa_ax25.sax25_ndigis != 0) { 1167 /* Valid number of digipeaters ? */ 1168 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) 1169 return -EINVAL; 1170 1171 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) 1172 return -ENOBUFS; 1173 1174 digi->ndigi = fsa->fsa_ax25.sax25_ndigis; 1175 digi->lastrepeat = -1; 1176 1177 while (ct < fsa->fsa_ax25.sax25_ndigis) { 1178 if ((fsa->fsa_digipeater[ct].ax25_call[6] & AX25_HBIT) && sk->protinfo.ax25->iamdigi) { 1179 digi->repeated[ct] = 1; 1180 digi->lastrepeat = ct; 1181 } else { 1182 digi->repeated[ct] = 0; 1183 } 1184 digi->calls[ct] = fsa->fsa_digipeater[ct]; 1185 ct++; 1186 } 1187 } 1188 1189 /* 1190 * Must bind first - autobinding in this may or may not work. If 1191 * the socket is already bound, check to see if the device has 1192 * been filled in, error if it hasn't. 1193 */ 1194 if (sk->zapped) { 1195 /* check if we can remove this feature. It is broken. */ 1196 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n", 1197 current->comm); 1198 if ((err = ax25_rt_autobind(sk->protinfo.ax25, &fsa->fsa_ax25.sax25_call)) < 0) 1199 return err; 1200 ax25_fillin_cb(sk->protinfo.ax25, sk->protinfo.ax25->ax25_dev); 1201 ax25_insert_socket(sk->protinfo.ax25); 1202 } else { 1203 if (sk->protinfo.ax25->ax25_dev == NULL) 1204 return -EHOSTUNREACH; 1205 } 1206 1207 if (sk->type == SOCK_SEQPACKET && ax25_find_cb(&sk->protinfo.ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi, sk->protinfo.ax25->ax25_dev->dev) != NULL) { 1208 if (digi != NULL) kfree(digi); 1209 return -EADDRINUSE; /* Already such a connection */ 1210 } 1211 1212 sk->protinfo.ax25->dest_addr = fsa->fsa_ax25.sax25_call; 1213 sk->protinfo.ax25->digipeat = digi; 1214 1215 /* First the easy one */ 1216 if (sk->type != SOCK_SEQPACKET) { 1217 sock->state = SS_CONNECTED; 1218 sk->state = TCP_ESTABLISHED; 1219 return 0; 1220 } 1221 1222 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */ 1223 sock->state = SS_CONNECTING; 1224 sk->state = TCP_SYN_SENT; 1225 1226 switch (sk->protinfo.ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) { 1227 case AX25_PROTO_STD_SIMPLEX: 1228 case AX25_PROTO_STD_DUPLEX: 1229 ax25_std_establish_data_link(sk->protinfo.ax25); 1230 break; 1231 1232#ifdef CONFIG_AX25_DAMA_SLAVE 1233 case AX25_PROTO_DAMA_SLAVE: 1234 sk->protinfo.ax25->modulus = AX25_MODULUS; 1235 sk->protinfo.ax25->window = sk->protinfo.ax25->ax25_dev->values[AX25_VALUES_WINDOW]; 1236 if (sk->protinfo.ax25->ax25_dev->dama.slave) 1237 ax25_ds_establish_data_link(sk->protinfo.ax25); 1238 else 1239 ax25_std_establish_data_link(sk->protinfo.ax25); 1240 break; 1241#endif 1242 } 1243 1244 sk->protinfo.ax25->state = AX25_STATE_1; 1245 1246 ax25_start_heartbeat(sk->protinfo.ax25); 1247 1248 /* Now the loop */ 1249 if (sk->state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) 1250 return -EINPROGRESS; 1251 1252 cli(); /* To avoid races on the sleep */ 1253 1254 /* A DM or timeout will go to closed, a UA will go to ABM */ 1255 while (sk->state == TCP_SYN_SENT) { 1256 interruptible_sleep_on(sk->sleep); 1257 if (signal_pending(current)) { 1258 sti(); 1259 return -ERESTARTSYS; 1260 } 1261 } 1262 1263 if (sk->state != TCP_ESTABLISHED) { 1264 /* Not in ABM, not in WAIT_UA -> failed */ 1265 sti(); 1266 sock->state = SS_UNCONNECTED; 1267 return sock_error(sk); /* Always set at this point */ 1268 } 1269 1270 sock->state = SS_CONNECTED; 1271 1272 sti(); 1273 1274 return 0; 1275} 1276 1277 1278static int ax25_accept(struct socket *sock, struct socket *newsock, int flags) 1279{ 1280 struct sock *sk; 1281 struct sock *newsk; 1282 struct sk_buff *skb; 1283 1284 if (sock->state != SS_UNCONNECTED) 1285 return -EINVAL; 1286 1287 if ((sk = sock->sk) == NULL) 1288 return -EINVAL; 1289 1290 if (sk->type != SOCK_SEQPACKET) 1291 return -EOPNOTSUPP; 1292 1293 if (sk->state != TCP_LISTEN) 1294 return -EINVAL; 1295 1296 /* 1297 * The read queue this time is holding sockets ready to use 1298 * hooked into the SABM we saved 1299 */ 1300 do { 1301 if ((skb = skb_dequeue(&sk->receive_queue)) == NULL) { 1302 if (flags & O_NONBLOCK) 1303 return -EWOULDBLOCK; 1304 1305 interruptible_sleep_on(sk->sleep); 1306 if (signal_pending(current)) 1307 return -ERESTARTSYS; 1308 } 1309 } while (skb == NULL); 1310 1311 newsk = skb->sk; 1312 newsk->pair = NULL; 1313 newsk->socket = newsock; 1314 newsk->sleep = &newsock->wait; 1315 1316 /* Now attach up the new socket */ 1317 kfree_skb(skb); 1318 sk->ack_backlog--; 1319 newsock->sk = newsk; 1320 newsock->state = SS_CONNECTED; 1321 1322 return 0; 1323} 1324 1325static int ax25_getname(struct socket *sock, struct sockaddr *uaddr, int *uaddr_len, int peer) 1326{ 1327 struct sock *sk = sock->sk; 1328 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr; 1329 unsigned char ndigi, i; 1330 1331 if (peer != 0) { 1332 if (sk->state != TCP_ESTABLISHED) 1333 return -ENOTCONN; 1334 1335 fsa->fsa_ax25.sax25_family = AF_AX25; 1336 fsa->fsa_ax25.sax25_call = sk->protinfo.ax25->dest_addr; 1337 fsa->fsa_ax25.sax25_ndigis = 0; 1338 1339 if (sk->protinfo.ax25->digipeat != NULL) { 1340 ndigi = sk->protinfo.ax25->digipeat->ndigi; 1341 fsa->fsa_ax25.sax25_ndigis = ndigi; 1342 for (i = 0; i < ndigi; i++) 1343 fsa->fsa_digipeater[i] = sk->protinfo.ax25->digipeat->calls[i]; 1344 } 1345 } else { 1346 fsa->fsa_ax25.sax25_family = AF_AX25; 1347 fsa->fsa_ax25.sax25_call = sk->protinfo.ax25->source_addr; 1348 fsa->fsa_ax25.sax25_ndigis = 1; 1349 if (sk->protinfo.ax25->ax25_dev != NULL) { 1350 memcpy(&fsa->fsa_digipeater[0], sk->protinfo.ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN); 1351 } else { 1352 fsa->fsa_digipeater[0] = null_ax25_address; 1353 } 1354 } 1355 *uaddr_len = sizeof (struct full_sockaddr_ax25); 1356 return 0; 1357} 1358 1359static int ax25_sendmsg(struct socket *sock, struct msghdr *msg, int len, struct scm_cookie *scm) 1360{ 1361 struct sock *sk = sock->sk; 1362 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name; 1363 int err; 1364 struct sockaddr_ax25 sax; 1365 struct sk_buff *skb; 1366 unsigned char *asmptr; 1367 int size; 1368 ax25_digi *dp; 1369 ax25_digi dtmp; 1370 int lv; 1371 int addr_len = msg->msg_namelen; 1372 1373 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR)) 1374 return -EINVAL; 1375 1376 if (sk->zapped) 1377 return -EADDRNOTAVAIL; 1378 1379 if (sk->shutdown & SEND_SHUTDOWN) { 1380 send_sig(SIGPIPE, current, 0); 1381 return -EPIPE; 1382 } 1383 1384 if (sk->protinfo.ax25->ax25_dev == NULL) 1385 return -ENETUNREACH; 1386 1387 if (usax != NULL) { 1388 if (usax->sax25_family != AF_AX25) 1389 return -EINVAL; 1390 1391 if (addr_len == sizeof(struct sockaddr_ax25)) { 1392 printk(KERN_WARNING "ax25_sendmsg(): %s uses obsolete socket structure\n", 1393 current->comm); 1394 } 1395 else if (addr_len != sizeof(struct full_sockaddr_ax25)) { 1396 /* support for old structure may go away some time */ 1397 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) || 1398 (addr_len > sizeof(struct full_sockaddr_ax25))) 1399 return -EINVAL; 1400 1401 printk(KERN_WARNING "ax25_sendmsg(): %s uses old (6 digipeater) socket structure.\n", 1402 current->comm); 1403 } 1404 1405 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) { 1406 int ct = 0; 1407 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax; 1408 1409 /* Valid number of digipeaters ? */ 1410 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) 1411 return -EINVAL; 1412 1413 dtmp.ndigi = usax->sax25_ndigis; 1414 1415 while (ct < usax->sax25_ndigis) { 1416 dtmp.repeated[ct] = 0; 1417 dtmp.calls[ct] = fsa->fsa_digipeater[ct]; 1418 ct++; 1419 } 1420 1421 dtmp.lastrepeat = 0; 1422 } 1423 1424 sax = *usax; 1425 if (sk->type == SOCK_SEQPACKET && ax25cmp(&sk->protinfo.ax25->dest_addr, &sax.sax25_call) != 0) 1426 return -EISCONN; 1427 if (usax->sax25_ndigis == 0) 1428 dp = NULL; 1429 else 1430 dp = &dtmp; 1431 } else { 1432 if (sk->state != TCP_ESTABLISHED) 1433 return -ENOTCONN; 1434 sax.sax25_family = AF_AX25; 1435 sax.sax25_call = sk->protinfo.ax25->dest_addr; 1436 dp = sk->protinfo.ax25->digipeat; 1437 } 1438 1439 SOCK_DEBUG(sk, "AX.25: sendto: Addresses built.\n"); 1440 1441 /* Build a packet */ 1442 SOCK_DEBUG(sk, "AX.25: sendto: building packet.\n"); 1443 1444 /* Assume the worst case */ 1445 size = len + 3 + ax25_addr_size(dp) + AX25_BPQ_HEADER_LEN; 1446 1447 if ((skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT, &err)) == NULL) 1448 return err; 1449 1450 skb_reserve(skb, size - len); 1451 1452 SOCK_DEBUG(sk, "AX.25: Appending user data\n"); 1453 1454 /* User data follows immediately after the AX.25 data */ 1455 memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len); 1456 skb->nh.raw = skb->data; 1457 1458 /* Add the PID if one is not supplied by the user in the skb */ 1459 if (!sk->protinfo.ax25->pidincl) { 1460 asmptr = skb_push(skb, 1); 1461 *asmptr = sk->protocol; 1462 } 1463 1464 SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n"); 1465 1466 if (sk->type == SOCK_SEQPACKET) { 1467 /* Connected mode sockets go via the LAPB machine */ 1468 if (sk->state != TCP_ESTABLISHED) { 1469 kfree_skb(skb); 1470 return -ENOTCONN; 1471 } 1472 1473 ax25_output(sk->protinfo.ax25, sk->protinfo.ax25->paclen, skb); /* Shove it onto the queue and kick */ 1474 1475 return len; 1476 } else { 1477 asmptr = skb_push(skb, 1 + ax25_addr_size(dp)); 1478 1479 SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp); 1480 1481 if (dp != NULL) 1482 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi); 1483 1484 /* Build an AX.25 header */ 1485 asmptr += (lv = ax25_addr_build(asmptr, &sk->protinfo.ax25->source_addr, &sax.sax25_call, dp, AX25_COMMAND, AX25_MODULUS)); 1486 1487 SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv); 1488 1489 skb->h.raw = asmptr; 1490 1491 SOCK_DEBUG(sk, "base=%p pos=%p\n", skb->data, asmptr); 1492 1493 *asmptr = AX25_UI; 1494 1495 /* Datagram frames go straight out of the door as UI */ 1496 skb->dev = sk->protinfo.ax25->ax25_dev->dev; 1497 1498 ax25_queue_xmit(skb); 1499 1500 return len; 1501 } 1502} 1503 1504static int ax25_recvmsg(struct socket *sock, struct msghdr *msg, int size, int flags, struct scm_cookie *scm) 1505{ 1506 struct sock *sk = sock->sk; 1507 int copied; 1508 struct sk_buff *skb; 1509 int er; 1510 1511 /* 1512 * This works for seqpacket too. The receiver has ordered the 1513 * queue for us! We do one quick check first though 1514 */ 1515 if (sk->type == SOCK_SEQPACKET && sk->state != TCP_ESTABLISHED) 1516 return -ENOTCONN; 1517 1518 /* Now we can treat all alike */ 1519 if ((skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, flags & MSG_DONTWAIT, &er)) == NULL) 1520 return er; 1521 1522 if (!sk->protinfo.ax25->pidincl) 1523 skb_pull(skb, 1); /* Remove PID */ 1524 1525 skb->h.raw = skb->data; 1526 copied = skb->len; 1527 1528 if (copied > size) { 1529 copied = size; 1530 msg->msg_flags |= MSG_TRUNC; 1531 } 1532 1533 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 1534 1535 if (msg->msg_namelen != 0) { 1536 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name; 1537 ax25_digi digi; 1538 ax25_address dest; 1539 1540 ax25_addr_parse(skb->mac.raw+1, skb->data-skb->mac.raw-1, NULL, &dest, &digi, NULL, NULL); 1541 1542 sax->sax25_family = AF_AX25; 1543 /* We set this correctly, even though we may not let the 1544 application know the digi calls further down (because it 1545 did NOT ask to know them). This could get political... **/ 1546 sax->sax25_ndigis = digi.ndigi; 1547 sax->sax25_call = dest; 1548 1549 if (sax->sax25_ndigis != 0) { 1550 int ct; 1551 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax; 1552 1553 for (ct = 0; ct < digi.ndigi; ct++) 1554 fsa->fsa_digipeater[ct] = digi.calls[ct]; 1555 } 1556 msg->msg_namelen = sizeof(struct full_sockaddr_ax25); 1557 } 1558 1559 skb_free_datagram(sk, skb); 1560 1561 return copied; 1562} 1563 1564static int ax25_shutdown(struct socket *sk, int how) 1565{ 1566 return -EOPNOTSUPP; 1567} 1568 1569static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 1570{ 1571 struct sock *sk = sock->sk; 1572 1573 switch (cmd) { 1574 case TIOCOUTQ: { 1575 long amount; 1576 amount = sk->sndbuf - atomic_read(&sk->wmem_alloc); 1577 if (amount < 0) 1578 amount = 0; 1579 return put_user(amount, (int *)arg); 1580 } 1581 1582 case TIOCINQ: { 1583 struct sk_buff *skb; 1584 long amount = 0L; 1585 /* These two are safe on a single CPU system as only user tasks fiddle here */ 1586 if ((skb = skb_peek(&sk->receive_queue)) != NULL) 1587 amount = skb->len; 1588 return put_user(amount, (int *)arg); 1589 } 1590 1591 case SIOCGSTAMP: 1592 if (sk != NULL) { 1593 if (sk->stamp.tv_sec == 0) 1594 return -ENOENT; 1595 return copy_to_user((void *)arg, &sk->stamp, sizeof(struct timeval)) ? -EFAULT : 0; 1596 } 1597 return -EINVAL; 1598 1599 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */ 1600 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */ 1601 case SIOCAX25GETUID: { 1602 struct sockaddr_ax25 sax25; 1603 if (copy_from_user(&sax25, (void *)arg, sizeof(sax25))) 1604 return -EFAULT; 1605 return ax25_uid_ioctl(cmd, &sax25); 1606 } 1607 1608 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */ 1609 long amount; 1610 if (!capable(CAP_NET_ADMIN)) 1611 return -EPERM; 1612 if (get_user(amount, (long *)arg)) 1613 return -EFAULT; 1614 if (amount > AX25_NOUID_BLOCK) 1615 return -EINVAL; 1616 ax25_uid_policy = amount; 1617 return 0; 1618 } 1619 1620 case SIOCADDRT: 1621 case SIOCDELRT: 1622 case SIOCAX25OPTRT: 1623 if (!capable(CAP_NET_ADMIN)) 1624 return -EPERM; 1625 return ax25_rt_ioctl(cmd, (void *)arg); 1626 1627 case SIOCAX25CTLCON: 1628 if (!capable(CAP_NET_ADMIN)) 1629 return -EPERM; 1630 return ax25_ctl_ioctl(cmd, (void *)arg); 1631 1632 case SIOCAX25GETINFO: 1633 case SIOCAX25GETINFOOLD: { 1634 struct ax25_info_struct ax25_info; 1635 1636 ax25_info.t1 = sk->protinfo.ax25->t1 / HZ; 1637 ax25_info.t2 = sk->protinfo.ax25->t2 / HZ; 1638 ax25_info.t3 = sk->protinfo.ax25->t3 / HZ; 1639 ax25_info.idle = sk->protinfo.ax25->idle / (60 * HZ); 1640 ax25_info.n2 = sk->protinfo.ax25->n2; 1641 ax25_info.t1timer = ax25_display_timer(&sk->protinfo.ax25->t1timer) / HZ; 1642 ax25_info.t2timer = ax25_display_timer(&sk->protinfo.ax25->t2timer) / HZ; 1643 ax25_info.t3timer = ax25_display_timer(&sk->protinfo.ax25->t3timer) / HZ; 1644 ax25_info.idletimer = ax25_display_timer(&sk->protinfo.ax25->idletimer) / (60 * HZ); 1645 ax25_info.n2count = sk->protinfo.ax25->n2count; 1646 ax25_info.state = sk->protinfo.ax25->state; 1647 ax25_info.rcv_q = atomic_read(&sk->rmem_alloc); 1648 ax25_info.snd_q = atomic_read(&sk->wmem_alloc); 1649 ax25_info.vs = sk->protinfo.ax25->vs; 1650 ax25_info.vr = sk->protinfo.ax25->vr; 1651 ax25_info.va = sk->protinfo.ax25->va; 1652 ax25_info.vs_max = sk->protinfo.ax25->vs; /* reserved */ 1653 ax25_info.paclen = sk->protinfo.ax25->paclen; 1654 ax25_info.window = sk->protinfo.ax25->window; 1655 1656 /* old structure? */ 1657 if (cmd == SIOCAX25GETINFOOLD) { 1658 static int warned = 0; 1659 if (!warned) { 1660 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n", 1661 current->comm); 1662 warned=1; 1663 } 1664 1665 if (copy_to_user((void *)arg, &ax25_info, sizeof(struct ax25_info_struct_depreciated))) 1666 return -EFAULT; 1667 } else { 1668 if (copy_to_user((void *)arg, &ax25_info, sizeof(struct ax25_info_struct))) 1669 return -EINVAL; 1670 } 1671 return 0; 1672 } 1673 1674 case SIOCAX25ADDFWD: 1675 case SIOCAX25DELFWD: { 1676 struct ax25_fwd_struct ax25_fwd; 1677 if (!capable(CAP_NET_ADMIN)) 1678 return -EPERM; 1679 if (copy_from_user(&ax25_fwd, (void *)arg, sizeof(ax25_fwd))) 1680 return -EFAULT; 1681 return ax25_fwd_ioctl(cmd, &ax25_fwd); 1682 } 1683 1684 case SIOCGIFADDR: 1685 case SIOCSIFADDR: 1686 case SIOCGIFDSTADDR: 1687 case SIOCSIFDSTADDR: 1688 case SIOCGIFBRDADDR: 1689 case SIOCSIFBRDADDR: 1690 case SIOCGIFNETMASK: 1691 case SIOCSIFNETMASK: 1692 case SIOCGIFMETRIC: 1693 case SIOCSIFMETRIC: 1694 return -EINVAL; 1695 1696 default: 1697 return dev_ioctl(cmd, (void *)arg); 1698 } 1699 1700 /*NOTREACHED*/ 1701 return 0; 1702} 1703 1704static int ax25_get_info(char *buffer, char **start, off_t offset, int length) 1705{ 1706 ax25_cb *ax25; 1707 int k; 1708 int len = 0; 1709 off_t pos = 0; 1710 off_t begin = 0; 1711 1712 cli(); 1713 1714 /* 1715 * New format: 1716 * 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 1717 */ 1718 1719 for (ax25 = ax25_list; ax25 != NULL; ax25 = ax25->next) { 1720 len += sprintf(buffer+len, "%8.8lx %s %s%s ", 1721 (long) ax25, 1722 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name, 1723 ax2asc(&ax25->source_addr), 1724 ax25->iamdigi? "*":""); 1725 1726 len += sprintf(buffer+len, "%s", ax2asc(&ax25->dest_addr)); 1727 1728 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) { 1729 len += sprintf(buffer+len, ",%s%s", 1730 ax2asc(&ax25->digipeat->calls[k]), 1731 ax25->digipeat->repeated[k]? "*":""); 1732 } 1733 1734 len += sprintf(buffer+len, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d", 1735 ax25->state, 1736 ax25->vs, ax25->vr, ax25->va, 1737 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ, 1738 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ, 1739 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ, 1740 ax25_display_timer(&ax25->idletimer) / (60 * HZ), 1741 ax25->idle / (60 * HZ), 1742 ax25->n2count, ax25->n2, 1743 ax25->rtt / HZ, 1744 ax25->window, 1745 ax25->paclen); 1746 1747 if (ax25->sk != NULL) { 1748 len += sprintf(buffer + len, " %d %d %ld\n", 1749 atomic_read(&ax25->sk->wmem_alloc), 1750 atomic_read(&ax25->sk->rmem_alloc), 1751 ax25->sk->socket != NULL ? ax25->sk->socket->inode->i_ino : 0L); 1752 } else { 1753 len += sprintf(buffer + len, " * * *\n"); 1754 } 1755 1756 pos = begin + len; 1757 1758 if (pos < offset) { 1759 len = 0; 1760 begin = pos; 1761 } 1762 1763 if (pos > offset + length) 1764 break; 1765 } 1766 1767 sti(); 1768 1769 *start = buffer + (offset - begin); 1770 len -= (offset - begin); 1771 1772 if (len > length) len = length; 1773 1774 return(len); 1775} 1776 1777static struct net_proto_family ax25_family_ops = { 1778 family: PF_AX25, 1779 create: ax25_create, 1780}; 1781 1782static struct proto_ops SOCKOPS_WRAPPED(ax25_proto_ops) = { 1783 family: PF_AX25, 1784 1785 release: ax25_release, 1786 bind: ax25_bind, 1787 connect: ax25_connect, 1788 socketpair: sock_no_socketpair, 1789 accept: ax25_accept, 1790 getname: ax25_getname, 1791 poll: datagram_poll, 1792 ioctl: ax25_ioctl, 1793 listen: ax25_listen, 1794 shutdown: ax25_shutdown, 1795 setsockopt: ax25_setsockopt, 1796 getsockopt: ax25_getsockopt, 1797 sendmsg: ax25_sendmsg, 1798 recvmsg: ax25_recvmsg, 1799 mmap: sock_no_mmap, 1800 sendpage: sock_no_sendpage, 1801}; 1802 1803#include <linux/smp_lock.h> 1804SOCKOPS_WRAP(ax25_proto, PF_AX25); 1805 1806/* 1807 * Called by socket.c on kernel start up 1808 */ 1809static struct packet_type ax25_packet_type = { 1810 type: __constant_htons(ETH_P_AX25), 1811 func: ax25_kiss_rcv, 1812}; 1813 1814static struct notifier_block ax25_dev_notifier = { 1815 notifier_call: ax25_device_event, 1816}; 1817 1818EXPORT_SYMBOL(ax25_encapsulate); 1819EXPORT_SYMBOL(ax25_rebuild_header); 1820EXPORT_SYMBOL(ax25_findbyuid); 1821EXPORT_SYMBOL(ax25_find_cb); 1822EXPORT_SYMBOL(ax25_linkfail_register); 1823EXPORT_SYMBOL(ax25_linkfail_release); 1824EXPORT_SYMBOL(ax25_listen_register); 1825EXPORT_SYMBOL(ax25_listen_release); 1826EXPORT_SYMBOL(ax25_protocol_register); 1827EXPORT_SYMBOL(ax25_protocol_release); 1828EXPORT_SYMBOL(ax25_send_frame); 1829EXPORT_SYMBOL(ax25_uid_policy); 1830EXPORT_SYMBOL(ax25cmp); 1831EXPORT_SYMBOL(ax2asc); 1832EXPORT_SYMBOL(asc2ax); 1833EXPORT_SYMBOL(null_ax25_address); 1834EXPORT_SYMBOL(ax25_display_timer); 1835 1836static char banner[] __initdata = KERN_INFO "NET4: G4KLX/GW4PTS AX.25 for Linux. Version 0.37 for Linux NET4.0\n"; 1837 1838static int __init ax25_init(void) 1839{ 1840 sock_register(&ax25_family_ops); 1841 dev_add_pack(&ax25_packet_type); 1842 register_netdevice_notifier(&ax25_dev_notifier); 1843 ax25_register_sysctl(); 1844 1845 proc_net_create("ax25_route", 0, ax25_rt_get_info); 1846 proc_net_create("ax25", 0, ax25_get_info); 1847 proc_net_create("ax25_calls", 0, ax25_uid_get_info); 1848 1849 printk(banner); 1850 return 0; 1851} 1852module_init(ax25_init); 1853 1854 1855MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>"); 1856MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol"); 1857MODULE_LICENSE("GPL"); 1858 1859static void __exit ax25_exit(void) 1860{ 1861 proc_net_remove("ax25_route"); 1862 proc_net_remove("ax25"); 1863 proc_net_remove("ax25_calls"); 1864 ax25_rt_free(); 1865 ax25_uid_free(); 1866 ax25_dev_free(); 1867 1868 ax25_unregister_sysctl(); 1869 unregister_netdevice_notifier(&ax25_dev_notifier); 1870 1871 dev_remove_pack(&ax25_packet_type); 1872 1873 sock_unregister(PF_AX25); 1874} 1875module_exit(ax25_exit); 1876