1 /* 2 * G8BPQ compatible "AX.25 via ethernet" driver release 004 3 * 4 * This code REQUIRES 2.0.0 or higher/ NET3.029 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 * This is a "pseudo" network driver to allow AX.25 over Ethernet 13 * using G8BPQ encapsulation. It has been extracted from the protocol 14 * implementation because 15 * 16 * - things got unreadable within the protocol stack 17 * - to cure the protocol stack from "feature-ism" 18 * - a protocol implementation shouldn't need to know on 19 * which hardware it is running 20 * - user-level programs like the AX.25 utilities shouldn't 21 * need to know about the hardware. 22 * - IP over ethernet encapsulated AX.25 was impossible 23 * - rxecho.c did not work 24 * - to have room for extensions 25 * - it just deserves to "live" as an own driver 26 * 27 * This driver can use any ethernet destination address, and can be 28 * limited to accept frames from one dedicated ethernet card only. 29 * 30 * Note that the driver sets up the BPQ devices automagically on 31 * startup or (if started before the "insmod" of an ethernet device) 32 * on "ifconfig up". It hopefully will remove the BPQ on "rmmod"ing 33 * the ethernet device (in fact: as soon as another ethernet or bpq 34 * device gets "ifconfig"ured). 35 * 36 * I have heard that several people are thinking of experiments 37 * with highspeed packet radio using existing ethernet cards. 38 * Well, this driver is prepared for this purpose, just add 39 * your tx key control and a txdelay / tailtime algorithm, 40 * probably some buffering, and /voila/... 41 * 42 * History 43 * BPQ 001 Joerg(DL1BKE) Extracted BPQ code from AX.25 44 * protocol stack and added my own 45 * yet existing patches 46 * BPQ 002 Joerg(DL1BKE) Scan network device list on 47 * startup. 48 * BPQ 003 Joerg(DL1BKE) Ethernet destination address 49 * and accepted source address 50 * can be configured by an ioctl() 51 * call. 52 * Fixed to match Linux networking 53 * changes - 2.1.15. 54 * BPQ 004 Joerg(DL1BKE) Fixed to not lock up on ifconfig. 55 */ 56 57 #include <linux/config.h> 58 #include <linux/errno.h> 59 #include <linux/types.h> 60 #include <linux/socket.h> 61 #include <linux/in.h> 62 #include <linux/kernel.h> 63 #include <linux/string.h> 64 #include <linux/net.h> 65 #include <net/ax25.h> 66 #include <linux/inet.h> 67 #include <linux/netdevice.h> 68 #include <linux/if_ether.h> 69 #include <linux/if_arp.h> 70 #include <linux/skbuff.h> 71 #include <net/sock.h> 72 #include <asm/system.h> 73 #include <asm/uaccess.h> 74 #include <linux/mm.h> 75 #include <linux/interrupt.h> 76 #include <linux/notifier.h> 77 #include <linux/proc_fs.h> 78 #include <linux/seq_file.h> 79 #include <linux/stat.h> 80 #include <linux/netfilter.h> 81 #include <linux/module.h> 82 #include <linux/init.h> 83 #include <linux/rtnetlink.h> 84 85 #include <net/ip.h> 86 #include <net/arp.h> 87 88 #include <linux/bpqether.h> 89 90 static char banner[] __initdata = KERN_INFO "AX.25: bpqether driver version 004\n"; 91 92 static unsigned char ax25_bcast[AX25_ADDR_LEN] = 93 {'Q' << 1, 'S' << 1, 'T' << 1, ' ' << 1, ' ' << 1, ' ' << 1, '0' << 1}; 94 static unsigned char ax25_defaddr[AX25_ADDR_LEN] = 95 {'L' << 1, 'I' << 1, 'N' << 1, 'U' << 1, 'X' << 1, ' ' << 1, '1' << 1}; 96 97 static char bcast_addr[6]={0xFF,0xFF,0xFF,0xFF,0xFF,0xFF}; 98 99 static char bpq_eth_addr[6]; 100 101 static int bpq_rcv(struct sk_buff *, struct net_device *, struct packet_type *, struct net_device *); 102 static int bpq_device_event(struct notifier_block *, unsigned long, void *); 103 static const char *bpq_print_ethaddr(const unsigned char *); 104 105 static struct packet_type bpq_packet_type = { 106 .type = __constant_htons(ETH_P_BPQ), 107 .func = bpq_rcv, 108 }; 109 110 static struct notifier_block bpq_dev_notifier = { 111 .notifier_call =bpq_device_event, 112 }; 113 114 115 struct bpqdev { 116 struct list_head bpq_list; /* list of bpq devices chain */ 117 struct net_device *ethdev; /* link to ethernet device */ 118 struct net_device *axdev; /* bpq device (bpq#) */ 119 struct net_device_stats stats; /* some statistics */ 120 char dest_addr[6]; /* ether destination address */ 121 char acpt_addr[6]; /* accept ether frames from this address only */ 122 }; 123 124 static LIST_HEAD(bpq_devices); 125 126 127 /* ------------------------------------------------------------------------ */ 128 129 130 /* 131 * Get the ethernet device for a BPQ device 132 */ 133 static inline struct net_device *bpq_get_ether_dev(struct net_device *dev) 134 { 135 struct bpqdev *bpq = netdev_priv(dev); 136 137 return bpq ? bpq->ethdev : NULL; 138 } 139 140 /* 141 * Get the BPQ device for the ethernet device 142 */ 143 static inline struct net_device *bpq_get_ax25_dev(struct net_device *dev) 144 { 145 struct bpqdev *bpq; 146 147 list_for_each_entry_rcu(bpq, &bpq_devices, bpq_list) { 148 if (bpq->ethdev == dev) 149 return bpq->axdev; 150 } 151 return NULL; 152 } 153 154 static inline int dev_is_ethdev(struct net_device *dev) 155 { 156 return ( 157 dev->type == ARPHRD_ETHER 158 && strncmp(dev->name, "dummy", 5) 159 ); 160 } 161 162 /* ------------------------------------------------------------------------ */ 163 164 165 /* 166 * Receive an AX.25 frame via an ethernet interface. 167 */ 168 static int bpq_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *ptype, struct net_device *orig_dev) 169 { 170 int len; 171 char * ptr; 172 struct ethhdr *eth; 173 struct bpqdev *bpq; 174 175 if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL) 176 return NET_RX_DROP; 177 178 if (!pskb_may_pull(skb, sizeof(struct ethhdr))) 179 goto drop; 180 181 rcu_read_lock(); 182 dev = bpq_get_ax25_dev(dev); 183 184 if (dev == NULL || !netif_running(dev)) 185 goto drop_unlock; 186 187 /* 188 * if we want to accept frames from just one ethernet device 189 * we check the source address of the sender. 190 */ 191 192 bpq = netdev_priv(dev); 193 194 eth = eth_hdr(skb); 195 196 if (!(bpq->acpt_addr[0] & 0x01) && 197 memcmp(eth->h_source, bpq->acpt_addr, ETH_ALEN)) 198 goto drop_unlock; 199 200 if (skb_cow(skb, sizeof(struct ethhdr))) 201 goto drop_unlock; 202 203 len = skb->data[0] + skb->data[1] * 256 - 5; 204 205 skb_pull(skb, 2); /* Remove the length bytes */ 206 skb_trim(skb, len); /* Set the length of the data */ 207 208 bpq->stats.rx_packets++; 209 bpq->stats.rx_bytes += len; 210 211 ptr = skb_push(skb, 1); 212 *ptr = 0; 213 214 skb->protocol = ax25_type_trans(skb, dev); 215 netif_rx(skb); 216 dev->last_rx = jiffies; 217 unlock: 218 219 rcu_read_unlock(); 220 221 return 0; 222 drop_unlock: 223 kfree_skb(skb); 224 goto unlock; 225 226 drop: 227 kfree_skb(skb); 228 return 0; 229 } 230 231 /* 232 * Send an AX.25 frame via an ethernet interface 233 */ 234 static int bpq_xmit(struct sk_buff *skb, struct net_device *dev) 235 { 236 struct sk_buff *newskb; 237 unsigned char *ptr; 238 struct bpqdev *bpq; 239 int size; 240 241 /* 242 * Just to be *really* sure not to send anything if the interface 243 * is down, the ethernet device may have gone. 244 */ 245 if (!netif_running(dev)) { 246 kfree_skb(skb); 247 return -ENODEV; 248 } 249 250 skb_pull(skb, 1); 251 size = skb->len; 252 253 /* 254 * The AX.25 code leaves enough room for the ethernet header, but 255 * sendto() does not. 256 */ 257 if (skb_headroom(skb) < AX25_BPQ_HEADER_LEN) { /* Ough! */ 258 if ((newskb = skb_realloc_headroom(skb, AX25_BPQ_HEADER_LEN)) == NULL) { 259 printk(KERN_WARNING "bpqether: out of memory\n"); 260 kfree_skb(skb); 261 return -ENOMEM; 262 } 263 264 if (skb->sk != NULL) 265 skb_set_owner_w(newskb, skb->sk); 266 267 kfree_skb(skb); 268 skb = newskb; 269 } 270 271 ptr = skb_push(skb, 2); 272 273 *ptr++ = (size + 5) % 256; 274 *ptr++ = (size + 5) / 256; 275 276 bpq = netdev_priv(dev); 277 278 if ((dev = bpq_get_ether_dev(dev)) == NULL) { 279 bpq->stats.tx_dropped++; 280 kfree_skb(skb); 281 return -ENODEV; 282 } 283 284 skb->protocol = ax25_type_trans(skb, dev); 285 skb->nh.raw = skb->data; 286 dev->hard_header(skb, dev, ETH_P_BPQ, bpq->dest_addr, NULL, 0); 287 bpq->stats.tx_packets++; 288 bpq->stats.tx_bytes+=skb->len; 289 290 dev_queue_xmit(skb); 291 netif_wake_queue(dev); 292 return 0; 293 } 294 295 /* 296 * Statistics 297 */ 298 static struct net_device_stats *bpq_get_stats(struct net_device *dev) 299 { 300 struct bpqdev *bpq = netdev_priv(dev); 301 302 return &bpq->stats; 303 } 304 305 /* 306 * Set AX.25 callsign 307 */ 308 static int bpq_set_mac_address(struct net_device *dev, void *addr) 309 { 310 struct sockaddr *sa = (struct sockaddr *)addr; 311 312 memcpy(dev->dev_addr, sa->sa_data, dev->addr_len); 313 314 return 0; 315 } 316 317 /* Ioctl commands 318 * 319 * SIOCSBPQETHOPT reserved for enhancements 320 * SIOCSBPQETHADDR set the destination and accepted 321 * source ethernet address (broadcast 322 * or multicast: accept all) 323 */ 324 static int bpq_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 325 { 326 struct bpq_ethaddr __user *ethaddr = ifr->ifr_data; 327 struct bpqdev *bpq = netdev_priv(dev); 328 struct bpq_req req; 329 330 if (!capable(CAP_NET_ADMIN)) 331 return -EPERM; 332 333 switch (cmd) { 334 case SIOCSBPQETHOPT: 335 if (copy_from_user(&req, ifr->ifr_data, sizeof(struct bpq_req))) 336 return -EFAULT; 337 switch (req.cmd) { 338 case SIOCGBPQETHPARAM: 339 case SIOCSBPQETHPARAM: 340 default: 341 return -EINVAL; 342 } 343 344 break; 345 346 case SIOCSBPQETHADDR: 347 if (copy_from_user(bpq->dest_addr, ethaddr->destination, ETH_ALEN)) 348 return -EFAULT; 349 if (copy_from_user(bpq->acpt_addr, ethaddr->accept, ETH_ALEN)) 350 return -EFAULT; 351 break; 352 353 default: 354 return -EINVAL; 355 } 356 357 return 0; 358 } 359 360 /* 361 * open/close a device 362 */ 363 static int bpq_open(struct net_device *dev) 364 { 365 netif_start_queue(dev); 366 return 0; 367 } 368 369 static int bpq_close(struct net_device *dev) 370 { 371 netif_stop_queue(dev); 372 return 0; 373 } 374 375 376 /* ------------------------------------------------------------------------ */ 377 378 379 /* 380 * Proc filesystem 381 */ 382 static const char * bpq_print_ethaddr(const unsigned char *e) 383 { 384 static char buf[18]; 385 386 sprintf(buf, "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X", 387 e[0], e[1], e[2], e[3], e[4], e[5]); 388 389 return buf; 390 } 391 392 static void *bpq_seq_start(struct seq_file *seq, loff_t *pos) 393 { 394 int i = 1; 395 struct bpqdev *bpqdev; 396 397 rcu_read_lock(); 398 399 if (*pos == 0) 400 return SEQ_START_TOKEN; 401 402 list_for_each_entry_rcu(bpqdev, &bpq_devices, bpq_list) { 403 if (i == *pos) 404 return bpqdev; 405 } 406 return NULL; 407 } 408 409 static void *bpq_seq_next(struct seq_file *seq, void *v, loff_t *pos) 410 { 411 struct list_head *p; 412 413 ++*pos; 414 415 if (v == SEQ_START_TOKEN) 416 p = bpq_devices.next; 417 else 418 p = ((struct bpqdev *)v)->bpq_list.next; 419 420 return (p == &bpq_devices) ? NULL 421 : rcu_dereference(list_entry(p, struct bpqdev, bpq_list)); 422 } 423 424 static void bpq_seq_stop(struct seq_file *seq, void *v) 425 { 426 rcu_read_unlock(); 427 } 428 429 430 static int bpq_seq_show(struct seq_file *seq, void *v) 431 { 432 if (v == SEQ_START_TOKEN) 433 seq_puts(seq, 434 "dev ether destination accept from\n"); 435 else { 436 const struct bpqdev *bpqdev = v; 437 438 seq_printf(seq, "%-5s %-10s %s ", 439 bpqdev->axdev->name, bpqdev->ethdev->name, 440 bpq_print_ethaddr(bpqdev->dest_addr)); 441 442 seq_printf(seq, "%s\n", 443 (bpqdev->acpt_addr[0] & 0x01) ? "*" 444 : bpq_print_ethaddr(bpqdev->acpt_addr)); 445 446 } 447 return 0; 448 } 449 450 static struct seq_operations bpq_seqops = { 451 .start = bpq_seq_start, 452 .next = bpq_seq_next, 453 .stop = bpq_seq_stop, 454 .show = bpq_seq_show, 455 }; 456 457 static int bpq_info_open(struct inode *inode, struct file *file) 458 { 459 return seq_open(file, &bpq_seqops); 460 } 461 462 static struct file_operations bpq_info_fops = { 463 .owner = THIS_MODULE, 464 .open = bpq_info_open, 465 .read = seq_read, 466 .llseek = seq_lseek, 467 .release = seq_release, 468 }; 469 470 471 /* ------------------------------------------------------------------------ */ 472 473 474 static void bpq_setup(struct net_device *dev) 475 { 476 477 dev->hard_start_xmit = bpq_xmit; 478 dev->open = bpq_open; 479 dev->stop = bpq_close; 480 dev->set_mac_address = bpq_set_mac_address; 481 dev->get_stats = bpq_get_stats; 482 dev->do_ioctl = bpq_ioctl; 483 dev->destructor = free_netdev; 484 485 memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN); 486 memcpy(dev->dev_addr, ax25_defaddr, AX25_ADDR_LEN); 487 488 dev->flags = 0; 489 490 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE) 491 dev->hard_header = ax25_hard_header; 492 dev->rebuild_header = ax25_rebuild_header; 493 #endif 494 495 dev->type = ARPHRD_AX25; 496 dev->hard_header_len = AX25_MAX_HEADER_LEN + AX25_BPQ_HEADER_LEN; 497 dev->mtu = AX25_DEF_PACLEN; 498 dev->addr_len = AX25_ADDR_LEN; 499 500 } 501 502 /* 503 * Setup a new device. 504 */ 505 static int bpq_new_device(struct net_device *edev) 506 { 507 int err; 508 struct net_device *ndev; 509 struct bpqdev *bpq; 510 511 ndev = alloc_netdev(sizeof(struct bpqdev), "bpq%d", 512 bpq_setup); 513 if (!ndev) 514 return -ENOMEM; 515 516 517 bpq = netdev_priv(ndev); 518 dev_hold(edev); 519 bpq->ethdev = edev; 520 bpq->axdev = ndev; 521 522 memcpy(bpq->dest_addr, bcast_addr, sizeof(bpq_eth_addr)); 523 memcpy(bpq->acpt_addr, bcast_addr, sizeof(bpq_eth_addr)); 524 525 err = dev_alloc_name(ndev, ndev->name); 526 if (err < 0) 527 goto error; 528 529 err = register_netdevice(ndev); 530 if (err) 531 goto error; 532 533 /* List protected by RTNL */ 534 list_add_rcu(&bpq->bpq_list, &bpq_devices); 535 return 0; 536 537 error: 538 dev_put(edev); 539 free_netdev(ndev); 540 return err; 541 542 } 543 544 static void bpq_free_device(struct net_device *ndev) 545 { 546 struct bpqdev *bpq = netdev_priv(ndev); 547 548 dev_put(bpq->ethdev); 549 list_del_rcu(&bpq->bpq_list); 550 551 unregister_netdevice(ndev); 552 } 553 554 /* 555 * Handle device status changes. 556 */ 557 static int bpq_device_event(struct notifier_block *this,unsigned long event, void *ptr) 558 { 559 struct net_device *dev = (struct net_device *)ptr; 560 561 if (!dev_is_ethdev(dev)) 562 return NOTIFY_DONE; 563 564 switch (event) { 565 case NETDEV_UP: /* new ethernet device -> new BPQ interface */ 566 if (bpq_get_ax25_dev(dev) == NULL) 567 bpq_new_device(dev); 568 break; 569 570 case NETDEV_DOWN: /* ethernet device closed -> close BPQ interface */ 571 if ((dev = bpq_get_ax25_dev(dev)) != NULL) 572 dev_close(dev); 573 break; 574 575 case NETDEV_UNREGISTER: /* ethernet device removed -> free BPQ interface */ 576 if ((dev = bpq_get_ax25_dev(dev)) != NULL) 577 bpq_free_device(dev); 578 break; 579 default: 580 break; 581 } 582 583 return NOTIFY_DONE; 584 } 585 586 587 /* ------------------------------------------------------------------------ */ 588 589 /* 590 * Initialize driver. To be called from af_ax25 if not compiled as a 591 * module 592 */ 593 static int __init bpq_init_driver(void) 594 { 595 #ifdef CONFIG_PROC_FS 596 if (!proc_net_fops_create("bpqether", S_IRUGO, &bpq_info_fops)) { 597 printk(KERN_ERR 598 "bpq: cannot create /proc/net/bpqether entry.\n"); 599 return -ENOENT; 600 } 601 #endif /* CONFIG_PROC_FS */ 602 603 dev_add_pack(&bpq_packet_type); 604 605 register_netdevice_notifier(&bpq_dev_notifier); 606 607 printk(banner); 608 609 return 0; 610 } 611 612 static void __exit bpq_cleanup_driver(void) 613 { 614 struct bpqdev *bpq; 615 616 dev_remove_pack(&bpq_packet_type); 617 618 unregister_netdevice_notifier(&bpq_dev_notifier); 619 620 proc_net_remove("bpqether"); 621 622 rtnl_lock(); 623 while (!list_empty(&bpq_devices)) { 624 bpq = list_entry(bpq_devices.next, struct bpqdev, bpq_list); 625 bpq_free_device(bpq->axdev); 626 } 627 rtnl_unlock(); 628 } 629 630 MODULE_AUTHOR("Joerg Reuter DL1BKE <jreuter@yaina.de>"); 631 MODULE_DESCRIPTION("Transmit and receive AX.25 packets over Ethernet"); 632 MODULE_LICENSE("GPL"); 633 module_init(bpq_init_driver); 634 module_exit(bpq_cleanup_driver); 635