Diff markup
1 /* 1 /*
2 * DECnet An implementation of the DECne 2 * DECnet An implementation of the DECnet protocol suite for the LINUX
3 * operating system. DECnet is i 3 * operating system. DECnet is implemented using the BSD Socket
4 * interface as the means of comm 4 * interface as the means of communication with the user level.
5 * 5 *
6 * DECnet Device Layer 6 * DECnet Device Layer
7 * 7 *
8 * Authors: Steve Whitehouse <SteveW@ACM.o 8 * Authors: Steve Whitehouse <SteveW@ACM.org>
9 * Eduardo Marcelo Serrat <emserr 9 * Eduardo Marcelo Serrat <emserrat@geocities.com>
10 * 10 *
11 * Changes: 11 * Changes:
12 * Steve Whitehouse : Devices now see 12 * Steve Whitehouse : Devices now see incoming frames so they
13 * can mark on who 13 * can mark on who it came from.
14 * Steve Whitehouse : Fixed bug in cr 14 * Steve Whitehouse : Fixed bug in creating neighbours. Each neighbour
15 * can now have a 15 * can now have a device specific setup func.
16 * Steve Whitehouse : Added /proc/sys 16 * Steve Whitehouse : Added /proc/sys/net/decnet/conf/<dev>/
17 * Steve Whitehouse : Fixed bug which 17 * Steve Whitehouse : Fixed bug which sometimes killed timer
18 * Steve Whitehouse : Multiple ifaddr 18 * Steve Whitehouse : Multiple ifaddr support
19 * Steve Whitehouse : SIOCGIFCONF is 19 * Steve Whitehouse : SIOCGIFCONF is now a compile time option
20 * Steve Whitehouse : /proc/sys/net/d 20 * Steve Whitehouse : /proc/sys/net/decnet/conf/<sys>/forwarding
21 * Steve Whitehouse : Removed timer1 21 * Steve Whitehouse : Removed timer1 - it's a user space issue now
22 * Patrick Caulfield : Fixed router he 22 * Patrick Caulfield : Fixed router hello message format
23 * Steve Whitehouse : Got rid of cons 23 * Steve Whitehouse : Got rid of constant sizes for blksize for
24 * devices. All mt 24 * devices. All mtu based now.
25 */ 25 */
26 26
27 #include <linux/config.h> !! 27 #include <linux/capability.h>
28 #include <linux/module.h> 28 #include <linux/module.h>
29 #include <linux/moduleparam.h> 29 #include <linux/moduleparam.h>
30 #include <linux/init.h> 30 #include <linux/init.h>
31 #include <linux/net.h> 31 #include <linux/net.h>
32 #include <linux/netdevice.h> 32 #include <linux/netdevice.h>
33 #include <linux/proc_fs.h> 33 #include <linux/proc_fs.h>
34 #include <linux/seq_file.h> 34 #include <linux/seq_file.h>
35 #include <linux/timer.h> 35 #include <linux/timer.h>
36 #include <linux/string.h> 36 #include <linux/string.h>
>> 37 #include <linux/if_addr.h>
37 #include <linux/if_arp.h> 38 #include <linux/if_arp.h>
38 #include <linux/if_ether.h> 39 #include <linux/if_ether.h>
39 #include <linux/skbuff.h> 40 #include <linux/skbuff.h>
40 #include <linux/rtnetlink.h> <<
41 #include <linux/sysctl.h> 41 #include <linux/sysctl.h>
42 #include <linux/notifier.h> 42 #include <linux/notifier.h>
43 #include <asm/uaccess.h> 43 #include <asm/uaccess.h>
44 #include <asm/system.h> 44 #include <asm/system.h>
>> 45 #include <net/net_namespace.h>
45 #include <net/neighbour.h> 46 #include <net/neighbour.h>
46 #include <net/dst.h> 47 #include <net/dst.h>
47 #include <net/flow.h> 48 #include <net/flow.h>
>> 49 #include <net/fib_rules.h>
>> 50 #include <net/netlink.h>
48 #include <net/dn.h> 51 #include <net/dn.h>
49 #include <net/dn_dev.h> 52 #include <net/dn_dev.h>
50 #include <net/dn_route.h> 53 #include <net/dn_route.h>
51 #include <net/dn_neigh.h> 54 #include <net/dn_neigh.h>
52 #include <net/dn_fib.h> 55 #include <net/dn_fib.h>
53 56
54 #define DN_IFREQ_SIZE (sizeof(struct ifreq) - 57 #define DN_IFREQ_SIZE (sizeof(struct ifreq) - sizeof(struct sockaddr) + sizeof(struct sockaddr_dn))
55 58
56 static char dn_rt_all_end_mcast[ETH_ALEN] = {0 59 static char dn_rt_all_end_mcast[ETH_ALEN] = {0xAB,0x00,0x00,0x04,0x00,0x00};
57 static char dn_rt_all_rt_mcast[ETH_ALEN] = {0 60 static char dn_rt_all_rt_mcast[ETH_ALEN] = {0xAB,0x00,0x00,0x03,0x00,0x00};
58 static char dn_hiord[ETH_ALEN] = {0 61 static char dn_hiord[ETH_ALEN] = {0xAA,0x00,0x04,0x00,0x00,0x00};
59 static unsigned char dn_eco_version[3] = {0 62 static unsigned char dn_eco_version[3] = {0x02,0x00,0x00};
60 63
61 extern struct neigh_table dn_neigh_table; 64 extern struct neigh_table dn_neigh_table;
62 65
63 /* 66 /*
64 * decnet_address is kept in network order. 67 * decnet_address is kept in network order.
65 */ 68 */
66 dn_address decnet_address = 0; !! 69 __le16 decnet_address = 0;
67 70
68 static DEFINE_RWLOCK(dndev_lock); 71 static DEFINE_RWLOCK(dndev_lock);
69 static struct net_device *decnet_default_devic 72 static struct net_device *decnet_default_device;
70 static struct notifier_block *dnaddr_chain; !! 73 static BLOCKING_NOTIFIER_HEAD(dnaddr_chain);
71 74
72 static struct dn_dev *dn_dev_create(struct net 75 static struct dn_dev *dn_dev_create(struct net_device *dev, int *err);
73 static void dn_dev_delete(struct net_device *d 76 static void dn_dev_delete(struct net_device *dev);
74 static void rtmsg_ifa(int event, struct dn_ifa !! 77 static void dn_ifaddr_notify(int event, struct dn_ifaddr *ifa);
75 78
76 static int dn_eth_up(struct net_device *); 79 static int dn_eth_up(struct net_device *);
77 static void dn_eth_down(struct net_device *); 80 static void dn_eth_down(struct net_device *);
78 static void dn_send_brd_hello(struct net_devic 81 static void dn_send_brd_hello(struct net_device *dev, struct dn_ifaddr *ifa);
79 static void dn_send_ptp_hello(struct net_devic 82 static void dn_send_ptp_hello(struct net_device *dev, struct dn_ifaddr *ifa);
80 83
81 static struct dn_dev_parms dn_dev_list[] = { 84 static struct dn_dev_parms dn_dev_list[] = {
82 { 85 {
83 .type = ARPHRD_ETHER, /* Ether 86 .type = ARPHRD_ETHER, /* Ethernet */
84 .mode = DN_DEV_BCAST, 87 .mode = DN_DEV_BCAST,
85 .state = DN_DEV_S_RU, 88 .state = DN_DEV_S_RU,
86 .t2 = 1, 89 .t2 = 1,
87 .t3 = 10, 90 .t3 = 10,
88 .name = "ethernet", 91 .name = "ethernet",
89 .ctl_name = NET_DECNET_CONF_ETHER, 92 .ctl_name = NET_DECNET_CONF_ETHER,
90 .up = dn_eth_up, 93 .up = dn_eth_up,
91 .down = dn_eth_down, 94 .down = dn_eth_down,
92 .timer3 = dn_send_brd_hello, 95 .timer3 = dn_send_brd_hello,
93 }, 96 },
94 { 97 {
95 .type = ARPHRD_IPGRE, /* DECne 98 .type = ARPHRD_IPGRE, /* DECnet tunneled over GRE in IP */
96 .mode = DN_DEV_BCAST, 99 .mode = DN_DEV_BCAST,
97 .state = DN_DEV_S_RU, 100 .state = DN_DEV_S_RU,
98 .t2 = 1, 101 .t2 = 1,
99 .t3 = 10, 102 .t3 = 10,
100 .name = "ipgre", 103 .name = "ipgre",
101 .ctl_name = NET_DECNET_CONF_GRE, 104 .ctl_name = NET_DECNET_CONF_GRE,
102 .timer3 = dn_send_brd_hello, 105 .timer3 = dn_send_brd_hello,
103 }, 106 },
104 #if 0 107 #if 0
105 { 108 {
106 .type = ARPHRD_X25, /* Bog sta 109 .type = ARPHRD_X25, /* Bog standard X.25 */
107 .mode = DN_DEV_UCAST, 110 .mode = DN_DEV_UCAST,
108 .state = DN_DEV_S_DS, 111 .state = DN_DEV_S_DS,
109 .t2 = 1, 112 .t2 = 1,
110 .t3 = 120, 113 .t3 = 120,
111 .name = "x25", 114 .name = "x25",
112 .ctl_name = NET_DECNET_CONF_X25, 115 .ctl_name = NET_DECNET_CONF_X25,
113 .timer3 = dn_send_ptp_hello, 116 .timer3 = dn_send_ptp_hello,
114 }, 117 },
115 #endif 118 #endif
116 #if 0 119 #if 0
117 { 120 {
118 .type = ARPHRD_PPP, /* DECnet 121 .type = ARPHRD_PPP, /* DECnet over PPP */
119 .mode = DN_DEV_BCAST, 122 .mode = DN_DEV_BCAST,
120 .state = DN_DEV_S_RU, 123 .state = DN_DEV_S_RU,
121 .t2 = 1, 124 .t2 = 1,
122 .t3 = 10, 125 .t3 = 10,
123 .name = "ppp", 126 .name = "ppp",
124 .ctl_name = NET_DECNET_CONF_PPP, 127 .ctl_name = NET_DECNET_CONF_PPP,
125 .timer3 = dn_send_brd_hello, 128 .timer3 = dn_send_brd_hello,
126 }, 129 },
127 #endif 130 #endif
128 { 131 {
129 .type = ARPHRD_DDCMP, /* DECne 132 .type = ARPHRD_DDCMP, /* DECnet over DDCMP */
130 .mode = DN_DEV_UCAST, 133 .mode = DN_DEV_UCAST,
131 .state = DN_DEV_S_DS, 134 .state = DN_DEV_S_DS,
132 .t2 = 1, 135 .t2 = 1,
133 .t3 = 120, 136 .t3 = 120,
134 .name = "ddcmp", 137 .name = "ddcmp",
135 .ctl_name = NET_DECNET_CONF_DDCMP, 138 .ctl_name = NET_DECNET_CONF_DDCMP,
136 .timer3 = dn_send_ptp_hello, 139 .timer3 = dn_send_ptp_hello,
137 }, 140 },
138 { 141 {
139 .type = ARPHRD_LOOPBACK, /* Lo 142 .type = ARPHRD_LOOPBACK, /* Loopback interface - always last */
140 .mode = DN_DEV_BCAST, 143 .mode = DN_DEV_BCAST,
141 .state = DN_DEV_S_RU, 144 .state = DN_DEV_S_RU,
142 .t2 = 1, 145 .t2 = 1,
143 .t3 = 10, 146 .t3 = 10,
144 .name = "loopback", 147 .name = "loopback",
145 .ctl_name = NET_DECNET_CONF_LOOPBA 148 .ctl_name = NET_DECNET_CONF_LOOPBACK,
146 .timer3 = dn_send_brd_hello, 149 .timer3 = dn_send_brd_hello,
147 } 150 }
148 }; 151 };
149 152
150 #define DN_DEV_LIST_SIZE (sizeof(dn_dev_list)/ !! 153 #define DN_DEV_LIST_SIZE ARRAY_SIZE(dn_dev_list)
151 154
152 #define DN_DEV_PARMS_OFFSET(x) ((int) ((char * !! 155 #define DN_DEV_PARMS_OFFSET(x) offsetof(struct dn_dev_parms, x)
153 156
154 #ifdef CONFIG_SYSCTL 157 #ifdef CONFIG_SYSCTL
155 158
156 static int min_t2[] = { 1 }; 159 static int min_t2[] = { 1 };
157 static int max_t2[] = { 60 }; /* No max specif 160 static int max_t2[] = { 60 }; /* No max specified, but this seems sensible */
158 static int min_t3[] = { 1 }; 161 static int min_t3[] = { 1 };
159 static int max_t3[] = { 8191 }; /* Must fit in 162 static int max_t3[] = { 8191 }; /* Must fit in 16 bits when multiplied by BCT3MULT or T3MULT */
160 163
161 static int min_priority[1]; 164 static int min_priority[1];
162 static int max_priority[] = { 127 }; /* From D 165 static int max_priority[] = { 127 }; /* From DECnet spec */
163 166
164 static int dn_forwarding_proc(ctl_table *, int 167 static int dn_forwarding_proc(ctl_table *, int, struct file *,
165 void __user *, size_t 168 void __user *, size_t *, loff_t *);
166 static int dn_forwarding_sysctl(ctl_table *tab !! 169 static int dn_forwarding_sysctl(ctl_table *table,
167 void __user *oldval, s 170 void __user *oldval, size_t __user *oldlenp,
168 void __user *newval, s !! 171 void __user *newval, size_t newlen);
169 void **context); <<
170 172
171 static struct dn_dev_sysctl_table { 173 static struct dn_dev_sysctl_table {
172 struct ctl_table_header *sysctl_header 174 struct ctl_table_header *sysctl_header;
173 ctl_table dn_dev_vars[5]; 175 ctl_table dn_dev_vars[5];
174 ctl_table dn_dev_dev[2]; <<
175 ctl_table dn_dev_conf_dir[2]; <<
176 ctl_table dn_dev_proto_dir[2]; <<
177 ctl_table dn_dev_root_dir[2]; <<
178 } dn_dev_sysctl = { 176 } dn_dev_sysctl = {
179 NULL, 177 NULL,
180 { 178 {
181 { 179 {
182 .ctl_name = NET_DECNET_CONF_DE 180 .ctl_name = NET_DECNET_CONF_DEV_FORWARDING,
183 .procname = "forwarding", 181 .procname = "forwarding",
184 .data = (void *)DN_DEV_PARMS_O 182 .data = (void *)DN_DEV_PARMS_OFFSET(forwarding),
185 .maxlen = sizeof(int), 183 .maxlen = sizeof(int),
186 .mode = 0644, 184 .mode = 0644,
187 .proc_handler = dn_forwarding_ 185 .proc_handler = dn_forwarding_proc,
188 .strategy = dn_forwarding_sysc 186 .strategy = dn_forwarding_sysctl,
189 }, 187 },
190 { 188 {
191 .ctl_name = NET_DECNET_CONF_DE 189 .ctl_name = NET_DECNET_CONF_DEV_PRIORITY,
192 .procname = "priority", 190 .procname = "priority",
193 .data = (void *)DN_DEV_PARMS_O 191 .data = (void *)DN_DEV_PARMS_OFFSET(priority),
194 .maxlen = sizeof(int), 192 .maxlen = sizeof(int),
195 .mode = 0644, 193 .mode = 0644,
196 .proc_handler = proc_dointvec_ 194 .proc_handler = proc_dointvec_minmax,
197 .strategy = sysctl_intvec, 195 .strategy = sysctl_intvec,
198 .extra1 = &min_priority, 196 .extra1 = &min_priority,
199 .extra2 = &max_priority 197 .extra2 = &max_priority
200 }, 198 },
201 { 199 {
202 .ctl_name = NET_DECNET_CONF_DE 200 .ctl_name = NET_DECNET_CONF_DEV_T2,
203 .procname = "t2", 201 .procname = "t2",
204 .data = (void *)DN_DEV_PARMS_O 202 .data = (void *)DN_DEV_PARMS_OFFSET(t2),
205 .maxlen = sizeof(int), 203 .maxlen = sizeof(int),
206 .mode = 0644, 204 .mode = 0644,
207 .proc_handler = proc_dointvec_ 205 .proc_handler = proc_dointvec_minmax,
208 .strategy = sysctl_intvec, 206 .strategy = sysctl_intvec,
209 .extra1 = &min_t2, 207 .extra1 = &min_t2,
210 .extra2 = &max_t2 208 .extra2 = &max_t2
211 }, 209 },
212 { 210 {
213 .ctl_name = NET_DECNET_CONF_DE 211 .ctl_name = NET_DECNET_CONF_DEV_T3,
214 .procname = "t3", 212 .procname = "t3",
215 .data = (void *)DN_DEV_PARMS_O 213 .data = (void *)DN_DEV_PARMS_OFFSET(t3),
216 .maxlen = sizeof(int), 214 .maxlen = sizeof(int),
217 .mode = 0644, 215 .mode = 0644,
218 .proc_handler = proc_dointvec_ 216 .proc_handler = proc_dointvec_minmax,
219 .strategy = sysctl_intvec, 217 .strategy = sysctl_intvec,
220 .extra1 = &min_t3, 218 .extra1 = &min_t3,
221 .extra2 = &max_t3 219 .extra2 = &max_t3
222 }, 220 },
223 {0} 221 {0}
224 }, 222 },
225 {{ <<
226 .ctl_name = 0, <<
227 .procname = "", <<
228 .mode = 0555, <<
229 .child = dn_dev_sysctl.dn_dev_ <<
230 }, {0}}, <<
231 {{ <<
232 .ctl_name = NET_DECNET_CONF, <<
233 .procname = "conf", <<
234 .mode = 0555, <<
235 .child = dn_dev_sysctl.dn_dev_ <<
236 }, {0}}, <<
237 {{ <<
238 .ctl_name = NET_DECNET, <<
239 .procname = "decnet", <<
240 .mode = 0555, <<
241 .child = dn_dev_sysctl.dn_dev_ <<
242 }, {0}}, <<
243 {{ <<
244 .ctl_name = CTL_NET, <<
245 .procname = "net", <<
246 .mode = 0555, <<
247 .child = dn_dev_sysctl.dn_dev_ <<
248 }, {0}} <<
249 }; 223 };
250 224
251 static void dn_dev_sysctl_register(struct net_ 225 static void dn_dev_sysctl_register(struct net_device *dev, struct dn_dev_parms *parms)
252 { 226 {
253 struct dn_dev_sysctl_table *t; 227 struct dn_dev_sysctl_table *t;
254 int i; 228 int i;
255 229
256 t = kmalloc(sizeof(*t), GFP_KERNEL); !! 230 #define DN_CTL_PATH_DEV 3
>> 231
>> 232 struct ctl_path dn_ctl_path[] = {
>> 233 { .procname = "net", .ctl_name = CTL_NET, },
>> 234 { .procname = "decnet", .ctl_name = NET_DECNET, },
>> 235 { .procname = "conf", .ctl_name = NET_DECNET_CONF, },
>> 236 { /* to be set */ },
>> 237 { },
>> 238 };
>> 239
>> 240 t = kmemdup(&dn_dev_sysctl, sizeof(*t), GFP_KERNEL);
257 if (t == NULL) 241 if (t == NULL)
258 return; 242 return;
259 243
260 memcpy(t, &dn_dev_sysctl, sizeof(*t)); <<
261 <<
262 for(i = 0; i < ARRAY_SIZE(t->dn_dev_va 244 for(i = 0; i < ARRAY_SIZE(t->dn_dev_vars) - 1; i++) {
263 long offset = (long)t->dn_dev_ 245 long offset = (long)t->dn_dev_vars[i].data;
264 t->dn_dev_vars[i].data = ((cha 246 t->dn_dev_vars[i].data = ((char *)parms) + offset;
265 t->dn_dev_vars[i].de = NULL; <<
266 } 247 }
267 248
268 if (dev) { 249 if (dev) {
269 t->dn_dev_dev[0].procname = de !! 250 dn_ctl_path[DN_CTL_PATH_DEV].procname = dev->name;
270 t->dn_dev_dev[0].ctl_name = de !! 251 dn_ctl_path[DN_CTL_PATH_DEV].ctl_name = dev->ifindex;
271 } else { 252 } else {
272 t->dn_dev_dev[0].procname = pa !! 253 dn_ctl_path[DN_CTL_PATH_DEV].procname = parms->name;
273 t->dn_dev_dev[0].ctl_name = pa !! 254 dn_ctl_path[DN_CTL_PATH_DEV].ctl_name = parms->ctl_name;
274 } 255 }
275 256
276 t->dn_dev_dev[0].child = t->dn_dev_var <<
277 t->dn_dev_dev[0].de = NULL; <<
278 t->dn_dev_conf_dir[0].child = t->dn_de <<
279 t->dn_dev_conf_dir[0].de = NULL; <<
280 t->dn_dev_proto_dir[0].child = t->dn_d <<
281 t->dn_dev_proto_dir[0].de = NULL; <<
282 t->dn_dev_root_dir[0].child = t->dn_de <<
283 t->dn_dev_root_dir[0].de = NULL; <<
284 t->dn_dev_vars[0].extra1 = (void *)dev 257 t->dn_dev_vars[0].extra1 = (void *)dev;
285 258
286 t->sysctl_header = register_sysctl_tab !! 259 t->sysctl_header = register_sysctl_paths(dn_ctl_path, t->dn_dev_vars);
287 if (t->sysctl_header == NULL) 260 if (t->sysctl_header == NULL)
288 kfree(t); 261 kfree(t);
289 else 262 else
290 parms->sysctl = t; 263 parms->sysctl = t;
291 } 264 }
292 265
293 static void dn_dev_sysctl_unregister(struct dn 266 static void dn_dev_sysctl_unregister(struct dn_dev_parms *parms)
294 { 267 {
295 if (parms->sysctl) { 268 if (parms->sysctl) {
296 struct dn_dev_sysctl_table *t 269 struct dn_dev_sysctl_table *t = parms->sysctl;
297 parms->sysctl = NULL; 270 parms->sysctl = NULL;
298 unregister_sysctl_table(t->sys 271 unregister_sysctl_table(t->sysctl_header);
299 kfree(t); 272 kfree(t);
300 } 273 }
301 } 274 }
302 275
303 static int dn_forwarding_proc(ctl_table *table !! 276 static int dn_forwarding_proc(ctl_table *table, int write,
304 struct file *f 277 struct file *filep,
305 void __user *b 278 void __user *buffer,
306 size_t *lenp, 279 size_t *lenp, loff_t *ppos)
307 { 280 {
308 #ifdef CONFIG_DECNET_ROUTER 281 #ifdef CONFIG_DECNET_ROUTER
309 struct net_device *dev = table->extra1 282 struct net_device *dev = table->extra1;
310 struct dn_dev *dn_db; 283 struct dn_dev *dn_db;
311 int err; 284 int err;
312 int tmp, old; 285 int tmp, old;
313 286
314 if (table->extra1 == NULL) 287 if (table->extra1 == NULL)
315 return -EINVAL; 288 return -EINVAL;
316 289
317 dn_db = dev->dn_ptr; 290 dn_db = dev->dn_ptr;
318 old = dn_db->parms.forwarding; 291 old = dn_db->parms.forwarding;
319 292
320 err = proc_dointvec(table, write, file 293 err = proc_dointvec(table, write, filep, buffer, lenp, ppos);
321 294
322 if ((err >= 0) && write) { 295 if ((err >= 0) && write) {
323 if (dn_db->parms.forwarding < 296 if (dn_db->parms.forwarding < 0)
324 dn_db->parms.forwardin 297 dn_db->parms.forwarding = 0;
325 if (dn_db->parms.forwarding > 298 if (dn_db->parms.forwarding > 2)
326 dn_db->parms.forwardin 299 dn_db->parms.forwarding = 2;
327 /* 300 /*
328 * What an ugly hack this is.. 301 * What an ugly hack this is... its works, just. It
329 * would be nice if sysctl/pro 302 * would be nice if sysctl/proc were just that little
330 * bit more flexible so I don' 303 * bit more flexible so I don't have to write a special
331 * routine, or suffer hacks li 304 * routine, or suffer hacks like this - SJW
332 */ 305 */
333 tmp = dn_db->parms.forwarding; 306 tmp = dn_db->parms.forwarding;
334 dn_db->parms.forwarding = old; 307 dn_db->parms.forwarding = old;
335 if (dn_db->parms.down) 308 if (dn_db->parms.down)
336 dn_db->parms.down(dev) 309 dn_db->parms.down(dev);
337 dn_db->parms.forwarding = tmp; 310 dn_db->parms.forwarding = tmp;
338 if (dn_db->parms.up) 311 if (dn_db->parms.up)
339 dn_db->parms.up(dev); 312 dn_db->parms.up(dev);
340 } 313 }
341 314
342 return err; 315 return err;
343 #else 316 #else
344 return -EINVAL; 317 return -EINVAL;
345 #endif 318 #endif
346 } 319 }
347 320
348 static int dn_forwarding_sysctl(ctl_table *tab !! 321 static int dn_forwarding_sysctl(ctl_table *table,
349 void __user *oldval, s 322 void __user *oldval, size_t __user *oldlenp,
350 void __user *newval, s !! 323 void __user *newval, size_t newlen)
351 void **context) <<
352 { 324 {
353 #ifdef CONFIG_DECNET_ROUTER 325 #ifdef CONFIG_DECNET_ROUTER
354 struct net_device *dev = table->extra1 326 struct net_device *dev = table->extra1;
355 struct dn_dev *dn_db; 327 struct dn_dev *dn_db;
356 int value; 328 int value;
357 329
358 if (table->extra1 == NULL) 330 if (table->extra1 == NULL)
359 return -EINVAL; 331 return -EINVAL;
360 332
361 dn_db = dev->dn_ptr; 333 dn_db = dev->dn_ptr;
362 334
363 if (newval && newlen) { 335 if (newval && newlen) {
364 if (newlen != sizeof(int)) 336 if (newlen != sizeof(int))
365 return -EINVAL; 337 return -EINVAL;
366 338
367 if (get_user(value, (int __use 339 if (get_user(value, (int __user *)newval))
368 return -EFAULT; 340 return -EFAULT;
369 if (value < 0) 341 if (value < 0)
370 return -EINVAL; 342 return -EINVAL;
371 if (value > 2) 343 if (value > 2)
372 return -EINVAL; 344 return -EINVAL;
373 345
374 if (dn_db->parms.down) 346 if (dn_db->parms.down)
375 dn_db->parms.down(dev) 347 dn_db->parms.down(dev);
376 dn_db->parms.forwarding = valu 348 dn_db->parms.forwarding = value;
377 if (dn_db->parms.up) 349 if (dn_db->parms.up)
378 dn_db->parms.up(dev); 350 dn_db->parms.up(dev);
379 } 351 }
380 352
381 return 0; 353 return 0;
382 #else 354 #else
383 return -EINVAL; 355 return -EINVAL;
384 #endif 356 #endif
385 } 357 }
386 358
387 #else /* CONFIG_SYSCTL */ 359 #else /* CONFIG_SYSCTL */
388 static void dn_dev_sysctl_unregister(struct dn 360 static void dn_dev_sysctl_unregister(struct dn_dev_parms *parms)
389 { 361 {
390 } 362 }
391 static void dn_dev_sysctl_register(struct net_ 363 static void dn_dev_sysctl_register(struct net_device *dev, struct dn_dev_parms *parms)
392 { 364 {
393 } 365 }
394 366
395 #endif /* CONFIG_SYSCTL */ 367 #endif /* CONFIG_SYSCTL */
396 368
397 static inline __u16 mtu2blksize(struct net_dev 369 static inline __u16 mtu2blksize(struct net_device *dev)
398 { 370 {
399 u32 blksize = dev->mtu; 371 u32 blksize = dev->mtu;
400 if (blksize > 0xffff) 372 if (blksize > 0xffff)
401 blksize = 0xffff; 373 blksize = 0xffff;
402 374
403 if (dev->type == ARPHRD_ETHER || 375 if (dev->type == ARPHRD_ETHER ||
404 dev->type == ARPHRD_PPP || 376 dev->type == ARPHRD_PPP ||
405 dev->type == ARPHRD_IPGRE || 377 dev->type == ARPHRD_IPGRE ||
406 dev->type == ARPHRD_LOOPBACK) 378 dev->type == ARPHRD_LOOPBACK)
407 blksize -= 2; 379 blksize -= 2;
408 380
409 return (__u16)blksize; 381 return (__u16)blksize;
410 } 382 }
411 383
412 static struct dn_ifaddr *dn_dev_alloc_ifa(void 384 static struct dn_ifaddr *dn_dev_alloc_ifa(void)
413 { 385 {
414 struct dn_ifaddr *ifa; 386 struct dn_ifaddr *ifa;
415 387
416 ifa = kmalloc(sizeof(*ifa), GFP_KERNEL !! 388 ifa = kzalloc(sizeof(*ifa), GFP_KERNEL);
417 <<
418 if (ifa) { <<
419 memset(ifa, 0, sizeof(*ifa)); <<
420 } <<
421 389
422 return ifa; 390 return ifa;
423 } 391 }
424 392
425 static __inline__ void dn_dev_free_ifa(struct 393 static __inline__ void dn_dev_free_ifa(struct dn_ifaddr *ifa)
426 { 394 {
427 kfree(ifa); 395 kfree(ifa);
428 } 396 }
429 397
430 static void dn_dev_del_ifa(struct dn_dev *dn_d 398 static void dn_dev_del_ifa(struct dn_dev *dn_db, struct dn_ifaddr **ifap, int destroy)
431 { 399 {
432 struct dn_ifaddr *ifa1 = *ifap; 400 struct dn_ifaddr *ifa1 = *ifap;
433 unsigned char mac_addr[6]; 401 unsigned char mac_addr[6];
434 struct net_device *dev = dn_db->dev; 402 struct net_device *dev = dn_db->dev;
435 403
436 ASSERT_RTNL(); 404 ASSERT_RTNL();
437 405
438 *ifap = ifa1->ifa_next; 406 *ifap = ifa1->ifa_next;
439 407
440 if (dn_db->dev->type == ARPHRD_ETHER) 408 if (dn_db->dev->type == ARPHRD_ETHER) {
441 if (ifa1->ifa_local != dn_hton !! 409 if (ifa1->ifa_local != dn_eth2dn(dev->dev_addr)) {
442 dn_dn2eth(mac_addr, if 410 dn_dn2eth(mac_addr, ifa1->ifa_local);
443 dev_mc_delete(dev, mac 411 dev_mc_delete(dev, mac_addr, ETH_ALEN, 0);
444 } 412 }
445 } 413 }
446 414
447 rtmsg_ifa(RTM_DELADDR, ifa1); !! 415 dn_ifaddr_notify(RTM_DELADDR, ifa1);
448 notifier_call_chain(&dnaddr_chain, NET !! 416 blocking_notifier_call_chain(&dnaddr_chain, NETDEV_DOWN, ifa1);
449 if (destroy) { 417 if (destroy) {
450 dn_dev_free_ifa(ifa1); 418 dn_dev_free_ifa(ifa1);
451 419
452 if (dn_db->ifa_list == NULL) 420 if (dn_db->ifa_list == NULL)
453 dn_dev_delete(dn_db->d 421 dn_dev_delete(dn_db->dev);
454 } 422 }
455 } 423 }
456 424
457 static int dn_dev_insert_ifa(struct dn_dev *dn 425 static int dn_dev_insert_ifa(struct dn_dev *dn_db, struct dn_ifaddr *ifa)
458 { 426 {
459 struct net_device *dev = dn_db->dev; 427 struct net_device *dev = dn_db->dev;
460 struct dn_ifaddr *ifa1; 428 struct dn_ifaddr *ifa1;
461 unsigned char mac_addr[6]; 429 unsigned char mac_addr[6];
462 430
463 ASSERT_RTNL(); 431 ASSERT_RTNL();
464 432
465 /* Check for duplicates */ !! 433 /* Check for duplicates */
466 for(ifa1 = dn_db->ifa_list; ifa1; ifa1 434 for(ifa1 = dn_db->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
467 if (ifa1->ifa_local == ifa->if 435 if (ifa1->ifa_local == ifa->ifa_local)
468 return -EEXIST; 436 return -EEXIST;
469 } 437 }
470 438
471 if (dev->type == ARPHRD_ETHER) { 439 if (dev->type == ARPHRD_ETHER) {
472 if (ifa->ifa_local != dn_htons !! 440 if (ifa->ifa_local != dn_eth2dn(dev->dev_addr)) {
473 dn_dn2eth(mac_addr, if 441 dn_dn2eth(mac_addr, ifa->ifa_local);
474 dev_mc_add(dev, mac_ad 442 dev_mc_add(dev, mac_addr, ETH_ALEN, 0);
475 dev_mc_upload(dev); <<
476 } 443 }
477 } 444 }
478 445
479 ifa->ifa_next = dn_db->ifa_list; 446 ifa->ifa_next = dn_db->ifa_list;
480 dn_db->ifa_list = ifa; 447 dn_db->ifa_list = ifa;
481 448
482 rtmsg_ifa(RTM_NEWADDR, ifa); !! 449 dn_ifaddr_notify(RTM_NEWADDR, ifa);
483 notifier_call_chain(&dnaddr_chain, NET !! 450 blocking_notifier_call_chain(&dnaddr_chain, NETDEV_UP, ifa);
484 451
485 return 0; 452 return 0;
486 } 453 }
487 454
488 static int dn_dev_set_ifa(struct net_device *d 455 static int dn_dev_set_ifa(struct net_device *dev, struct dn_ifaddr *ifa)
489 { 456 {
490 struct dn_dev *dn_db = dev->dn_ptr; 457 struct dn_dev *dn_db = dev->dn_ptr;
491 int rv; 458 int rv;
492 459
493 if (dn_db == NULL) { 460 if (dn_db == NULL) {
494 int err; 461 int err;
495 dn_db = dn_dev_create(dev, &er 462 dn_db = dn_dev_create(dev, &err);
496 if (dn_db == NULL) 463 if (dn_db == NULL)
497 return err; 464 return err;
498 } 465 }
499 466
500 ifa->ifa_dev = dn_db; 467 ifa->ifa_dev = dn_db;
501 468
502 if (dev->flags & IFF_LOOPBACK) 469 if (dev->flags & IFF_LOOPBACK)
503 ifa->ifa_scope = RT_SCOPE_HOST 470 ifa->ifa_scope = RT_SCOPE_HOST;
504 471
505 rv = dn_dev_insert_ifa(dn_db, ifa); 472 rv = dn_dev_insert_ifa(dn_db, ifa);
506 if (rv) 473 if (rv)
507 dn_dev_free_ifa(ifa); 474 dn_dev_free_ifa(ifa);
508 return rv; 475 return rv;
509 } 476 }
510 477
511 478
512 int dn_dev_ioctl(unsigned int cmd, void __user 479 int dn_dev_ioctl(unsigned int cmd, void __user *arg)
513 { 480 {
514 char buffer[DN_IFREQ_SIZE]; 481 char buffer[DN_IFREQ_SIZE];
515 struct ifreq *ifr = (struct ifreq *)bu 482 struct ifreq *ifr = (struct ifreq *)buffer;
516 struct sockaddr_dn *sdn = (struct sock 483 struct sockaddr_dn *sdn = (struct sockaddr_dn *)&ifr->ifr_addr;
517 struct dn_dev *dn_db; 484 struct dn_dev *dn_db;
518 struct net_device *dev; 485 struct net_device *dev;
519 struct dn_ifaddr *ifa = NULL, **ifap = 486 struct dn_ifaddr *ifa = NULL, **ifap = NULL;
520 int ret = 0; 487 int ret = 0;
521 488
522 if (copy_from_user(ifr, arg, DN_IFREQ_ 489 if (copy_from_user(ifr, arg, DN_IFREQ_SIZE))
523 return -EFAULT; 490 return -EFAULT;
524 ifr->ifr_name[IFNAMSIZ-1] = 0; 491 ifr->ifr_name[IFNAMSIZ-1] = 0;
525 492
526 #ifdef CONFIG_KMOD !! 493 dev_load(&init_net, ifr->ifr_name);
527 dev_load(ifr->ifr_name); <<
528 #endif <<
529 494
530 switch(cmd) { 495 switch(cmd) {
531 case SIOCGIFADDR: 496 case SIOCGIFADDR:
532 break; 497 break;
533 case SIOCSIFADDR: 498 case SIOCSIFADDR:
534 if (!capable(CAP_NET_A 499 if (!capable(CAP_NET_ADMIN))
535 return -EACCES 500 return -EACCES;
536 if (sdn->sdn_family != 501 if (sdn->sdn_family != AF_DECnet)
537 return -EINVAL 502 return -EINVAL;
538 break; 503 break;
539 default: 504 default:
540 return -EINVAL; 505 return -EINVAL;
541 } 506 }
542 507
543 rtnl_lock(); 508 rtnl_lock();
544 509
545 if ((dev = __dev_get_by_name(ifr->ifr_ !! 510 if ((dev = __dev_get_by_name(&init_net, ifr->ifr_name)) == NULL) {
546 ret = -ENODEV; 511 ret = -ENODEV;
547 goto done; 512 goto done;
548 } 513 }
549 514
550 if ((dn_db = dev->dn_ptr) != NULL) { 515 if ((dn_db = dev->dn_ptr) != NULL) {
551 for (ifap = &dn_db->ifa_list; 516 for (ifap = &dn_db->ifa_list; (ifa=*ifap) != NULL; ifap = &ifa->ifa_next)
552 if (strcmp(ifr->ifr_na 517 if (strcmp(ifr->ifr_name, ifa->ifa_label) == 0)
553 break; 518 break;
554 } 519 }
555 520
556 if (ifa == NULL && cmd != SIOCSIFADDR) 521 if (ifa == NULL && cmd != SIOCSIFADDR) {
557 ret = -EADDRNOTAVAIL; 522 ret = -EADDRNOTAVAIL;
558 goto done; 523 goto done;
559 } 524 }
560 525
561 switch(cmd) { 526 switch(cmd) {
562 case SIOCGIFADDR: 527 case SIOCGIFADDR:
563 *((dn_address *)sdn->s !! 528 *((__le16 *)sdn->sdn_nodeaddr) = ifa->ifa_local;
564 goto rarok; 529 goto rarok;
565 530
566 case SIOCSIFADDR: 531 case SIOCSIFADDR:
567 if (!ifa) { 532 if (!ifa) {
568 if ((ifa = dn_ 533 if ((ifa = dn_dev_alloc_ifa()) == NULL) {
569 ret = 534 ret = -ENOBUFS;
570 break; 535 break;
571 } 536 }
572 memcpy(ifa->if 537 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
573 } else { 538 } else {
574 if (ifa->ifa_l 539 if (ifa->ifa_local == dn_saddr2dn(sdn))
575 break; 540 break;
576 dn_dev_del_ifa 541 dn_dev_del_ifa(dn_db, ifap, 0);
577 } 542 }
578 543
579 ifa->ifa_local = ifa-> 544 ifa->ifa_local = ifa->ifa_address = dn_saddr2dn(sdn);
580 545
581 ret = dn_dev_set_ifa(d 546 ret = dn_dev_set_ifa(dev, ifa);
582 } 547 }
583 done: 548 done:
584 rtnl_unlock(); 549 rtnl_unlock();
585 550
586 return ret; 551 return ret;
587 rarok: 552 rarok:
588 if (copy_to_user(arg, ifr, DN_IFREQ_SI 553 if (copy_to_user(arg, ifr, DN_IFREQ_SIZE))
589 ret = -EFAULT; 554 ret = -EFAULT;
590 goto done; 555 goto done;
591 } 556 }
592 557
593 struct net_device *dn_dev_get_default(void) 558 struct net_device *dn_dev_get_default(void)
594 { 559 {
595 struct net_device *dev; 560 struct net_device *dev;
596 read_lock(&dndev_lock); 561 read_lock(&dndev_lock);
597 dev = decnet_default_device; 562 dev = decnet_default_device;
598 if (dev) { 563 if (dev) {
599 if (dev->dn_ptr) 564 if (dev->dn_ptr)
600 dev_hold(dev); 565 dev_hold(dev);
601 else 566 else
602 dev = NULL; 567 dev = NULL;
603 } 568 }
604 read_unlock(&dndev_lock); 569 read_unlock(&dndev_lock);
605 return dev; 570 return dev;
606 } 571 }
607 572
608 int dn_dev_set_default(struct net_device *dev, 573 int dn_dev_set_default(struct net_device *dev, int force)
609 { 574 {
610 struct net_device *old = NULL; 575 struct net_device *old = NULL;
611 int rv = -EBUSY; 576 int rv = -EBUSY;
612 if (!dev->dn_ptr) 577 if (!dev->dn_ptr)
613 return -ENODEV; 578 return -ENODEV;
614 write_lock(&dndev_lock); 579 write_lock(&dndev_lock);
615 if (force || decnet_default_device == 580 if (force || decnet_default_device == NULL) {
616 old = decnet_default_device; 581 old = decnet_default_device;
617 decnet_default_device = dev; 582 decnet_default_device = dev;
618 rv = 0; 583 rv = 0;
619 } 584 }
620 write_unlock(&dndev_lock); 585 write_unlock(&dndev_lock);
621 if (old) 586 if (old)
622 dev_put(dev); !! 587 dev_put(old);
623 return rv; 588 return rv;
624 } 589 }
625 590
626 static void dn_dev_check_default(struct net_de 591 static void dn_dev_check_default(struct net_device *dev)
627 { 592 {
628 write_lock(&dndev_lock); 593 write_lock(&dndev_lock);
629 if (dev == decnet_default_device) { 594 if (dev == decnet_default_device) {
630 decnet_default_device = NULL; 595 decnet_default_device = NULL;
631 } else { 596 } else {
632 dev = NULL; 597 dev = NULL;
633 } 598 }
634 write_unlock(&dndev_lock); 599 write_unlock(&dndev_lock);
635 if (dev) 600 if (dev)
636 dev_put(dev); 601 dev_put(dev);
637 } 602 }
638 603
639 static struct dn_dev *dn_dev_by_index(int ifin 604 static struct dn_dev *dn_dev_by_index(int ifindex)
640 { 605 {
641 struct net_device *dev; 606 struct net_device *dev;
642 struct dn_dev *dn_dev = NULL; 607 struct dn_dev *dn_dev = NULL;
643 dev = dev_get_by_index(ifindex); !! 608 dev = dev_get_by_index(&init_net, ifindex);
644 if (dev) { 609 if (dev) {
645 dn_dev = dev->dn_ptr; 610 dn_dev = dev->dn_ptr;
646 dev_put(dev); 611 dev_put(dev);
647 } 612 }
648 613
649 return dn_dev; 614 return dn_dev;
650 } 615 }
651 616
652 static int dn_dev_rtm_deladdr(struct sk_buff * !! 617 static const struct nla_policy dn_ifa_policy[IFA_MAX+1] = {
>> 618 [IFA_ADDRESS] = { .type = NLA_U16 },
>> 619 [IFA_LOCAL] = { .type = NLA_U16 },
>> 620 [IFA_LABEL] = { .type = NLA_STRING,
>> 621 .len = IFNAMSIZ - 1 },
>> 622 };
>> 623
>> 624 static int dn_nl_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
653 { 625 {
654 struct rtattr **rta = arg; !! 626 struct net *net = sock_net(skb->sk);
>> 627 struct nlattr *tb[IFA_MAX+1];
655 struct dn_dev *dn_db; 628 struct dn_dev *dn_db;
656 struct ifaddrmsg *ifm = NLMSG_DATA(nlh !! 629 struct ifaddrmsg *ifm;
657 struct dn_ifaddr *ifa, **ifap; 630 struct dn_ifaddr *ifa, **ifap;
>> 631 int err = -EINVAL;
>> 632
>> 633 if (net != &init_net)
>> 634 goto errout;
658 635
>> 636 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, dn_ifa_policy);
>> 637 if (err < 0)
>> 638 goto errout;
>> 639
>> 640 err = -ENODEV;
>> 641 ifm = nlmsg_data(nlh);
659 if ((dn_db = dn_dev_by_index(ifm->ifa_ 642 if ((dn_db = dn_dev_by_index(ifm->ifa_index)) == NULL)
660 return -EADDRNOTAVAIL; !! 643 goto errout;
>> 644
>> 645 err = -EADDRNOTAVAIL;
>> 646 for (ifap = &dn_db->ifa_list; (ifa = *ifap); ifap = &ifa->ifa_next) {
>> 647 if (tb[IFA_LOCAL] &&
>> 648 nla_memcmp(tb[IFA_LOCAL], &ifa->ifa_local, 2))
>> 649 continue;
661 650
662 for(ifap = &dn_db->ifa_list; (ifa=*ifa !! 651 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
663 void *tmp = rta[IFA_LOCAL-1]; <<
664 if ((tmp && memcmp(RTA_DATA(tm <<
665 (rta[IFA_LABEL-1] && rtatt <<
666 continue; 652 continue;
667 653
668 dn_dev_del_ifa(dn_db, ifap, 1) 654 dn_dev_del_ifa(dn_db, ifap, 1);
669 return 0; 655 return 0;
670 } 656 }
671 657
672 return -EADDRNOTAVAIL; !! 658 errout:
>> 659 return err;
673 } 660 }
674 661
675 static int dn_dev_rtm_newaddr(struct sk_buff * !! 662 static int dn_nl_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
676 { 663 {
677 struct rtattr **rta = arg; !! 664 struct net *net = sock_net(skb->sk);
>> 665 struct nlattr *tb[IFA_MAX+1];
678 struct net_device *dev; 666 struct net_device *dev;
679 struct dn_dev *dn_db; 667 struct dn_dev *dn_db;
680 struct ifaddrmsg *ifm = NLMSG_DATA(nlh !! 668 struct ifaddrmsg *ifm;
681 struct dn_ifaddr *ifa; 669 struct dn_ifaddr *ifa;
682 int rv; !! 670 int err;
>> 671
>> 672 if (net != &init_net)
>> 673 return -EINVAL;
>> 674
>> 675 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, dn_ifa_policy);
>> 676 if (err < 0)
>> 677 return err;
683 678
684 if (rta[IFA_LOCAL-1] == NULL) !! 679 if (tb[IFA_LOCAL] == NULL)
685 return -EINVAL; 680 return -EINVAL;
686 681
687 if ((dev = __dev_get_by_index(ifm->ifa !! 682 ifm = nlmsg_data(nlh);
>> 683 if ((dev = __dev_get_by_index(&init_net, ifm->ifa_index)) == NULL)
688 return -ENODEV; 684 return -ENODEV;
689 685
690 if ((dn_db = dev->dn_ptr) == NULL) { 686 if ((dn_db = dev->dn_ptr) == NULL) {
691 int err; <<
692 dn_db = dn_dev_create(dev, &er 687 dn_db = dn_dev_create(dev, &err);
693 if (!dn_db) 688 if (!dn_db)
694 return err; 689 return err;
695 } 690 }
696 !! 691
697 if ((ifa = dn_dev_alloc_ifa()) == NULL 692 if ((ifa = dn_dev_alloc_ifa()) == NULL)
698 return -ENOBUFS; 693 return -ENOBUFS;
699 694
700 if (!rta[IFA_ADDRESS - 1]) !! 695 if (tb[IFA_ADDRESS] == NULL)
701 rta[IFA_ADDRESS - 1] = rta[IFA !! 696 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
702 memcpy(&ifa->ifa_local, RTA_DATA(rta[I !! 697
703 memcpy(&ifa->ifa_address, RTA_DATA(rta !! 698 ifa->ifa_local = nla_get_le16(tb[IFA_LOCAL]);
>> 699 ifa->ifa_address = nla_get_le16(tb[IFA_ADDRESS]);
704 ifa->ifa_flags = ifm->ifa_flags; 700 ifa->ifa_flags = ifm->ifa_flags;
705 ifa->ifa_scope = ifm->ifa_scope; 701 ifa->ifa_scope = ifm->ifa_scope;
706 ifa->ifa_dev = dn_db; 702 ifa->ifa_dev = dn_db;
707 if (rta[IFA_LABEL-1]) !! 703
708 rtattr_strlcpy(ifa->ifa_label, !! 704 if (tb[IFA_LABEL])
>> 705 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
709 else 706 else
710 memcpy(ifa->ifa_label, dev->na 707 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
711 708
712 rv = dn_dev_insert_ifa(dn_db, ifa); !! 709 err = dn_dev_insert_ifa(dn_db, ifa);
713 if (rv) !! 710 if (err)
714 dn_dev_free_ifa(ifa); 711 dn_dev_free_ifa(ifa);
715 return rv; !! 712
>> 713 return err;
716 } 714 }
717 715
718 static int dn_dev_fill_ifaddr(struct sk_buff * !! 716 static inline size_t dn_ifaddr_nlmsg_size(void)
719 u32 pid, u32 s !! 717 {
>> 718 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
>> 719 + nla_total_size(IFNAMSIZ) /* IFA_LABEL */
>> 720 + nla_total_size(2) /* IFA_ADDRESS */
>> 721 + nla_total_size(2); /* IFA_LOCAL */
>> 722 }
>> 723
>> 724 static int dn_nl_fill_ifaddr(struct sk_buff *skb, struct dn_ifaddr *ifa,
>> 725 u32 pid, u32 seq, int event, unsigned int flags)
720 { 726 {
721 struct ifaddrmsg *ifm; 727 struct ifaddrmsg *ifm;
722 struct nlmsghdr *nlh; 728 struct nlmsghdr *nlh;
723 unsigned char *b = skb->tail; <<
724 729
725 nlh = NLMSG_PUT(skb, pid, seq, event, !! 730 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags);
726 ifm = NLMSG_DATA(nlh); !! 731 if (nlh == NULL)
>> 732 return -EMSGSIZE;
727 733
>> 734 ifm = nlmsg_data(nlh);
728 ifm->ifa_family = AF_DECnet; 735 ifm->ifa_family = AF_DECnet;
729 ifm->ifa_prefixlen = 16; 736 ifm->ifa_prefixlen = 16;
730 ifm->ifa_flags = ifa->ifa_flags | IFA_ 737 ifm->ifa_flags = ifa->ifa_flags | IFA_F_PERMANENT;
731 ifm->ifa_scope = ifa->ifa_scope; 738 ifm->ifa_scope = ifa->ifa_scope;
732 ifm->ifa_index = ifa->ifa_dev->dev->if 739 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
>> 740
733 if (ifa->ifa_address) 741 if (ifa->ifa_address)
734 RTA_PUT(skb, IFA_ADDRESS, 2, & !! 742 NLA_PUT_LE16(skb, IFA_ADDRESS, ifa->ifa_address);
735 if (ifa->ifa_local) 743 if (ifa->ifa_local)
736 RTA_PUT(skb, IFA_LOCAL, 2, &if !! 744 NLA_PUT_LE16(skb, IFA_LOCAL, ifa->ifa_local);
737 if (ifa->ifa_label[0]) 745 if (ifa->ifa_label[0])
738 RTA_PUT(skb, IFA_LABEL, IFNAMS !! 746 NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label);
739 nlh->nlmsg_len = skb->tail - b; !! 747
740 return skb->len; !! 748 return nlmsg_end(skb, nlh);
741 749
742 nlmsg_failure: !! 750 nla_put_failure:
743 rtattr_failure: !! 751 nlmsg_cancel(skb, nlh);
744 skb_trim(skb, b - skb->data); !! 752 return -EMSGSIZE;
745 return -1; <<
746 } 753 }
747 754
748 static void rtmsg_ifa(int event, struct dn_ifa !! 755 static void dn_ifaddr_notify(int event, struct dn_ifaddr *ifa)
749 { 756 {
750 struct sk_buff *skb; 757 struct sk_buff *skb;
751 int size = NLMSG_SPACE(sizeof(struct i !! 758 int err = -ENOBUFS;
752 759
753 skb = alloc_skb(size, GFP_KERNEL); !! 760 skb = alloc_skb(dn_ifaddr_nlmsg_size(), GFP_KERNEL);
754 if (!skb) { !! 761 if (skb == NULL)
755 netlink_set_err(rtnl, 0, RTMGR !! 762 goto errout;
756 return; !! 763
757 } !! 764 err = dn_nl_fill_ifaddr(skb, ifa, 0, 0, event, 0);
758 if (dn_dev_fill_ifaddr(skb, ifa, 0, 0, !! 765 if (err < 0) {
>> 766 /* -EMSGSIZE implies BUG in dn_ifaddr_nlmsg_size() */
>> 767 WARN_ON(err == -EMSGSIZE);
759 kfree_skb(skb); 768 kfree_skb(skb);
760 netlink_set_err(rtnl, 0, RTMGR !! 769 goto errout;
761 return; <<
762 } 770 }
763 NETLINK_CB(skb).dst_groups = RTMGRP_DE !! 771 rtnl_notify(skb, &init_net, 0, RTNLGRP_DECnet_IFADDR, NULL, GFP_KERNEL);
764 netlink_broadcast(rtnl, skb, 0, RTMGRP !! 772 return;
>> 773 errout:
>> 774 if (err < 0)
>> 775 rtnl_set_sk_err(&init_net, RTNLGRP_DECnet_IFADDR, err);
765 } 776 }
766 777
767 static int dn_dev_dump_ifaddr(struct sk_buff * !! 778 static int dn_nl_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
768 { 779 {
769 int idx, dn_idx; !! 780 struct net *net = sock_net(skb->sk);
770 int s_idx, s_dn_idx; !! 781 int idx, dn_idx = 0, skip_ndevs, skip_naddr;
771 struct net_device *dev; 782 struct net_device *dev;
772 struct dn_dev *dn_db; 783 struct dn_dev *dn_db;
773 struct dn_ifaddr *ifa; 784 struct dn_ifaddr *ifa;
774 785
775 s_idx = cb->args[0]; !! 786 if (net != &init_net)
776 s_dn_idx = dn_idx = cb->args[1]; !! 787 return 0;
777 read_lock(&dev_base_lock); !! 788
778 for(dev = dev_base, idx = 0; dev; dev !! 789 skip_ndevs = cb->args[0];
779 if (idx < s_idx) !! 790 skip_naddr = cb->args[1];
780 continue; !! 791
781 if (idx > s_idx) !! 792 idx = 0;
782 s_dn_idx = 0; !! 793 for_each_netdev(&init_net, dev) {
>> 794 if (idx < skip_ndevs)
>> 795 goto cont;
>> 796 else if (idx > skip_ndevs) {
>> 797 /* Only skip over addresses for first dev dumped
>> 798 * in this iteration (idx == skip_ndevs) */
>> 799 skip_naddr = 0;
>> 800 }
>> 801
783 if ((dn_db = dev->dn_ptr) == N 802 if ((dn_db = dev->dn_ptr) == NULL)
784 continue; !! 803 goto cont;
785 804
786 for(ifa = dn_db->ifa_list, dn_ !! 805 for (ifa = dn_db->ifa_list, dn_idx = 0; ifa;
787 if (dn_idx < s_dn_idx) !! 806 ifa = ifa->ifa_next, dn_idx++) {
>> 807 if (dn_idx < skip_naddr)
788 continue; 808 continue;
789 809
790 if (dn_dev_fill_ifaddr !! 810 if (dn_nl_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
791 !! 811 cb->nlh->nlmsg_seq, RTM_NEWADDR,
792 !! 812 NLM_F_MULTI) < 0)
793 <<
794 goto done; 813 goto done;
795 } 814 }
>> 815 cont:
>> 816 idx++;
796 } 817 }
797 done: 818 done:
798 read_unlock(&dev_base_lock); <<
799 cb->args[0] = idx; 819 cb->args[0] = idx;
800 cb->args[1] = dn_idx; 820 cb->args[1] = dn_idx;
801 821
802 return skb->len; 822 return skb->len;
803 } 823 }
804 824
805 static int dn_dev_get_first(struct net_device !! 825 static int dn_dev_get_first(struct net_device *dev, __le16 *addr)
806 { 826 {
807 struct dn_dev *dn_db = (struct dn_dev 827 struct dn_dev *dn_db = (struct dn_dev *)dev->dn_ptr;
808 struct dn_ifaddr *ifa; 828 struct dn_ifaddr *ifa;
809 int rv = -ENODEV; 829 int rv = -ENODEV;
810 if (dn_db == NULL) 830 if (dn_db == NULL)
811 goto out; 831 goto out;
812 ifa = dn_db->ifa_list; 832 ifa = dn_db->ifa_list;
813 if (ifa != NULL) { 833 if (ifa != NULL) {
814 *addr = ifa->ifa_local; 834 *addr = ifa->ifa_local;
815 rv = 0; 835 rv = 0;
816 } 836 }
817 out: 837 out:
818 return rv; 838 return rv;
819 } 839 }
820 840
821 /* !! 841 /*
822 * Find a default address to bind to. 842 * Find a default address to bind to.
823 * 843 *
824 * This is one of those areas where the initia 844 * This is one of those areas where the initial VMS concepts don't really
825 * map onto the Linux concepts, and since we i 845 * map onto the Linux concepts, and since we introduced multiple addresses
826 * per interface we have to cope with slightly 846 * per interface we have to cope with slightly odd ways of finding out what
827 * "our address" really is. Mostly it's not a 847 * "our address" really is. Mostly it's not a problem; for this we just guess
828 * a sensible default. Eventually the routing 848 * a sensible default. Eventually the routing code will take care of all the
829 * nasties for us I hope. 849 * nasties for us I hope.
830 */ 850 */
831 int dn_dev_bind_default(dn_address *addr) !! 851 int dn_dev_bind_default(__le16 *addr)
832 { 852 {
833 struct net_device *dev; 853 struct net_device *dev;
834 int rv; 854 int rv;
835 dev = dn_dev_get_default(); 855 dev = dn_dev_get_default();
836 last_chance: 856 last_chance:
837 if (dev) { 857 if (dev) {
838 read_lock(&dev_base_lock); 858 read_lock(&dev_base_lock);
839 rv = dn_dev_get_first(dev, add 859 rv = dn_dev_get_first(dev, addr);
840 read_unlock(&dev_base_lock); 860 read_unlock(&dev_base_lock);
841 dev_put(dev); 861 dev_put(dev);
842 if (rv == 0 || dev == &loopbac !! 862 if (rv == 0 || dev == init_net.loopback_dev)
843 return rv; 863 return rv;
844 } 864 }
845 dev = &loopback_dev; !! 865 dev = init_net.loopback_dev;
846 dev_hold(dev); 866 dev_hold(dev);
847 goto last_chance; 867 goto last_chance;
848 } 868 }
849 869
850 static void dn_send_endnode_hello(struct net_d 870 static void dn_send_endnode_hello(struct net_device *dev, struct dn_ifaddr *ifa)
851 { 871 {
852 struct endnode_hello_message *msg; !! 872 struct endnode_hello_message *msg;
853 struct sk_buff *skb = NULL; !! 873 struct sk_buff *skb = NULL;
854 unsigned short int *pktlen; !! 874 __le16 *pktlen;
855 struct dn_dev *dn_db = (struct dn_dev 875 struct dn_dev *dn_db = (struct dn_dev *)dev->dn_ptr;
856 876
857 if ((skb = dn_alloc_skb(NULL, sizeof(* !! 877 if ((skb = dn_alloc_skb(NULL, sizeof(*msg), GFP_ATOMIC)) == NULL)
858 return; 878 return;
859 879
860 skb->dev = dev; !! 880 skb->dev = dev;
861 881
862 msg = (struct endnode_hello_message *) !! 882 msg = (struct endnode_hello_message *)skb_put(skb,sizeof(*msg));
863 883
864 msg->msgflg = 0x0D; !! 884 msg->msgflg = 0x0D;
865 memcpy(msg->tiver, dn_eco_version, 3); !! 885 memcpy(msg->tiver, dn_eco_version, 3);
866 dn_dn2eth(msg->id, ifa->ifa_local); 886 dn_dn2eth(msg->id, ifa->ifa_local);
867 msg->iinfo = DN_RT_INFO_ENDN; !! 887 msg->iinfo = DN_RT_INFO_ENDN;
868 msg->blksize = dn_htons(mtu2blksize(de !! 888 msg->blksize = cpu_to_le16(mtu2blksize(dev));
869 msg->area = 0x00; !! 889 msg->area = 0x00;
870 memset(msg->seed, 0, 8); !! 890 memset(msg->seed, 0, 8);
871 memcpy(msg->neighbor, dn_hiord, ETH_AL !! 891 memcpy(msg->neighbor, dn_hiord, ETH_ALEN);
872 892
873 if (dn_db->router) { 893 if (dn_db->router) {
874 struct dn_neigh *dn = (struct 894 struct dn_neigh *dn = (struct dn_neigh *)dn_db->router;
875 dn_dn2eth(msg->neighbor, dn->a 895 dn_dn2eth(msg->neighbor, dn->addr);
876 } 896 }
877 897
878 msg->timer = dn_htons((unsigned shor !! 898 msg->timer = cpu_to_le16((unsigned short)dn_db->parms.t3);
879 msg->mpd = 0x00; !! 899 msg->mpd = 0x00;
880 msg->datalen = 0x02; !! 900 msg->datalen = 0x02;
881 memset(msg->data, 0xAA, 2); !! 901 memset(msg->data, 0xAA, 2);
882 <<
883 pktlen = (unsigned short *)skb_push(sk <<
884 *pktlen = dn_htons(skb->len - 2); <<
885 902
886 skb->nh.raw = skb->data; !! 903 pktlen = (__le16 *)skb_push(skb,2);
>> 904 *pktlen = cpu_to_le16(skb->len - 2);
>> 905
>> 906 skb_reset_network_header(skb);
887 907
888 dn_rt_finish_output(skb, dn_rt_all_rt_ 908 dn_rt_finish_output(skb, dn_rt_all_rt_mcast, msg->id);
889 } 909 }
890 910
891 911
892 #define DRDELAY (5 * HZ) 912 #define DRDELAY (5 * HZ)
893 913
894 static int dn_am_i_a_router(struct dn_neigh *d 914 static int dn_am_i_a_router(struct dn_neigh *dn, struct dn_dev *dn_db, struct dn_ifaddr *ifa)
895 { 915 {
896 /* First check time since device went 916 /* First check time since device went up */
897 if ((jiffies - dn_db->uptime) < DRDELA 917 if ((jiffies - dn_db->uptime) < DRDELAY)
898 return 0; 918 return 0;
899 919
900 /* If there is no router, then yes... 920 /* If there is no router, then yes... */
901 if (!dn_db->router) 921 if (!dn_db->router)
902 return 1; 922 return 1;
903 923
904 /* otherwise only if we have a higher 924 /* otherwise only if we have a higher priority or.. */
905 if (dn->priority < dn_db->parms.priori 925 if (dn->priority < dn_db->parms.priority)
906 return 1; 926 return 1;
907 927
908 /* if we have equal priority and a hig 928 /* if we have equal priority and a higher node number */
909 if (dn->priority != dn_db->parms.prior 929 if (dn->priority != dn_db->parms.priority)
910 return 0; 930 return 0;
911 931
912 if (dn_ntohs(dn->addr) < dn_ntohs(ifa- !! 932 if (le16_to_cpu(dn->addr) < le16_to_cpu(ifa->ifa_local))
913 return 1; 933 return 1;
914 934
915 return 0; 935 return 0;
916 } 936 }
917 937
918 static void dn_send_router_hello(struct net_de 938 static void dn_send_router_hello(struct net_device *dev, struct dn_ifaddr *ifa)
919 { 939 {
920 int n; 940 int n;
921 struct dn_dev *dn_db = dev->dn_ptr; 941 struct dn_dev *dn_db = dev->dn_ptr;
922 struct dn_neigh *dn = (struct dn_neigh 942 struct dn_neigh *dn = (struct dn_neigh *)dn_db->router;
923 struct sk_buff *skb; 943 struct sk_buff *skb;
924 size_t size; 944 size_t size;
925 unsigned char *ptr; 945 unsigned char *ptr;
926 unsigned char *i1, *i2; 946 unsigned char *i1, *i2;
927 unsigned short *pktlen; !! 947 __le16 *pktlen;
928 char *src; 948 char *src;
929 949
930 if (mtu2blksize(dev) < (26 + 7)) 950 if (mtu2blksize(dev) < (26 + 7))
931 return; 951 return;
932 952
933 n = mtu2blksize(dev) - 26; 953 n = mtu2blksize(dev) - 26;
934 n /= 7; 954 n /= 7;
935 955
936 if (n > 32) 956 if (n > 32)
937 n = 32; 957 n = 32;
938 958
939 size = 2 + 26 + 7 * n; 959 size = 2 + 26 + 7 * n;
940 960
941 if ((skb = dn_alloc_skb(NULL, size, GF 961 if ((skb = dn_alloc_skb(NULL, size, GFP_ATOMIC)) == NULL)
942 return; 962 return;
943 963
944 skb->dev = dev; 964 skb->dev = dev;
945 ptr = skb_put(skb, size); 965 ptr = skb_put(skb, size);
946 966
947 *ptr++ = DN_RT_PKT_CNTL | DN_RT_PKT_ER 967 *ptr++ = DN_RT_PKT_CNTL | DN_RT_PKT_ERTH;
948 *ptr++ = 2; /* ECO */ 968 *ptr++ = 2; /* ECO */
949 *ptr++ = 0; 969 *ptr++ = 0;
950 *ptr++ = 0; 970 *ptr++ = 0;
951 dn_dn2eth(ptr, ifa->ifa_local); 971 dn_dn2eth(ptr, ifa->ifa_local);
952 src = ptr; 972 src = ptr;
953 ptr += ETH_ALEN; 973 ptr += ETH_ALEN;
954 *ptr++ = dn_db->parms.forwarding == 1 !! 974 *ptr++ = dn_db->parms.forwarding == 1 ?
955 DN_RT_INFO_L1RT : DN_R 975 DN_RT_INFO_L1RT : DN_RT_INFO_L2RT;
956 *((unsigned short *)ptr) = dn_htons(mt !! 976 *((__le16 *)ptr) = cpu_to_le16(mtu2blksize(dev));
957 ptr += 2; 977 ptr += 2;
958 *ptr++ = dn_db->parms.priority; /* Pri !! 978 *ptr++ = dn_db->parms.priority; /* Priority */
959 *ptr++ = 0; /* Area: Reserved */ 979 *ptr++ = 0; /* Area: Reserved */
960 *((unsigned short *)ptr) = dn_htons((u !! 980 *((__le16 *)ptr) = cpu_to_le16((unsigned short)dn_db->parms.t3);
961 ptr += 2; 981 ptr += 2;
962 *ptr++ = 0; /* MPD: Reserved */ 982 *ptr++ = 0; /* MPD: Reserved */
963 i1 = ptr++; 983 i1 = ptr++;
964 memset(ptr, 0, 7); /* Name: Reserved * 984 memset(ptr, 0, 7); /* Name: Reserved */
965 ptr += 7; 985 ptr += 7;
966 i2 = ptr++; 986 i2 = ptr++;
967 987
968 n = dn_neigh_elist(dev, ptr, n); 988 n = dn_neigh_elist(dev, ptr, n);
969 989
970 *i2 = 7 * n; 990 *i2 = 7 * n;
971 *i1 = 8 + *i2; 991 *i1 = 8 + *i2;
972 992
973 skb_trim(skb, (27 + *i2)); 993 skb_trim(skb, (27 + *i2));
974 994
975 pktlen = (unsigned short *)skb_push(sk !! 995 pktlen = (__le16 *)skb_push(skb, 2);
976 *pktlen = dn_htons(skb->len - 2); !! 996 *pktlen = cpu_to_le16(skb->len - 2);
977 997
978 skb->nh.raw = skb->data; !! 998 skb_reset_network_header(skb);
979 999
980 if (dn_am_i_a_router(dn, dn_db, ifa)) 1000 if (dn_am_i_a_router(dn, dn_db, ifa)) {
981 struct sk_buff *skb2 = skb_cop 1001 struct sk_buff *skb2 = skb_copy(skb, GFP_ATOMIC);
982 if (skb2) { 1002 if (skb2) {
983 dn_rt_finish_output(sk 1003 dn_rt_finish_output(skb2, dn_rt_all_end_mcast, src);
984 } 1004 }
985 } 1005 }
986 1006
987 dn_rt_finish_output(skb, dn_rt_all_rt_ 1007 dn_rt_finish_output(skb, dn_rt_all_rt_mcast, src);
988 } 1008 }
989 1009
990 static void dn_send_brd_hello(struct net_devic 1010 static void dn_send_brd_hello(struct net_device *dev, struct dn_ifaddr *ifa)
991 { 1011 {
992 struct dn_dev *dn_db = (struct dn_dev 1012 struct dn_dev *dn_db = (struct dn_dev *)dev->dn_ptr;
993 1013
994 if (dn_db->parms.forwarding == 0) 1014 if (dn_db->parms.forwarding == 0)
995 dn_send_endnode_hello(dev, ifa 1015 dn_send_endnode_hello(dev, ifa);
996 else 1016 else
997 dn_send_router_hello(dev, ifa) 1017 dn_send_router_hello(dev, ifa);
998 } 1018 }
999 1019
1000 static void dn_send_ptp_hello(struct net_devi 1020 static void dn_send_ptp_hello(struct net_device *dev, struct dn_ifaddr *ifa)
1001 { 1021 {
1002 int tdlen = 16; 1022 int tdlen = 16;
1003 int size = dev->hard_header_len + 2 + 1023 int size = dev->hard_header_len + 2 + 4 + tdlen;
1004 struct sk_buff *skb = dn_alloc_skb(NU 1024 struct sk_buff *skb = dn_alloc_skb(NULL, size, GFP_ATOMIC);
1005 int i; 1025 int i;
1006 unsigned char *ptr; 1026 unsigned char *ptr;
1007 char src[ETH_ALEN]; 1027 char src[ETH_ALEN];
1008 1028
1009 if (skb == NULL) 1029 if (skb == NULL)
1010 return ; 1030 return ;
1011 1031
1012 skb->dev = dev; 1032 skb->dev = dev;
1013 skb_push(skb, dev->hard_header_len); 1033 skb_push(skb, dev->hard_header_len);
1014 ptr = skb_put(skb, 2 + 4 + tdlen); 1034 ptr = skb_put(skb, 2 + 4 + tdlen);
1015 1035
1016 *ptr++ = DN_RT_PKT_HELO; 1036 *ptr++ = DN_RT_PKT_HELO;
1017 *((dn_address *)ptr) = ifa->ifa_local !! 1037 *((__le16 *)ptr) = ifa->ifa_local;
1018 ptr += 2; 1038 ptr += 2;
1019 *ptr++ = tdlen; 1039 *ptr++ = tdlen;
1020 1040
1021 for(i = 0; i < tdlen; i++) 1041 for(i = 0; i < tdlen; i++)
1022 *ptr++ = 0252; 1042 *ptr++ = 0252;
1023 1043
1024 dn_dn2eth(src, ifa->ifa_local); 1044 dn_dn2eth(src, ifa->ifa_local);
1025 dn_rt_finish_output(skb, dn_rt_all_rt 1045 dn_rt_finish_output(skb, dn_rt_all_rt_mcast, src);
1026 } 1046 }
1027 1047
1028 static int dn_eth_up(struct net_device *dev) 1048 static int dn_eth_up(struct net_device *dev)
1029 { 1049 {
1030 struct dn_dev *dn_db = dev->dn_ptr; 1050 struct dn_dev *dn_db = dev->dn_ptr;
1031 1051
1032 if (dn_db->parms.forwarding == 0) 1052 if (dn_db->parms.forwarding == 0)
1033 dev_mc_add(dev, dn_rt_all_end 1053 dev_mc_add(dev, dn_rt_all_end_mcast, ETH_ALEN, 0);
1034 else 1054 else
1035 dev_mc_add(dev, dn_rt_all_rt_ 1055 dev_mc_add(dev, dn_rt_all_rt_mcast, ETH_ALEN, 0);
1036 1056
1037 dev_mc_upload(dev); <<
1038 <<
1039 dn_db->use_long = 1; 1057 dn_db->use_long = 1;
1040 1058
1041 return 0; 1059 return 0;
1042 } 1060 }
1043 1061
1044 static void dn_eth_down(struct net_device *de 1062 static void dn_eth_down(struct net_device *dev)
1045 { 1063 {
1046 struct dn_dev *dn_db = dev->dn_ptr; 1064 struct dn_dev *dn_db = dev->dn_ptr;
1047 1065
1048 if (dn_db->parms.forwarding == 0) 1066 if (dn_db->parms.forwarding == 0)
1049 dev_mc_delete(dev, dn_rt_all_ 1067 dev_mc_delete(dev, dn_rt_all_end_mcast, ETH_ALEN, 0);
1050 else 1068 else
1051 dev_mc_delete(dev, dn_rt_all_ 1069 dev_mc_delete(dev, dn_rt_all_rt_mcast, ETH_ALEN, 0);
1052 } 1070 }
1053 1071
1054 static void dn_dev_set_timer(struct net_devic 1072 static void dn_dev_set_timer(struct net_device *dev);
1055 1073
1056 static void dn_dev_timer_func(unsigned long a 1074 static void dn_dev_timer_func(unsigned long arg)
1057 { 1075 {
1058 struct net_device *dev = (struct net_ 1076 struct net_device *dev = (struct net_device *)arg;
1059 struct dn_dev *dn_db = dev->dn_ptr; 1077 struct dn_dev *dn_db = dev->dn_ptr;
1060 struct dn_ifaddr *ifa; 1078 struct dn_ifaddr *ifa;
1061 1079
1062 if (dn_db->t3 <= dn_db->parms.t2) { 1080 if (dn_db->t3 <= dn_db->parms.t2) {
1063 if (dn_db->parms.timer3) { 1081 if (dn_db->parms.timer3) {
1064 for(ifa = dn_db->ifa_ 1082 for(ifa = dn_db->ifa_list; ifa; ifa = ifa->ifa_next) {
1065 if (!(ifa->if 1083 if (!(ifa->ifa_flags & IFA_F_SECONDARY))
1066 dn_db 1084 dn_db->parms.timer3(dev, ifa);
1067 } 1085 }
1068 } 1086 }
1069 dn_db->t3 = dn_db->parms.t3; 1087 dn_db->t3 = dn_db->parms.t3;
1070 } else { 1088 } else {
1071 dn_db->t3 -= dn_db->parms.t2; 1089 dn_db->t3 -= dn_db->parms.t2;
1072 } 1090 }
1073 1091
1074 dn_dev_set_timer(dev); 1092 dn_dev_set_timer(dev);
1075 } 1093 }
1076 1094
1077 static void dn_dev_set_timer(struct net_devic 1095 static void dn_dev_set_timer(struct net_device *dev)
1078 { 1096 {
1079 struct dn_dev *dn_db = dev->dn_ptr; 1097 struct dn_dev *dn_db = dev->dn_ptr;
1080 1098
1081 if (dn_db->parms.t2 > dn_db->parms.t3 1099 if (dn_db->parms.t2 > dn_db->parms.t3)
1082 dn_db->parms.t2 = dn_db->parm 1100 dn_db->parms.t2 = dn_db->parms.t3;
1083 1101
1084 dn_db->timer.data = (unsigned long)de 1102 dn_db->timer.data = (unsigned long)dev;
1085 dn_db->timer.function = dn_dev_timer_ 1103 dn_db->timer.function = dn_dev_timer_func;
1086 dn_db->timer.expires = jiffies + (dn_ 1104 dn_db->timer.expires = jiffies + (dn_db->parms.t2 * HZ);
1087 1105
1088 add_timer(&dn_db->timer); 1106 add_timer(&dn_db->timer);
1089 } 1107 }
1090 1108
1091 struct dn_dev *dn_dev_create(struct net_devic !! 1109 static struct dn_dev *dn_dev_create(struct net_device *dev, int *err)
1092 { 1110 {
1093 int i; 1111 int i;
1094 struct dn_dev_parms *p = dn_dev_list; 1112 struct dn_dev_parms *p = dn_dev_list;
1095 struct dn_dev *dn_db; 1113 struct dn_dev *dn_db;
1096 1114
1097 for(i = 0; i < DN_DEV_LIST_SIZE; i++, 1115 for(i = 0; i < DN_DEV_LIST_SIZE; i++, p++) {
1098 if (p->type == dev->type) 1116 if (p->type == dev->type)
1099 break; 1117 break;
1100 } 1118 }
1101 1119
1102 *err = -ENODEV; 1120 *err = -ENODEV;
1103 if (i == DN_DEV_LIST_SIZE) 1121 if (i == DN_DEV_LIST_SIZE)
1104 return NULL; 1122 return NULL;
1105 1123
1106 *err = -ENOBUFS; 1124 *err = -ENOBUFS;
1107 if ((dn_db = kmalloc(sizeof(struct dn !! 1125 if ((dn_db = kzalloc(sizeof(struct dn_dev), GFP_ATOMIC)) == NULL)
1108 return NULL; 1126 return NULL;
1109 1127
1110 memset(dn_db, 0, sizeof(struct dn_dev <<
1111 memcpy(&dn_db->parms, p, sizeof(struc 1128 memcpy(&dn_db->parms, p, sizeof(struct dn_dev_parms));
1112 smp_wmb(); 1129 smp_wmb();
1113 dev->dn_ptr = dn_db; 1130 dev->dn_ptr = dn_db;
1114 dn_db->dev = dev; 1131 dn_db->dev = dev;
1115 init_timer(&dn_db->timer); 1132 init_timer(&dn_db->timer);
1116 1133
1117 dn_db->uptime = jiffies; 1134 dn_db->uptime = jiffies;
>> 1135
>> 1136 dn_db->neigh_parms = neigh_parms_alloc(dev, &dn_neigh_table);
>> 1137 if (!dn_db->neigh_parms) {
>> 1138 dev->dn_ptr = NULL;
>> 1139 kfree(dn_db);
>> 1140 return NULL;
>> 1141 }
>> 1142
1118 if (dn_db->parms.up) { 1143 if (dn_db->parms.up) {
1119 if (dn_db->parms.up(dev) < 0) 1144 if (dn_db->parms.up(dev) < 0) {
>> 1145 neigh_parms_release(&dn_neigh_table, dn_db->neigh_parms);
1120 dev->dn_ptr = NULL; 1146 dev->dn_ptr = NULL;
1121 kfree(dn_db); 1147 kfree(dn_db);
1122 return NULL; 1148 return NULL;
1123 } 1149 }
1124 } 1150 }
1125 1151
1126 dn_db->neigh_parms = neigh_parms_allo <<
1127 <<
1128 dn_dev_sysctl_register(dev, &dn_db->p 1152 dn_dev_sysctl_register(dev, &dn_db->parms);
1129 1153
1130 dn_dev_set_timer(dev); 1154 dn_dev_set_timer(dev);
1131 1155
1132 *err = 0; 1156 *err = 0;
1133 return dn_db; 1157 return dn_db;
1134 } 1158 }
1135 1159
1136 1160
1137 /* 1161 /*
1138 * This processes a device up event. We only 1162 * This processes a device up event. We only start up
1139 * the loopback device & ethernet devices wit 1163 * the loopback device & ethernet devices with correct
1140 * MAC addreses automatically. Others must be 1164 * MAC addreses automatically. Others must be started
1141 * specifically. 1165 * specifically.
1142 * 1166 *
1143 * FIXME: How should we configure the loopbac 1167 * FIXME: How should we configure the loopback address ? If we could dispense
1144 * with using decnet_address here and for aut 1168 * with using decnet_address here and for autobind, it will be one less thing
1145 * for users to worry about setting up. 1169 * for users to worry about setting up.
1146 */ 1170 */
1147 1171
1148 void dn_dev_up(struct net_device *dev) 1172 void dn_dev_up(struct net_device *dev)
1149 { 1173 {
1150 struct dn_ifaddr *ifa; 1174 struct dn_ifaddr *ifa;
1151 dn_address addr = decnet_address; !! 1175 __le16 addr = decnet_address;
1152 int maybe_default = 0; 1176 int maybe_default = 0;
1153 struct dn_dev *dn_db = (struct dn_dev 1177 struct dn_dev *dn_db = (struct dn_dev *)dev->dn_ptr;
1154 1178
1155 if ((dev->type != ARPHRD_ETHER) && (d 1179 if ((dev->type != ARPHRD_ETHER) && (dev->type != ARPHRD_LOOPBACK))
1156 return; 1180 return;
1157 1181
1158 /* 1182 /*
1159 * Need to ensure that loopback devic 1183 * Need to ensure that loopback device has a dn_db attached to it
1160 * to allow creation of neighbours ag 1184 * to allow creation of neighbours against it, even though it might
1161 * not have a local address of its ow 1185 * not have a local address of its own. Might as well do the same for
1162 * all autoconfigured interfaces. 1186 * all autoconfigured interfaces.
1163 */ 1187 */
1164 if (dn_db == NULL) { 1188 if (dn_db == NULL) {
1165 int err; 1189 int err;
1166 dn_db = dn_dev_create(dev, &e 1190 dn_db = dn_dev_create(dev, &err);
1167 if (dn_db == NULL) 1191 if (dn_db == NULL)
1168 return; 1192 return;
1169 } 1193 }
1170 1194
1171 if (dev->type == ARPHRD_ETHER) { 1195 if (dev->type == ARPHRD_ETHER) {
1172 if (memcmp(dev->dev_addr, dn_ 1196 if (memcmp(dev->dev_addr, dn_hiord, 4) != 0)
1173 return; 1197 return;
1174 addr = dn_htons(dn_eth2dn(dev !! 1198 addr = dn_eth2dn(dev->dev_addr);
1175 maybe_default = 1; 1199 maybe_default = 1;
1176 } 1200 }
1177 1201
1178 if (addr == 0) 1202 if (addr == 0)
1179 return; 1203 return;
1180 1204
1181 if ((ifa = dn_dev_alloc_ifa()) == NUL 1205 if ((ifa = dn_dev_alloc_ifa()) == NULL)
1182 return; 1206 return;
1183 1207
1184 ifa->ifa_local = ifa->ifa_address = a 1208 ifa->ifa_local = ifa->ifa_address = addr;
1185 ifa->ifa_flags = 0; 1209 ifa->ifa_flags = 0;
1186 ifa->ifa_scope = RT_SCOPE_UNIVERSE; 1210 ifa->ifa_scope = RT_SCOPE_UNIVERSE;
1187 strcpy(ifa->ifa_label, dev->name); 1211 strcpy(ifa->ifa_label, dev->name);
1188 1212
1189 dn_dev_set_ifa(dev, ifa); 1213 dn_dev_set_ifa(dev, ifa);
1190 1214
1191 /* 1215 /*
1192 * Automagically set the default devi 1216 * Automagically set the default device to the first automatically
1193 * configured ethernet card in the sy 1217 * configured ethernet card in the system.
1194 */ 1218 */
1195 if (maybe_default) { 1219 if (maybe_default) {
1196 dev_hold(dev); 1220 dev_hold(dev);
1197 if (dn_dev_set_default(dev, 0 1221 if (dn_dev_set_default(dev, 0))
1198 dev_put(dev); 1222 dev_put(dev);
1199 } 1223 }
1200 } 1224 }
1201 1225
1202 static void dn_dev_delete(struct net_device * 1226 static void dn_dev_delete(struct net_device *dev)
1203 { 1227 {
1204 struct dn_dev *dn_db = dev->dn_ptr; 1228 struct dn_dev *dn_db = dev->dn_ptr;
1205 1229
1206 if (dn_db == NULL) 1230 if (dn_db == NULL)
1207 return; 1231 return;
1208 1232
1209 del_timer_sync(&dn_db->timer); 1233 del_timer_sync(&dn_db->timer);
1210 dn_dev_sysctl_unregister(&dn_db->parm 1234 dn_dev_sysctl_unregister(&dn_db->parms);
1211 dn_dev_check_default(dev); 1235 dn_dev_check_default(dev);
1212 neigh_ifdown(&dn_neigh_table, dev); 1236 neigh_ifdown(&dn_neigh_table, dev);
1213 1237
1214 if (dn_db->parms.down) 1238 if (dn_db->parms.down)
1215 dn_db->parms.down(dev); 1239 dn_db->parms.down(dev);
1216 1240
1217 dev->dn_ptr = NULL; 1241 dev->dn_ptr = NULL;
1218 1242
1219 neigh_parms_release(&dn_neigh_table, 1243 neigh_parms_release(&dn_neigh_table, dn_db->neigh_parms);
1220 neigh_ifdown(&dn_neigh_table, dev); 1244 neigh_ifdown(&dn_neigh_table, dev);
1221 1245
1222 if (dn_db->router) 1246 if (dn_db->router)
1223 neigh_release(dn_db->router); 1247 neigh_release(dn_db->router);
1224 if (dn_db->peer) 1248 if (dn_db->peer)
1225 neigh_release(dn_db->peer); 1249 neigh_release(dn_db->peer);
1226 1250
1227 kfree(dn_db); 1251 kfree(dn_db);
1228 } 1252 }
1229 1253
1230 void dn_dev_down(struct net_device *dev) 1254 void dn_dev_down(struct net_device *dev)
1231 { 1255 {
1232 struct dn_dev *dn_db = dev->dn_ptr; 1256 struct dn_dev *dn_db = dev->dn_ptr;
1233 struct dn_ifaddr *ifa; 1257 struct dn_ifaddr *ifa;
1234 1258
1235 if (dn_db == NULL) 1259 if (dn_db == NULL)
1236 return; 1260 return;
1237 1261
1238 while((ifa = dn_db->ifa_list) != NULL 1262 while((ifa = dn_db->ifa_list) != NULL) {
1239 dn_dev_del_ifa(dn_db, &dn_db- 1263 dn_dev_del_ifa(dn_db, &dn_db->ifa_list, 0);
1240 dn_dev_free_ifa(ifa); 1264 dn_dev_free_ifa(ifa);
1241 } 1265 }
1242 1266
1243 dn_dev_delete(dev); 1267 dn_dev_delete(dev);
1244 } 1268 }
1245 1269
1246 void dn_dev_init_pkt(struct sk_buff *skb) 1270 void dn_dev_init_pkt(struct sk_buff *skb)
1247 { 1271 {
1248 return; 1272 return;
1249 } 1273 }
1250 1274
1251 void dn_dev_veri_pkt(struct sk_buff *skb) 1275 void dn_dev_veri_pkt(struct sk_buff *skb)
1252 { 1276 {
1253 return; 1277 return;
1254 } 1278 }
1255 1279
1256 void dn_dev_hello(struct sk_buff *skb) 1280 void dn_dev_hello(struct sk_buff *skb)
1257 { 1281 {
1258 return; 1282 return;
1259 } 1283 }
1260 1284
1261 void dn_dev_devices_off(void) 1285 void dn_dev_devices_off(void)
1262 { 1286 {
1263 struct net_device *dev; 1287 struct net_device *dev;
1264 1288
1265 rtnl_lock(); 1289 rtnl_lock();
1266 for(dev = dev_base; dev; dev = dev->n !! 1290 for_each_netdev(&init_net, dev)
1267 dn_dev_down(dev); 1291 dn_dev_down(dev);
1268 rtnl_unlock(); 1292 rtnl_unlock();
1269 1293
1270 } 1294 }
1271 1295
1272 void dn_dev_devices_on(void) 1296 void dn_dev_devices_on(void)
1273 { 1297 {
1274 struct net_device *dev; 1298 struct net_device *dev;
1275 1299
1276 rtnl_lock(); 1300 rtnl_lock();
1277 for(dev = dev_base; dev; dev = dev->n !! 1301 for_each_netdev(&init_net, dev) {
1278 if (dev->flags & IFF_UP) 1302 if (dev->flags & IFF_UP)
1279 dn_dev_up(dev); 1303 dn_dev_up(dev);
1280 } 1304 }
1281 rtnl_unlock(); 1305 rtnl_unlock();
1282 } 1306 }
1283 1307
1284 int register_dnaddr_notifier(struct notifier_ 1308 int register_dnaddr_notifier(struct notifier_block *nb)
1285 { 1309 {
1286 return notifier_chain_register(&dnadd !! 1310 return blocking_notifier_chain_register(&dnaddr_chain, nb);
1287 } 1311 }
1288 1312
1289 int unregister_dnaddr_notifier(struct notifie 1313 int unregister_dnaddr_notifier(struct notifier_block *nb)
1290 { 1314 {
1291 return notifier_chain_unregister(&dna !! 1315 return blocking_notifier_chain_unregister(&dnaddr_chain, nb);
1292 } 1316 }
1293 1317
1294 #ifdef CONFIG_PROC_FS 1318 #ifdef CONFIG_PROC_FS
1295 static inline struct net_device *dn_dev_get_n !! 1319 static inline int is_dn_dev(struct net_device *dev)
1296 { 1320 {
1297 do { !! 1321 return dev->dn_ptr != NULL;
1298 dev = dev->next; <<
1299 } while(dev && !dev->dn_ptr); <<
1300 <<
1301 return dev; <<
1302 } 1322 }
1303 1323
1304 static struct net_device *dn_dev_get_idx(stru !! 1324 static void *dn_dev_seq_start(struct seq_file *seq, loff_t *pos)
>> 1325 __acquires(&dev_base_lock)
1305 { 1326 {
>> 1327 int i;
1306 struct net_device *dev; 1328 struct net_device *dev;
1307 1329
1308 dev = dev_base; !! 1330 read_lock(&dev_base_lock);
1309 if (dev && !dev->dn_ptr) <<
1310 dev = dn_dev_get_next(seq, de <<
1311 if (pos) { <<
1312 while(dev && (dev = dn_dev_ge <<
1313 --pos; <<
1314 } <<
1315 return dev; <<
1316 } <<
1317 1331
1318 static void *dn_dev_seq_start(struct seq_file !! 1332 if (*pos == 0)
1319 { !! 1333 return SEQ_START_TOKEN;
1320 if (*pos) { !! 1334
1321 struct net_device *dev; !! 1335 i = 1;
1322 read_lock(&dev_base_lock); !! 1336 for_each_netdev(&init_net, dev) {
1323 dev = dn_dev_get_idx(seq, *po !! 1337 if (!is_dn_dev(dev))
1324 if (dev == NULL) !! 1338 continue;
1325 read_unlock(&dev_base !! 1339
1326 return dev; !! 1340 if (i++ == *pos)
>> 1341 return dev;
1327 } 1342 }
1328 return SEQ_START_TOKEN; !! 1343
>> 1344 return NULL;
1329 } 1345 }
1330 1346
1331 static void *dn_dev_seq_next(struct seq_file 1347 static void *dn_dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1332 { 1348 {
1333 struct net_device *dev = v; !! 1349 struct net_device *dev;
1334 loff_t one = 1; <<
1335 1350
1336 if (v == SEQ_START_TOKEN) { <<
1337 dev = dn_dev_seq_start(seq, & <<
1338 } else { <<
1339 dev = dn_dev_get_next(seq, de <<
1340 if (dev == NULL) <<
1341 read_unlock(&dev_base <<
1342 } <<
1343 ++*pos; 1351 ++*pos;
1344 return dev; !! 1352
>> 1353 dev = (struct net_device *)v;
>> 1354 if (v == SEQ_START_TOKEN)
>> 1355 dev = net_device_entry(&init_net.dev_base_head);
>> 1356
>> 1357 for_each_netdev_continue(&init_net, dev) {
>> 1358 if (!is_dn_dev(dev))
>> 1359 continue;
>> 1360
>> 1361 return dev;
>> 1362 }
>> 1363
>> 1364 return NULL;
1345 } 1365 }
1346 1366
1347 static void dn_dev_seq_stop(struct seq_file * 1367 static void dn_dev_seq_stop(struct seq_file *seq, void *v)
>> 1368 __releases(&dev_base_lock)
1348 { 1369 {
1349 if (v && v != SEQ_START_TOKEN) !! 1370 read_unlock(&dev_base_lock);
1350 read_unlock(&dev_base_lock); <<
1351 } 1371 }
1352 1372
1353 static char *dn_type2asc(char type) 1373 static char *dn_type2asc(char type)
1354 { 1374 {
1355 switch(type) { 1375 switch(type) {
1356 case DN_DEV_BCAST: 1376 case DN_DEV_BCAST:
1357 return "B"; 1377 return "B";
1358 case DN_DEV_UCAST: 1378 case DN_DEV_UCAST:
1359 return "U"; 1379 return "U";
1360 case DN_DEV_MPOINT: 1380 case DN_DEV_MPOINT:
1361 return "M"; 1381 return "M";
1362 } 1382 }
1363 1383
1364 return "?"; 1384 return "?";
1365 } 1385 }
1366 1386
1367 static int dn_dev_seq_show(struct seq_file *s 1387 static int dn_dev_seq_show(struct seq_file *seq, void *v)
1368 { 1388 {
1369 if (v == SEQ_START_TOKEN) 1389 if (v == SEQ_START_TOKEN)
1370 seq_puts(seq, "Name Flags !! 1390 seq_puts(seq, "Name Flags T1 Timer1 T3 Timer3 BlkSize Pri State DevType Router Peer\n");
1371 else { 1391 else {
1372 struct net_device *dev = v; 1392 struct net_device *dev = v;
1373 char peer_buf[DN_ASCBUF_LEN]; 1393 char peer_buf[DN_ASCBUF_LEN];
1374 char router_buf[DN_ASCBUF_LEN 1394 char router_buf[DN_ASCBUF_LEN];
1375 struct dn_dev *dn_db = dev->d 1395 struct dn_dev *dn_db = dev->dn_ptr;
1376 1396
1377 seq_printf(seq, "%-8s %1s !! 1397 seq_printf(seq, "%-8s %1s %04u %04u %04lu %04lu"
1378 " %04hu 1398 " %04hu %03d %02x %-10s %-7s %-7s\n",
1379 dev->name ? d !! 1399 dev->name ? dev->name : "???",
1380 dn_type2asc(d !! 1400 dn_type2asc(dn_db->parms.mode),
1381 0, 0, !! 1401 0, 0,
1382 dn_db->t3, dn 1402 dn_db->t3, dn_db->parms.t3,
1383 mtu2blksize(d 1403 mtu2blksize(dev),
1384 dn_db->parms. 1404 dn_db->parms.priority,
1385 dn_db->parms. 1405 dn_db->parms.state, dn_db->parms.name,
1386 dn_db->router !! 1406 dn_db->router ? dn_addr2asc(le16_to_cpu(*(__le16 *)dn_db->router->primary_key), router_buf) : "",
1387 dn_db->peer ? !! 1407 dn_db->peer ? dn_addr2asc(le16_to_cpu(*(__le16 *)dn_db->peer->primary_key), peer_buf) : "");
1388 } 1408 }
1389 return 0; 1409 return 0;
1390 } 1410 }
1391 1411
1392 static struct seq_operations dn_dev_seq_ops = !! 1412 static const struct seq_operations dn_dev_seq_ops = {
1393 .start = dn_dev_seq_start, 1413 .start = dn_dev_seq_start,
1394 .next = dn_dev_seq_next, 1414 .next = dn_dev_seq_next,
1395 .stop = dn_dev_seq_stop, 1415 .stop = dn_dev_seq_stop,
1396 .show = dn_dev_seq_show, 1416 .show = dn_dev_seq_show,
1397 }; 1417 };
1398 1418
1399 static int dn_dev_seq_open(struct inode *inod 1419 static int dn_dev_seq_open(struct inode *inode, struct file *file)
1400 { 1420 {
1401 return seq_open(file, &dn_dev_seq_ops 1421 return seq_open(file, &dn_dev_seq_ops);
1402 } 1422 }
1403 1423
1404 static struct file_operations dn_dev_seq_fops !! 1424 static const struct file_operations dn_dev_seq_fops = {
1405 .owner = THIS_MODULE, 1425 .owner = THIS_MODULE,
1406 .open = dn_dev_seq_open, 1426 .open = dn_dev_seq_open,
1407 .read = seq_read, 1427 .read = seq_read,
1408 .llseek = seq_lseek, 1428 .llseek = seq_lseek,
1409 .release = seq_release, 1429 .release = seq_release,
1410 }; 1430 };
1411 1431
1412 #endif /* CONFIG_PROC_FS */ 1432 #endif /* CONFIG_PROC_FS */
1413 1433
1414 static struct rtnetlink_link dnet_rtnetlink_t !! 1434 static int addr[2];
1415 { <<
1416 [4] = { .doit = dn_dev_rtm_newaddr <<
1417 [5] = { .doit = dn_dev_rtm_deladdr <<
1418 [6] = { .dumpit = dn_dev_dump_ifaddr <<
1419 <<
1420 #ifdef CONFIG_DECNET_ROUTER <<
1421 [8] = { .doit = dn_fib_rtm_newrout <<
1422 [9] = { .doit = dn_fib_rtm_delrout <<
1423 [10] = { .doit = dn_cache_getroute, <<
1424 [16] = { .doit = dn_fib_rtm_newrule <<
1425 [17] = { .doit = dn_fib_rtm_delrule <<
1426 [18] = { .dumpit = dn_fib_dump_rules, <<
1427 #else <<
1428 [10] = { .doit = dn_cache_getroute, <<
1429 #endif <<
1430 <<
1431 }; <<
1432 <<
1433 static int __initdata addr[2]; <<
1434 module_param_array(addr, int, NULL, 0444); 1435 module_param_array(addr, int, NULL, 0444);
1435 MODULE_PARM_DESC(addr, "The DECnet address of 1436 MODULE_PARM_DESC(addr, "The DECnet address of this machine: area,node");
1436 1437
1437 void __init dn_dev_init(void) 1438 void __init dn_dev_init(void)
1438 { 1439 {
1439 if (addr[0] > 63 || addr[0] < 0) { !! 1440 if (addr[0] > 63 || addr[0] < 0) {
1440 printk(KERN_ERR "DECnet: Area !! 1441 printk(KERN_ERR "DECnet: Area must be between 0 and 63");
1441 return; !! 1442 return;
1442 } !! 1443 }
1443 !! 1444
1444 if (addr[1] > 1023 || addr[1] < 0) { !! 1445 if (addr[1] > 1023 || addr[1] < 0) {
1445 printk(KERN_ERR "DECnet: Node !! 1446 printk(KERN_ERR "DECnet: Node must be between 0 and 1023");
1446 return; !! 1447 return;
1447 } !! 1448 }
1448 1449
1449 decnet_address = dn_htons((addr[0] << !! 1450 decnet_address = cpu_to_le16((addr[0] << 10) | addr[1]);
1450 1451
1451 dn_dev_devices_on(); 1452 dn_dev_devices_on();
1452 1453
1453 rtnetlink_links[PF_DECnet] = dnet_rtn !! 1454 rtnl_register(PF_DECnet, RTM_NEWADDR, dn_nl_newaddr, NULL);
>> 1455 rtnl_register(PF_DECnet, RTM_DELADDR, dn_nl_deladdr, NULL);
>> 1456 rtnl_register(PF_DECnet, RTM_GETADDR, NULL, dn_nl_dump_ifaddr);
1454 1457
1455 proc_net_fops_create("decnet_dev", S_ !! 1458 proc_net_fops_create(&init_net, "decnet_dev", S_IRUGO, &dn_dev_seq_fops);
1456 1459
1457 #ifdef CONFIG_SYSCTL 1460 #ifdef CONFIG_SYSCTL
1458 { 1461 {
1459 int i; 1462 int i;
1460 for(i = 0; i < DN_DEV_LIST_SI 1463 for(i = 0; i < DN_DEV_LIST_SIZE; i++)
1461 dn_dev_sysctl_registe 1464 dn_dev_sysctl_register(NULL, &dn_dev_list[i]);
1462 } 1465 }
1463 #endif /* CONFIG_SYSCTL */ 1466 #endif /* CONFIG_SYSCTL */
1464 } 1467 }
1465 1468
1466 void __exit dn_dev_cleanup(void) 1469 void __exit dn_dev_cleanup(void)
1467 { 1470 {
1468 rtnetlink_links[PF_DECnet] = NULL; <<
1469 <<
1470 #ifdef CONFIG_SYSCTL 1471 #ifdef CONFIG_SYSCTL
1471 { 1472 {
1472 int i; 1473 int i;
1473 for(i = 0; i < DN_DEV_LIST_SI 1474 for(i = 0; i < DN_DEV_LIST_SIZE; i++)
1474 dn_dev_sysctl_unregis 1475 dn_dev_sysctl_unregister(&dn_dev_list[i]);
1475 } 1476 }
1476 #endif /* CONFIG_SYSCTL */ 1477 #endif /* CONFIG_SYSCTL */
1477 1478
1478 proc_net_remove("decnet_dev"); !! 1479 proc_net_remove(&init_net, "decnet_dev");
1479 1480
1480 dn_dev_devices_off(); 1481 dn_dev_devices_off();
1481 } 1482 }
1482 1483
|
This page was automatically generated by the
LXR engine.
|