1/* 2 * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and 3 * James Leu (jleu@mindspring.net). 4 * Copyright (C) 2001 by various other people who didn't put their name here. 5 * Licensed under the GPL. 6 */ 7 8#include "linux/kernel.h" 9#include "linux/netdevice.h" 10#include "linux/rtnetlink.h" 11#include "linux/skbuff.h" 12#include "linux/socket.h" 13#include "linux/spinlock.h" 14#include "linux/module.h" 15#include "linux/init.h" 16#include "linux/etherdevice.h" 17#include "linux/list.h" 18#include "linux/inetdevice.h" 19#include "linux/ctype.h" 20#include "linux/bootmem.h" 21#include "linux/ethtool.h" 22#include "linux/platform_device.h" 23#include "asm/uaccess.h" 24#include "kern_util.h" 25#include "net_kern.h" 26#include "net_user.h" 27#include "mconsole_kern.h" 28#include "init.h" 29#include "irq_user.h" 30#include "irq_kern.h" 31 32static inline void set_ether_mac(struct net_device *dev, unsigned char *addr) 33{ 34 memcpy(dev->dev_addr, addr, ETH_ALEN); 35} 36 37#define DRIVER_NAME "uml-netdev" 38 39static DEFINE_SPINLOCK(opened_lock); 40static LIST_HEAD(opened); 41 42static int uml_net_rx(struct net_device *dev) 43{ 44 struct uml_net_private *lp = dev->priv; 45 int pkt_len; 46 struct sk_buff *skb; 47 48 /* If we can't allocate memory, try again next round. */ 49 skb = dev_alloc_skb(dev->mtu); 50 if (skb == NULL) { 51 lp->stats.rx_dropped++; 52 return 0; 53 } 54 55 skb->dev = dev; 56 skb_put(skb, dev->mtu); 57 skb_reset_mac_header(skb); 58 pkt_len = (*lp->read)(lp->fd, &skb, lp); 59 60 if (pkt_len > 0) { 61 skb_trim(skb, pkt_len); 62 skb->protocol = (*lp->protocol)(skb); 63 netif_rx(skb); 64 65 lp->stats.rx_bytes += skb->len; 66 lp->stats.rx_packets++; 67 return pkt_len; 68 } 69 70 kfree_skb(skb); 71 return pkt_len; 72} 73 74static void uml_dev_close(struct work_struct *work) 75{ 76 struct uml_net_private *lp = 77 container_of(work, struct uml_net_private, work); 78 dev_close(lp->dev); 79} 80 81irqreturn_t uml_net_interrupt(int irq, void *dev_id) 82{ 83 struct net_device *dev = dev_id; 84 struct uml_net_private *lp = dev->priv; 85 int err; 86 87 if(!netif_running(dev)) 88 return(IRQ_NONE); 89 90 spin_lock(&lp->lock); 91 while((err = uml_net_rx(dev)) > 0) ; 92 if(err < 0) { 93 printk(KERN_ERR 94 "Device '%s' read returned %d, shutting it down\n", 95 dev->name, err); 96 /* dev_close can't be called in interrupt context, and takes 97 * again lp->lock. 98 * And dev_close() can be safely called multiple times on the 99 * same device, since it tests for (dev->flags & IFF_UP). So 100 * there's no harm in delaying the device shutdown. 101 * Furthermore, the workqueue will not re-enqueue an already 102 * enqueued work item. */ 103 schedule_work(&lp->work); 104 goto out; 105 } 106 reactivate_fd(lp->fd, UM_ETH_IRQ); 107 108out: 109 spin_unlock(&lp->lock); 110 return IRQ_HANDLED; 111} 112 113static int uml_net_open(struct net_device *dev) 114{ 115 struct uml_net_private *lp = dev->priv; 116 int err; 117 118 if(lp->fd >= 0){ 119 err = -ENXIO; 120 goto out; 121 } 122 123 lp->fd = (*lp->open)(&lp->user); 124 if(lp->fd < 0){ 125 err = lp->fd; 126 goto out; 127 } 128 129 err = um_request_irq(dev->irq, lp->fd, IRQ_READ, uml_net_interrupt, 130 IRQF_DISABLED | IRQF_SHARED, dev->name, dev); 131 if(err != 0){ 132 printk(KERN_ERR "uml_net_open: failed to get irq(%d)\n", err); 133 err = -ENETUNREACH; 134 goto out_close; 135 } 136 137 lp->tl.data = (unsigned long) &lp->user; 138 netif_start_queue(dev); 139 140 /* clear buffer - it can happen that the host side of the interface 141 * is full when we get here. In this case, new data is never queued, 142 * SIGIOs never arrive, and the net never works. 143 */ 144 while((err = uml_net_rx(dev)) > 0) ; 145 146 spin_lock(&opened_lock); 147 list_add(&lp->list, &opened); 148 spin_unlock(&opened_lock); 149 150 return 0; 151out_close: 152 if(lp->close != NULL) (*lp->close)(lp->fd, &lp->user); 153 lp->fd = -1; 154out: 155 return err; 156} 157 158static int uml_net_close(struct net_device *dev) 159{ 160 struct uml_net_private *lp = dev->priv; 161 162 netif_stop_queue(dev); 163 164 free_irq(dev->irq, dev); 165 if(lp->close != NULL) 166 (*lp->close)(lp->fd, &lp->user); 167 lp->fd = -1; 168 169 spin_lock(&opened_lock); 170 list_del(&lp->list); 171 spin_unlock(&opened_lock); 172 173 return 0; 174} 175 176static int uml_net_start_xmit(struct sk_buff *skb, struct net_device *dev) 177{ 178 struct uml_net_private *lp = dev->priv; 179 unsigned long flags; 180 int len; 181 182 netif_stop_queue(dev); 183 184 spin_lock_irqsave(&lp->lock, flags); 185 186 len = (*lp->write)(lp->fd, &skb, lp); 187 188 if(len == skb->len) { 189 lp->stats.tx_packets++; 190 lp->stats.tx_bytes += skb->len; 191 dev->trans_start = jiffies; 192 netif_start_queue(dev); 193 194 /* this is normally done in the interrupt when tx finishes */ 195 netif_wake_queue(dev); 196 } 197 else if(len == 0){ 198 netif_start_queue(dev); 199 lp->stats.tx_dropped++; 200 } 201 else { 202 netif_start_queue(dev); 203 printk(KERN_ERR "uml_net_start_xmit: failed(%d)\n", len); 204 } 205 206 spin_unlock_irqrestore(&lp->lock, flags); 207 208 dev_kfree_skb(skb); 209 210 return 0; 211} 212 213static struct net_device_stats *uml_net_get_stats(struct net_device *dev) 214{ 215 struct uml_net_private *lp = dev->priv; 216 return &lp->stats; 217} 218 219static void uml_net_set_multicast_list(struct net_device *dev) 220{ 221 if (dev->flags & IFF_PROMISC) return; 222 else if (dev->mc_count) dev->flags |= IFF_ALLMULTI; 223 else dev->flags &= ~IFF_ALLMULTI; 224} 225 226static void uml_net_tx_timeout(struct net_device *dev) 227{ 228 dev->trans_start = jiffies; 229 netif_wake_queue(dev); 230} 231 232static int uml_net_set_mac(struct net_device *dev, void *addr) 233{ 234 struct uml_net_private *lp = dev->priv; 235 struct sockaddr *hwaddr = addr; 236 237 spin_lock_irq(&lp->lock); 238 set_ether_mac(dev, hwaddr->sa_data); 239 spin_unlock_irq(&lp->lock); 240 241 return 0; 242} 243 244static int uml_net_change_mtu(struct net_device *dev, int new_mtu) 245{ 246 struct uml_net_private *lp = dev->priv; 247 int err = 0; 248 249 spin_lock_irq(&lp->lock); 250 251 new_mtu = (*lp->set_mtu)(new_mtu, &lp->user); 252 if(new_mtu < 0){ 253 err = new_mtu; 254 goto out; 255 } 256 257 dev->mtu = new_mtu; 258 259 out: 260 spin_unlock_irq(&lp->lock); 261 return err; 262} 263 264static void uml_net_get_drvinfo(struct net_device *dev, 265 struct ethtool_drvinfo *info) 266{ 267 strcpy(info->driver, DRIVER_NAME); 268 strcpy(info->version, "42"); 269} 270 271static struct ethtool_ops uml_net_ethtool_ops = { 272 .get_drvinfo = uml_net_get_drvinfo, 273 .get_link = ethtool_op_get_link, 274}; 275 276void uml_net_user_timer_expire(unsigned long _conn) 277{ 278#ifdef undef 279 struct connection *conn = (struct connection *)_conn; 280 281 dprintk(KERN_INFO "uml_net_user_timer_expire [%p]\n", conn); 282 do_connect(conn); 283#endif 284} 285 286static void setup_etheraddr(char *str, unsigned char *addr, char *name) 287{ 288 char *end; 289 int i; 290 291 if(str == NULL) 292 goto random; 293 294 for(i=0;i<6;i++){ 295 addr[i] = simple_strtoul(str, &end, 16); 296 if((end == str) || 297 ((*end != ':') && (*end != ',') && (*end != '\0'))){ 298 printk(KERN_ERR 299 "setup_etheraddr: failed to parse '%s' " 300 "as an ethernet address\n", str); 301 goto random; 302 } 303 str = end + 1; 304 } 305 if (is_multicast_ether_addr(addr)) { 306 printk(KERN_ERR 307 "Attempt to assign a multicast ethernet address to a " 308 "device disallowed\n"); 309 goto random; 310 } 311 if (!is_valid_ether_addr(addr)) { 312 printk(KERN_ERR 313 "Attempt to assign an invalid ethernet address to a " 314 "device disallowed\n"); 315 goto random; 316 } 317 if (!is_local_ether_addr(addr)) { 318 printk(KERN_WARNING 319 "Warning: attempt to assign a globally valid ethernet " 320 "address to a device\n"); 321 printk(KERN_WARNING "You should better enable the 2nd " 322 "rightmost bit in the first byte of the MAC,\n"); 323 printk(KERN_WARNING "i.e. %02x:%02x:%02x:%02x:%02x:%02x\n", 324 addr[0] | 0x02, addr[1], addr[2], addr[3], addr[4], 325 addr[5]); 326 goto random; 327 } 328 return; 329 330random: 331 printk(KERN_INFO 332 "Choosing a random ethernet address for device %s\n", name); 333 random_ether_addr(addr); 334} 335 336static DEFINE_SPINLOCK(devices_lock); 337static LIST_HEAD(devices); 338 339static struct platform_driver uml_net_driver = { 340 .driver = { 341 .name = DRIVER_NAME, 342 }, 343}; 344static int driver_registered; 345 346static void net_device_release(struct device *dev) 347{ 348 struct uml_net *device = dev->driver_data; 349 struct net_device *netdev = device->dev; 350 struct uml_net_private *lp = netdev->priv; 351 352 if(lp->remove != NULL) 353 (*lp->remove)(&lp->user); 354 list_del(&device->list); 355 kfree(device); 356 free_netdev(netdev); 357} 358 359static void eth_configure(int n, void *init, char *mac, 360 struct transport *transport) 361{ 362 struct uml_net *device; 363 struct net_device *dev; 364 struct uml_net_private *lp; 365 int err, size; 366 367 size = transport->private_size + sizeof(struct uml_net_private); 368 369 device = kzalloc(sizeof(*device), GFP_KERNEL); 370 if (device == NULL) { 371 printk(KERN_ERR "eth_configure failed to allocate struct " 372 "uml_net\n"); 373 return; 374 } 375 376 dev = alloc_etherdev(size); 377 if (dev == NULL) { 378 printk(KERN_ERR "eth_configure: failed to allocate struct " 379 "net_device for eth%d\n", n); 380 goto out_free_device; 381 } 382 383 INIT_LIST_HEAD(&device->list); 384 device->index = n; 385 386 /* If this name ends up conflicting with an existing registered 387 * netdevice, that is OK, register_netdev{,ice}() will notice this 388 * and fail. 389 */ 390 snprintf(dev->name, sizeof(dev->name), "eth%d", n); 391 392 setup_etheraddr(mac, device->mac, dev->name); 393 394 printk(KERN_INFO "Netdevice %d ", n); 395 printk("(%02x:%02x:%02x:%02x:%02x:%02x) ", 396 device->mac[0], device->mac[1], 397 device->mac[2], device->mac[3], 398 device->mac[4], device->mac[5]); 399 printk(": "); 400 401 lp = dev->priv; 402 /* This points to the transport private data. It's still clear, but we 403 * must memset it to 0 *now*. Let's help the drivers. */ 404 memset(lp, 0, size); 405 INIT_WORK(&lp->work, uml_dev_close); 406 407 /* sysfs register */ 408 if (!driver_registered) { 409 platform_driver_register(¨_net_driver); 410 driver_registered = 1; 411 } 412 device->pdev.id = n; 413 device->pdev.name = DRIVER_NAME; 414 device->pdev.dev.release = net_device_release; 415 device->pdev.dev.driver_data = device; 416 if(platform_device_register(&device->pdev)) 417 goto out_free_netdev; 418 SET_NETDEV_DEV(dev,&device->pdev.dev); 419 420 device->dev = dev; 421 422 /* 423 * These just fill in a data structure, so there's no failure 424 * to be worried about. 425 */ 426 (*transport->kern->init)(dev, init); 427 428 *lp = ((struct uml_net_private) 429 { .list = LIST_HEAD_INIT(lp->list), 430 .dev = dev, 431 .fd = -1, 432 .mac = { 0xfe, 0xfd, 0x0, 0x0, 0x0, 0x0}, 433 .protocol = transport->kern->protocol, 434 .open = transport->user->open, 435 .close = transport->user->close, 436 .remove = transport->user->remove, 437 .read = transport->kern->read, 438 .write = transport->kern->write, 439 .add_address = transport->user->add_address, 440 .delete_address = transport->user->delete_address, 441 .set_mtu = transport->user->set_mtu }); 442 443 init_timer(&lp->tl); 444 spin_lock_init(&lp->lock); 445 lp->tl.function = uml_net_user_timer_expire; 446 memcpy(lp->mac, device->mac, sizeof(lp->mac)); 447 448 if ((transport->user->init != NULL) && 449 ((*transport->user->init)(&lp->user, dev) != 0)) 450 goto out_unregister; 451 452 set_ether_mac(dev, device->mac); 453 dev->mtu = transport->user->max_packet; 454 dev->open = uml_net_open; 455 dev->hard_start_xmit = uml_net_start_xmit; 456 dev->stop = uml_net_close; 457 dev->get_stats = uml_net_get_stats; 458 dev->set_multicast_list = uml_net_set_multicast_list; 459 dev->tx_timeout = uml_net_tx_timeout; 460 dev->set_mac_address = uml_net_set_mac; 461 dev->change_mtu = uml_net_change_mtu; 462 dev->ethtool_ops = ¨_net_ethtool_ops; 463 dev->watchdog_timeo = (HZ >> 1); 464 dev->irq = UM_ETH_IRQ; 465 466 rtnl_lock(); 467 err = register_netdevice(dev); 468 rtnl_unlock(); 469 if (err) 470 goto out_undo_user_init; 471 472 spin_lock(&devices_lock); 473 list_add(&device->list, &devices); 474 spin_unlock(&devices_lock); 475 476 return; 477 478out_undo_user_init: 479 if (transport->user->remove != NULL) 480 (*transport->user->remove)(&lp->user); 481out_unregister: 482 platform_device_unregister(&device->pdev); 483 return; /* platform_device_unregister frees dev and device */ 484out_free_netdev: 485 free_netdev(dev); 486out_free_device: 487 kfree(device); 488} 489 490static struct uml_net *find_device(int n) 491{ 492 struct uml_net *device; 493 struct list_head *ele; 494 495 spin_lock(&devices_lock); 496 list_for_each(ele, &devices){ 497 device = list_entry(ele, struct uml_net, list); 498 if(device->index == n) 499 goto out; 500 } 501 device = NULL; 502 out: 503 spin_unlock(&devices_lock); 504 return device; 505} 506 507static int eth_parse(char *str, int *index_out, char **str_out, 508 char **error_out) 509{ 510 char *end; 511 int n, err = -EINVAL;; 512 513 n = simple_strtoul(str, &end, 0); 514 if(end == str){ 515 *error_out = "Bad device number"; 516 return err; 517 } 518 519 str = end; 520 if(*str != '='){ 521 *error_out = "Expected '=' after device number"; 522 return err; 523 } 524 525 str++; 526 if(find_device(n)){ 527 *error_out = "Device already configured"; 528 return err; 529 } 530 531 *index_out = n; 532 *str_out = str; 533 return 0; 534} 535 536struct eth_init { 537 struct list_head list; 538 char *init; 539 int index; 540}; 541 542static DEFINE_SPINLOCK(transports_lock); 543static LIST_HEAD(transports); 544 545/* Filled in during early boot */ 546static LIST_HEAD(eth_cmd_line); 547 548static int check_transport(struct transport *transport, char *eth, int n, 549 void **init_out, char **mac_out) 550{ 551 int len; 552 553 len = strlen(transport->name); 554 if(strncmp(eth, transport->name, len)) 555 return 0; 556 557 eth += len; 558 if(*eth == ',') 559 eth++; 560 else if(*eth != '\0') 561 return 0; 562 563 *init_out = kmalloc(transport->setup_size, GFP_KERNEL); 564 if(*init_out == NULL) 565 return 1; 566 567 if(!transport->setup(eth, mac_out, *init_out)){ 568 kfree(*init_out); 569 *init_out = NULL; 570 } 571 return 1; 572} 573 574void register_transport(struct transport *new) 575{ 576 struct list_head *ele, *next; 577 struct eth_init *eth; 578 void *init; 579 char *mac = NULL; 580 int match; 581 582 spin_lock(&transports_lock); 583 BUG_ON(!list_empty(&new->list)); 584 list_add(&new->list, &transports); 585 spin_unlock(&transports_lock); 586 587 list_for_each_safe(ele, next, ð_cmd_line){ 588 eth = list_entry(ele, struct eth_init, list); 589 match = check_transport(new, eth->init, eth->index, &init, 590 &mac); 591 if(!match) 592 continue; 593 else if(init != NULL){ 594 eth_configure(eth->index, init, mac, new); 595 kfree(init); 596 } 597 list_del(ð->list); 598 } 599} 600 601static int eth_setup_common(char *str, int index) 602{ 603 struct list_head *ele; 604 struct transport *transport; 605 void *init; 606 char *mac = NULL; 607 int found = 0; 608 609 spin_lock(&transports_lock); 610 list_for_each(ele, &transports){ 611 transport = list_entry(ele, struct transport, list); 612 if(!check_transport(transport, str, index, &init, &mac)) 613 continue; 614 if(init != NULL){ 615 eth_configure(index, init, mac, transport); 616 kfree(init); 617 } 618 found = 1; 619 break; 620 } 621 622 spin_unlock(&transports_lock); 623 return found; 624} 625 626static int eth_setup(char *str) 627{ 628 struct eth_init *new; 629 char *error; 630 int n, err; 631 632 err = eth_parse(str, &n, &str, &error); 633 if(err){ 634 printk(KERN_ERR "eth_setup - Couldn't parse '%s' : %s\n", 635 str, error); 636 return 1; 637 } 638 639 new = alloc_bootmem(sizeof(*new)); 640 if (new == NULL){ 641 printk("eth_init : alloc_bootmem failed\n"); 642 return 1; 643 } 644 645 INIT_LIST_HEAD(&new->list); 646 new->index = n; 647 new->init = str; 648 649 list_add_tail(&new->list, ð_cmd_line); 650 return 1; 651} 652 653__setup("eth", eth_setup); 654__uml_help(eth_setup, 655"eth[0-9]+=<transport>,<options>\n" 656" Configure a network device.\n\n" 657); 658 659static int net_config(char *str, char **error_out) 660{ 661 int n, err; 662 663 err = eth_parse(str, &n, &str, error_out); 664 if(err) 665 return err; 666 667 /* This string is broken up and the pieces used by the underlying 668 * driver. So, it is freed only if eth_setup_common fails. 669 */ 670 str = kstrdup(str, GFP_KERNEL); 671 if(str == NULL){ 672 *error_out = "net_config failed to strdup string"; 673 return -ENOMEM; 674 } 675 err = !eth_setup_common(str, n); 676 if(err) 677 kfree(str); 678 return(err); 679} 680 681static int net_id(char **str, int *start_out, int *end_out) 682{ 683 char *end; 684 int n; 685 686 n = simple_strtoul(*str, &end, 0); 687 if((*end != '\0') || (end == *str)) 688 return -1; 689 690 *start_out = n; 691 *end_out = n; 692 *str = end; 693 return n; 694} 695 696static int net_remove(int n, char **error_out) 697{ 698 struct uml_net *device; 699 struct net_device *dev; 700 struct uml_net_private *lp; 701 702 device = find_device(n); 703 if(device == NULL) 704 return -ENODEV; 705 706 dev = device->dev; 707 lp = dev->priv; 708 if(lp->fd > 0) 709 return -EBUSY; 710 unregister_netdev(dev); 711 platform_device_unregister(&device->pdev); 712 713 return 0; 714} 715 716static struct mc_device net_mc = { 717 .list = LIST_HEAD_INIT(net_mc.list), 718 .name = "eth", 719 .config = net_config, 720 .get_config = NULL, 721 .id = net_id, 722 .remove = net_remove, 723}; 724 725static int uml_inetaddr_event(struct notifier_block *this, unsigned long event, 726 void *ptr) 727{ 728 struct in_ifaddr *ifa = ptr; 729 struct net_device *dev = ifa->ifa_dev->dev; 730 struct uml_net_private *lp; 731 void (*proc)(unsigned char *, unsigned char *, void *); 732 unsigned char addr_buf[4], netmask_buf[4]; 733 734 if(dev->open != uml_net_open) 735 return NOTIFY_DONE; 736 737 lp = dev->priv; 738 739 proc = NULL; 740 switch (event){ 741 case NETDEV_UP: 742 proc = lp->add_address; 743 break; 744 case NETDEV_DOWN: 745 proc = lp->delete_address; 746 break; 747 } 748 if(proc != NULL){ 749 memcpy(addr_buf, &ifa->ifa_address, sizeof(addr_buf)); 750 memcpy(netmask_buf, &ifa->ifa_mask, sizeof(netmask_buf)); 751 (*proc)(addr_buf, netmask_buf, &lp->user); 752 } 753 return NOTIFY_DONE; 754} 755 756/* uml_net_init shouldn't be called twice on two CPUs at the same time */ 757struct notifier_block uml_inetaddr_notifier = { 758 .notifier_call = uml_inetaddr_event, 759}; 760 761static int uml_net_init(void) 762{ 763 struct list_head *ele; 764 struct uml_net_private *lp; 765 struct in_device *ip; 766 struct in_ifaddr *in; 767 768 mconsole_register_dev(&net_mc); 769 register_inetaddr_notifier(¨_inetaddr_notifier); 770 771 /* Devices may have been opened already, so the uml_inetaddr_notifier 772 * didn't get a chance to run for them. This fakes it so that 773 * addresses which have already been set up get handled properly. 774 */ 775 spin_lock(&opened_lock); 776 list_for_each(ele, &opened){ 777 lp = list_entry(ele, struct uml_net_private, list); 778 ip = lp->dev->ip_ptr; 779 if(ip == NULL) 780 continue; 781 in = ip->ifa_list; 782 while(in != NULL){ 783 uml_inetaddr_event(NULL, NETDEV_UP, in); 784 in = in->ifa_next; 785 } 786 } 787 spin_unlock(&opened_lock); 788 789 return 0; 790} 791 792__initcall(uml_net_init); 793 794static void close_devices(void) 795{ 796 struct list_head *ele; 797 struct uml_net_private *lp; 798 799 spin_lock(&opened_lock); 800 list_for_each(ele, &opened){ 801 lp = list_entry(ele, struct uml_net_private, list); 802 free_irq(lp->dev->irq, lp->dev); 803 if((lp->close != NULL) && (lp->fd >= 0)) 804 (*lp->close)(lp->fd, &lp->user); 805 if(lp->remove != NULL) 806 (*lp->remove)(&lp->user); 807 } 808 spin_unlock(&opened_lock); 809} 810 811__uml_exitcall(close_devices); 812 813struct sk_buff *ether_adjust_skb(struct sk_buff *skb, int extra) 814{ 815 if((skb != NULL) && (skb_tailroom(skb) < extra)){ 816 struct sk_buff *skb2; 817 818 skb2 = skb_copy_expand(skb, 0, extra, GFP_ATOMIC); 819 dev_kfree_skb(skb); 820 skb = skb2; 821 } 822 if(skb != NULL) skb_put(skb, extra); 823 return(skb); 824} 825 826void iter_addresses(void *d, void (*cb)(unsigned char *, unsigned char *, 827 void *), 828 void *arg) 829{ 830 struct net_device *dev = d; 831 struct in_device *ip = dev->ip_ptr; 832 struct in_ifaddr *in; 833 unsigned char address[4], netmask[4]; 834 835 if(ip == NULL) return; 836 in = ip->ifa_list; 837 while(in != NULL){ 838 memcpy(address, &in->ifa_address, sizeof(address)); 839 memcpy(netmask, &in->ifa_mask, sizeof(netmask)); 840 (*cb)(address, netmask, arg); 841 in = in->ifa_next; 842 } 843} 844 845int dev_netmask(void *d, void *m) 846{ 847 struct net_device *dev = d; 848 struct in_device *ip = dev->ip_ptr; 849 struct in_ifaddr *in; 850 __be32 *mask_out = m; 851 852 if(ip == NULL) 853 return(1); 854 855 in = ip->ifa_list; 856 if(in == NULL) 857 return(1); 858 859 *mask_out = in->ifa_mask; 860 return(0); 861} 862 863void *get_output_buffer(int *len_out) 864{ 865 void *ret; 866 867 ret = (void *) __get_free_pages(GFP_KERNEL, 0); 868 if(ret) *len_out = PAGE_SIZE; 869 else *len_out = 0; 870 return ret; 871} 872 873void free_output_buffer(void *buffer) 874{ 875 free_pages((unsigned long) buffer, 0); 876} 877 878int tap_setup_common(char *str, char *type, char **dev_name, char **mac_out, 879 char **gate_addr) 880{ 881 char *remain; 882 883 remain = split_if_spec(str, dev_name, mac_out, gate_addr, NULL); 884 if(remain != NULL){ 885 printk("tap_setup_common - Extra garbage on specification : " 886 "'%s'\n", remain); 887 return(1); 888 } 889 890 return(0); 891} 892 893unsigned short eth_protocol(struct sk_buff *skb) 894{ 895 return(eth_type_trans(skb, skb->dev)); 896} 897