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