Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
hippi.c
Go to the documentation of this file.
1 /*
2  * INET An implementation of the TCP/IP protocol suite for the LINUX
3  * operating system. INET is implemented using the BSD Socket
4  * interface as the means of communication with the user level.
5  *
6  * HIPPI-type device handling.
7  *
8  * Version: @(#)hippi.c 1.0.0 05/29/97
9  *
10  * Authors: Ross Biro
11  * Fred N. van Kempen, <[email protected]>
12  * Mark Evans, <[email protected]>
13  * Florian La Roche, <[email protected]>
14  * Alan Cox, <[email protected]>
15  * Jes Sorensen, <[email protected]>
16  *
17  * This program is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU General Public License
19  * as published by the Free Software Foundation; either version
20  * 2 of the License, or (at your option) any later version.
21  */
22 
23 #include <linux/module.h>
24 #include <linux/types.h>
25 #include <linux/kernel.h>
26 #include <linux/string.h>
27 #include <linux/mm.h>
28 #include <linux/socket.h>
29 #include <linux/in.h>
30 #include <linux/inet.h>
31 #include <linux/netdevice.h>
32 #include <linux/hippidevice.h>
33 #include <linux/skbuff.h>
34 #include <linux/errno.h>
35 #include <net/arp.h>
36 #include <net/sock.h>
37 #include <asm/uaccess.h>
38 
39 /*
40  * Create the HIPPI MAC header for an arbitrary protocol layer
41  *
42  * saddr=NULL means use device source address
43  * daddr=NULL means leave destination address (eg unresolved arp)
44  */
45 
46 static int hippi_header(struct sk_buff *skb, struct net_device *dev,
47  unsigned short type,
48  const void *daddr, const void *saddr, unsigned int len)
49 {
50  struct hippi_hdr *hip = (struct hippi_hdr *)skb_push(skb, HIPPI_HLEN);
51  struct hippi_cb *hcb = (struct hippi_cb *) skb->cb;
52 
53  if (!len){
54  len = skb->len - HIPPI_HLEN;
55  printk("hippi_header(): length not supplied\n");
56  }
57 
58  /*
59  * Due to the stupidity of the little endian byte-order we
60  * have to set the fp field this way.
61  */
62  hip->fp.fixed = htonl(0x04800018);
63  hip->fp.d2_size = htonl(len + 8);
64  hip->le.fc = 0;
65  hip->le.double_wide = 0; /* only HIPPI 800 for the time being */
66  hip->le.message_type = 0; /* Data PDU */
67 
68  hip->le.dest_addr_type = 2; /* 12 bit SC address */
69  hip->le.src_addr_type = 2; /* 12 bit SC address */
70 
71  memcpy(hip->le.src_switch_addr, dev->dev_addr + 3, 3);
72  memset(&hip->le.reserved, 0, 16);
73 
74  hip->snap.dsap = HIPPI_EXTENDED_SAP;
75  hip->snap.ssap = HIPPI_EXTENDED_SAP;
76  hip->snap.ctrl = HIPPI_UI_CMD;
77  hip->snap.oui[0] = 0x00;
78  hip->snap.oui[1] = 0x00;
79  hip->snap.oui[2] = 0x00;
80  hip->snap.ethertype = htons(type);
81 
82  if (daddr)
83  {
84  memcpy(hip->le.dest_switch_addr, daddr + 3, 3);
85  memcpy(&hcb->ifield, daddr + 2, 4);
86  return HIPPI_HLEN;
87  }
88  hcb->ifield = 0;
89  return -((int)HIPPI_HLEN);
90 }
91 
92 
93 /*
94  * Rebuild the HIPPI MAC header. This is called after an ARP has
95  * completed on this sk_buff. We now let ARP fill in the other fields.
96  */
97 
98 static int hippi_rebuild_header(struct sk_buff *skb)
99 {
100  struct hippi_hdr *hip = (struct hippi_hdr *)skb->data;
101 
102  /*
103  * Only IP is currently supported
104  */
105 
106  if(hip->snap.ethertype != htons(ETH_P_IP))
107  {
108  printk(KERN_DEBUG "%s: unable to resolve type %X addresses.\n",skb->dev->name,ntohs(hip->snap.ethertype));
109  return 0;
110  }
111 
112  /*
113  * We don't support dynamic ARP on HIPPI, but we use the ARP
114  * static ARP tables to hold the I-FIELDs.
115  */
116  return arp_find(hip->le.daddr, skb);
117 }
118 
119 
120 /*
121  * Determine the packet's protocol ID.
122  */
123 
124 __be16 hippi_type_trans(struct sk_buff *skb, struct net_device *dev)
125 {
126  struct hippi_hdr *hip;
127 
128  /*
129  * This is actually wrong ... question is if we really should
130  * set the raw address here.
131  */
132  skb->dev = dev;
133  skb_reset_mac_header(skb);
134  hip = (struct hippi_hdr *)skb_mac_header(skb);
135  skb_pull(skb, HIPPI_HLEN);
136 
137  /*
138  * No fancy promisc stuff here now.
139  */
140 
141  return hip->snap.ethertype;
142 }
143 
145 
146 int hippi_change_mtu(struct net_device *dev, int new_mtu)
147 {
148  /*
149  * HIPPI's got these nice large MTUs.
150  */
151  if ((new_mtu < 68) || (new_mtu > 65280))
152  return -EINVAL;
153  dev->mtu = new_mtu;
154  return 0;
155 }
157 
158 /*
159  * For HIPPI we will actually use the lower 4 bytes of the hardware
160  * address as the I-FIELD rather than the actual hardware address.
161  */
162 int hippi_mac_addr(struct net_device *dev, void *p)
163 {
164  struct sockaddr *addr = p;
165  if (netif_running(dev))
166  return -EBUSY;
167  memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
168  return 0;
169 }
171 
173 {
174  /* Never send broadcast/multicast ARP messages */
175  p->mcast_probes = 0;
176 
177  /* In IPv6 unicast probes are valid even on NBMA,
178  * because they are encapsulated in normal IPv6 protocol.
179  * Should be a generic flag.
180  */
181  if (p->tbl->family != AF_INET6)
182  p->ucast_probes = 0;
183  return 0;
184 }
186 
187 static const struct header_ops hippi_header_ops = {
188  .create = hippi_header,
189  .rebuild = hippi_rebuild_header,
190 };
191 
192 
193 static void hippi_setup(struct net_device *dev)
194 {
195  dev->header_ops = &hippi_header_ops;
196 
197  /*
198  * We don't support HIPPI `ARP' for the time being, and probably
199  * never will unless someone else implements it. However we
200  * still need a fake ARPHRD to make ifconfig and friends play ball.
201  */
202  dev->type = ARPHRD_HIPPI;
204  dev->mtu = 65280;
205  dev->addr_len = HIPPI_ALEN;
206  dev->tx_queue_len = 25 /* 5 */;
207  memset(dev->broadcast, 0xFF, HIPPI_ALEN);
208 
209 
210  /*
211  * HIPPI doesn't support broadcast+multicast and we only use
212  * static ARP tables. ARP is disabled by hippi_neigh_setup_dev.
213  */
214  dev->flags = 0;
215 }
216 
229 struct net_device *alloc_hippi_dev(int sizeof_priv)
230 {
231  return alloc_netdev(sizeof_priv, "hip%d", hippi_setup);
232 }
233