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 .dn_up = dn_eth_up,
91 .down = dn_eth_down, !! 94 .dn_down = dn_eth_down,
92 .timer3 = dn_send_brd_hello, !! 95 .dn_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 .dn_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 .dn_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 .dn_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 .dn_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 .dn_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) ((int) ((char *) &((struct dn_dev_parms *)0)->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, int __user *name, int nlen,
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.dn_down)
336 dn_db->parms.down(dev) !! 309 dn_db->parms.dn_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.dn_up)
339 dn_db->parms.up(dev); !! 312 dn_db->parms.dn_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, int __user *name, int nlen,
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.dn_down)
375 dn_db->parms.down(dev) !! 347 dn_db->parms.dn_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.dn_up)
378 dn_db->parms.up(dev); !! 350 dn_db->parms.dn_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 #ifdef CONFIG_KMOD
527 dev_load(ifr->ifr_name); !! 494 dev_load(&init_net, ifr->ifr_name);
528 #endif 495 #endif
529 496
530 switch(cmd) { 497 switch(cmd) {
531 case SIOCGIFADDR: 498 case SIOCGIFADDR:
532 break; 499 break;
533 case SIOCSIFADDR: 500 case SIOCSIFADDR:
534 if (!capable(CAP_NET_A 501 if (!capable(CAP_NET_ADMIN))
535 return -EACCES 502 return -EACCES;
536 if (sdn->sdn_family != 503 if (sdn->sdn_family != AF_DECnet)
537 return -EINVAL 504 return -EINVAL;
538 break; 505 break;
539 default: 506 default:
540 return -EINVAL; 507 return -EINVAL;
541 } 508 }
542 509
543 rtnl_lock(); 510 rtnl_lock();
544 511
545 if ((dev = __dev_get_by_name(ifr->ifr_ !! 512 if ((dev = __dev_get_by_name(&init_net, ifr->ifr_name)) == NULL) {
546 ret = -ENODEV; 513 ret = -ENODEV;
547 goto done; 514 goto done;
548 } 515 }
549 516
550 if ((dn_db = dev->dn_ptr) != NULL) { 517 if ((dn_db = dev->dn_ptr) != NULL) {
551 for (ifap = &dn_db->ifa_list; 518 for (ifap = &dn_db->ifa_list; (ifa=*ifap) != NULL; ifap = &ifa->ifa_next)
552 if (strcmp(ifr->ifr_na 519 if (strcmp(ifr->ifr_name, ifa->ifa_label) == 0)
553 break; 520 break;
554 } 521 }
555 522
556 if (ifa == NULL && cmd != SIOCSIFADDR) 523 if (ifa == NULL && cmd != SIOCSIFADDR) {
557 ret = -EADDRNOTAVAIL; 524 ret = -EADDRNOTAVAIL;
558 goto done; 525 goto done;
559 } 526 }
560 527
561 switch(cmd) { 528 switch(cmd) {
562 case SIOCGIFADDR: 529 case SIOCGIFADDR:
563 *((dn_address *)sdn->s !! 530 *((__le16 *)sdn->sdn_nodeaddr) = ifa->ifa_local;
564 goto rarok; 531 goto rarok;
565 532
566 case SIOCSIFADDR: 533 case SIOCSIFADDR:
567 if (!ifa) { 534 if (!ifa) {
568 if ((ifa = dn_ 535 if ((ifa = dn_dev_alloc_ifa()) == NULL) {
569 ret = 536 ret = -ENOBUFS;
570 break; 537 break;
571 } 538 }
572 memcpy(ifa->if 539 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
573 } else { 540 } else {
574 if (ifa->ifa_l 541 if (ifa->ifa_local == dn_saddr2dn(sdn))
575 break; 542 break;
576 dn_dev_del_ifa 543 dn_dev_del_ifa(dn_db, ifap, 0);
577 } 544 }
578 545
579 ifa->ifa_local = ifa-> 546 ifa->ifa_local = ifa->ifa_address = dn_saddr2dn(sdn);
580 547
581 ret = dn_dev_set_ifa(d 548 ret = dn_dev_set_ifa(dev, ifa);
582 } 549 }
583 done: 550 done:
584 rtnl_unlock(); 551 rtnl_unlock();
585 552
586 return ret; 553 return ret;
587 rarok: 554 rarok:
588 if (copy_to_user(arg, ifr, DN_IFREQ_SI 555 if (copy_to_user(arg, ifr, DN_IFREQ_SIZE))
589 ret = -EFAULT; 556 ret = -EFAULT;
590 goto done; 557 goto done;
591 } 558 }
592 559
593 struct net_device *dn_dev_get_default(void) 560 struct net_device *dn_dev_get_default(void)
594 { 561 {
595 struct net_device *dev; 562 struct net_device *dev;
596 read_lock(&dndev_lock); 563 read_lock(&dndev_lock);
597 dev = decnet_default_device; 564 dev = decnet_default_device;
598 if (dev) { 565 if (dev) {
599 if (dev->dn_ptr) 566 if (dev->dn_ptr)
600 dev_hold(dev); 567 dev_hold(dev);
601 else 568 else
602 dev = NULL; 569 dev = NULL;
603 } 570 }
604 read_unlock(&dndev_lock); 571 read_unlock(&dndev_lock);
605 return dev; 572 return dev;
606 } 573 }
607 574
608 int dn_dev_set_default(struct net_device *dev, 575 int dn_dev_set_default(struct net_device *dev, int force)
609 { 576 {
610 struct net_device *old = NULL; 577 struct net_device *old = NULL;
611 int rv = -EBUSY; 578 int rv = -EBUSY;
612 if (!dev->dn_ptr) 579 if (!dev->dn_ptr)
613 return -ENODEV; 580 return -ENODEV;
614 write_lock(&dndev_lock); 581 write_lock(&dndev_lock);
615 if (force || decnet_default_device == 582 if (force || decnet_default_device == NULL) {
616 old = decnet_default_device; 583 old = decnet_default_device;
617 decnet_default_device = dev; 584 decnet_default_device = dev;
618 rv = 0; 585 rv = 0;
619 } 586 }
620 write_unlock(&dndev_lock); 587 write_unlock(&dndev_lock);
621 if (old) 588 if (old)
622 dev_put(dev); !! 589 dev_put(old);
623 return rv; 590 return rv;
624 } 591 }
625 592
626 static void dn_dev_check_default(struct net_de 593 static void dn_dev_check_default(struct net_device *dev)
627 { 594 {
628 write_lock(&dndev_lock); 595 write_lock(&dndev_lock);
629 if (dev == decnet_default_device) { 596 if (dev == decnet_default_device) {
630 decnet_default_device = NULL; 597 decnet_default_device = NULL;
631 } else { 598 } else {
632 dev = NULL; 599 dev = NULL;
633 } 600 }
634 write_unlock(&dndev_lock); 601 write_unlock(&dndev_lock);
635 if (dev) 602 if (dev)
636 dev_put(dev); 603 dev_put(dev);
637 } 604 }
638 605
639 static struct dn_dev *dn_dev_by_index(int ifin 606 static struct dn_dev *dn_dev_by_index(int ifindex)
640 { 607 {
641 struct net_device *dev; 608 struct net_device *dev;
642 struct dn_dev *dn_dev = NULL; 609 struct dn_dev *dn_dev = NULL;
643 dev = dev_get_by_index(ifindex); !! 610 dev = dev_get_by_index(&init_net, ifindex);
644 if (dev) { 611 if (dev) {
645 dn_dev = dev->dn_ptr; 612 dn_dev = dev->dn_ptr;
646 dev_put(dev); 613 dev_put(dev);
647 } 614 }
648 615
649 return dn_dev; 616 return dn_dev;
650 } 617 }
651 618
652 static int dn_dev_rtm_deladdr(struct sk_buff * !! 619 static const struct nla_policy dn_ifa_policy[IFA_MAX+1] = {
>> 620 [IFA_ADDRESS] = { .type = NLA_U16 },
>> 621 [IFA_LOCAL] = { .type = NLA_U16 },
>> 622 [IFA_LABEL] = { .type = NLA_STRING,
>> 623 .len = IFNAMSIZ - 1 },
>> 624 };
>> 625
>> 626 static int dn_nl_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
653 { 627 {
654 struct rtattr **rta = arg; !! 628 struct net *net = skb->sk->sk_net;
>> 629 struct nlattr *tb[IFA_MAX+1];
655 struct dn_dev *dn_db; 630 struct dn_dev *dn_db;
656 struct ifaddrmsg *ifm = NLMSG_DATA(nlh !! 631 struct ifaddrmsg *ifm;
657 struct dn_ifaddr *ifa, **ifap; 632 struct dn_ifaddr *ifa, **ifap;
>> 633 int err = -EINVAL;
>> 634
>> 635 if (net != &init_net)
>> 636 goto errout;
658 637
>> 638 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, dn_ifa_policy);
>> 639 if (err < 0)
>> 640 goto errout;
>> 641
>> 642 err = -ENODEV;
>> 643 ifm = nlmsg_data(nlh);
659 if ((dn_db = dn_dev_by_index(ifm->ifa_ 644 if ((dn_db = dn_dev_by_index(ifm->ifa_index)) == NULL)
660 return -EADDRNOTAVAIL; !! 645 goto errout;
>> 646
>> 647 err = -EADDRNOTAVAIL;
>> 648 for (ifap = &dn_db->ifa_list; (ifa = *ifap); ifap = &ifa->ifa_next) {
>> 649 if (tb[IFA_LOCAL] &&
>> 650 nla_memcmp(tb[IFA_LOCAL], &ifa->ifa_local, 2))
>> 651 continue;
661 652
662 for(ifap = &dn_db->ifa_list; (ifa=*ifa !! 653 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; 654 continue;
667 655
668 dn_dev_del_ifa(dn_db, ifap, 1) 656 dn_dev_del_ifa(dn_db, ifap, 1);
669 return 0; 657 return 0;
670 } 658 }
671 659
672 return -EADDRNOTAVAIL; !! 660 errout:
>> 661 return err;
673 } 662 }
674 663
675 static int dn_dev_rtm_newaddr(struct sk_buff * !! 664 static int dn_nl_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
676 { 665 {
677 struct rtattr **rta = arg; !! 666 struct net *net = skb->sk->sk_net;
>> 667 struct nlattr *tb[IFA_MAX+1];
678 struct net_device *dev; 668 struct net_device *dev;
679 struct dn_dev *dn_db; 669 struct dn_dev *dn_db;
680 struct ifaddrmsg *ifm = NLMSG_DATA(nlh !! 670 struct ifaddrmsg *ifm;
681 struct dn_ifaddr *ifa; 671 struct dn_ifaddr *ifa;
682 int rv; !! 672 int err;
>> 673
>> 674 if (net != &init_net)
>> 675 return -EINVAL;
>> 676
>> 677 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, dn_ifa_policy);
>> 678 if (err < 0)
>> 679 return err;
683 680
684 if (rta[IFA_LOCAL-1] == NULL) !! 681 if (tb[IFA_LOCAL] == NULL)
685 return -EINVAL; 682 return -EINVAL;
686 683
687 if ((dev = __dev_get_by_index(ifm->ifa !! 684 ifm = nlmsg_data(nlh);
>> 685 if ((dev = __dev_get_by_index(&init_net, ifm->ifa_index)) == NULL)
688 return -ENODEV; 686 return -ENODEV;
689 687
690 if ((dn_db = dev->dn_ptr) == NULL) { 688 if ((dn_db = dev->dn_ptr) == NULL) {
691 int err; 689 int err;
692 dn_db = dn_dev_create(dev, &er 690 dn_db = dn_dev_create(dev, &err);
693 if (!dn_db) 691 if (!dn_db)
694 return err; 692 return err;
695 } 693 }
696 !! 694
697 if ((ifa = dn_dev_alloc_ifa()) == NULL 695 if ((ifa = dn_dev_alloc_ifa()) == NULL)
698 return -ENOBUFS; 696 return -ENOBUFS;
699 697
700 if (!rta[IFA_ADDRESS - 1]) !! 698 if (tb[IFA_ADDRESS] == NULL)
701 rta[IFA_ADDRESS - 1] = rta[IFA !! 699 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
702 memcpy(&ifa->ifa_local, RTA_DATA(rta[I !! 700
703 memcpy(&ifa->ifa_address, RTA_DATA(rta !! 701 ifa->ifa_local = nla_get_le16(tb[IFA_LOCAL]);
>> 702 ifa->ifa_address = nla_get_le16(tb[IFA_ADDRESS]);
704 ifa->ifa_flags = ifm->ifa_flags; 703 ifa->ifa_flags = ifm->ifa_flags;
705 ifa->ifa_scope = ifm->ifa_scope; 704 ifa->ifa_scope = ifm->ifa_scope;
706 ifa->ifa_dev = dn_db; 705 ifa->ifa_dev = dn_db;
707 if (rta[IFA_LABEL-1]) !! 706
708 rtattr_strlcpy(ifa->ifa_label, !! 707 if (tb[IFA_LABEL])
>> 708 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
709 else 709 else
710 memcpy(ifa->ifa_label, dev->na 710 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
711 711
712 rv = dn_dev_insert_ifa(dn_db, ifa); !! 712 err = dn_dev_insert_ifa(dn_db, ifa);
713 if (rv) !! 713 if (err)
714 dn_dev_free_ifa(ifa); 714 dn_dev_free_ifa(ifa);
715 return rv; !! 715
>> 716 return err;
716 } 717 }
717 718
718 static int dn_dev_fill_ifaddr(struct sk_buff * !! 719 static inline size_t dn_ifaddr_nlmsg_size(void)
719 u32 pid, u32 s !! 720 {
>> 721 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
>> 722 + nla_total_size(IFNAMSIZ) /* IFA_LABEL */
>> 723 + nla_total_size(2) /* IFA_ADDRESS */
>> 724 + nla_total_size(2); /* IFA_LOCAL */
>> 725 }
>> 726
>> 727 static int dn_nl_fill_ifaddr(struct sk_buff *skb, struct dn_ifaddr *ifa,
>> 728 u32 pid, u32 seq, int event, unsigned int flags)
720 { 729 {
721 struct ifaddrmsg *ifm; 730 struct ifaddrmsg *ifm;
722 struct nlmsghdr *nlh; 731 struct nlmsghdr *nlh;
723 unsigned char *b = skb->tail; <<
724 732
725 nlh = NLMSG_PUT(skb, pid, seq, event, !! 733 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags);
726 ifm = NLMSG_DATA(nlh); !! 734 if (nlh == NULL)
>> 735 return -EMSGSIZE;
727 736
>> 737 ifm = nlmsg_data(nlh);
728 ifm->ifa_family = AF_DECnet; 738 ifm->ifa_family = AF_DECnet;
729 ifm->ifa_prefixlen = 16; 739 ifm->ifa_prefixlen = 16;
730 ifm->ifa_flags = ifa->ifa_flags | IFA_ 740 ifm->ifa_flags = ifa->ifa_flags | IFA_F_PERMANENT;
731 ifm->ifa_scope = ifa->ifa_scope; 741 ifm->ifa_scope = ifa->ifa_scope;
732 ifm->ifa_index = ifa->ifa_dev->dev->if 742 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
>> 743
733 if (ifa->ifa_address) 744 if (ifa->ifa_address)
734 RTA_PUT(skb, IFA_ADDRESS, 2, & !! 745 NLA_PUT_LE16(skb, IFA_ADDRESS, ifa->ifa_address);
735 if (ifa->ifa_local) 746 if (ifa->ifa_local)
736 RTA_PUT(skb, IFA_LOCAL, 2, &if !! 747 NLA_PUT_LE16(skb, IFA_LOCAL, ifa->ifa_local);
737 if (ifa->ifa_label[0]) 748 if (ifa->ifa_label[0])
738 RTA_PUT(skb, IFA_LABEL, IFNAMS !! 749 NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label);
739 nlh->nlmsg_len = skb->tail - b; <<
740 return skb->len; <<
741 750
742 nlmsg_failure: !! 751 return nlmsg_end(skb, nlh);
743 rtattr_failure: !! 752
744 skb_trim(skb, b - skb->data); !! 753 nla_put_failure:
745 return -1; !! 754 nlmsg_cancel(skb, nlh);
>> 755 return -EMSGSIZE;
746 } 756 }
747 757
748 static void rtmsg_ifa(int event, struct dn_ifa !! 758 static void dn_ifaddr_notify(int event, struct dn_ifaddr *ifa)
749 { 759 {
750 struct sk_buff *skb; 760 struct sk_buff *skb;
751 int size = NLMSG_SPACE(sizeof(struct i !! 761 int err = -ENOBUFS;
752 762
753 skb = alloc_skb(size, GFP_KERNEL); !! 763 skb = alloc_skb(dn_ifaddr_nlmsg_size(), GFP_KERNEL);
754 if (!skb) { !! 764 if (skb == NULL)
755 netlink_set_err(rtnl, 0, RTMGR !! 765 goto errout;
756 return; !! 766
757 } !! 767 err = dn_nl_fill_ifaddr(skb, ifa, 0, 0, event, 0);
758 if (dn_dev_fill_ifaddr(skb, ifa, 0, 0, !! 768 if (err < 0) {
>> 769 /* -EMSGSIZE implies BUG in dn_ifaddr_nlmsg_size() */
>> 770 WARN_ON(err == -EMSGSIZE);
759 kfree_skb(skb); 771 kfree_skb(skb);
760 netlink_set_err(rtnl, 0, RTMGR !! 772 goto errout;
761 return; <<
762 } 773 }
763 NETLINK_CB(skb).dst_groups = RTMGRP_DE !! 774 err = rtnl_notify(skb, &init_net, 0, RTNLGRP_DECnet_IFADDR, NULL, GFP_KERNEL);
764 netlink_broadcast(rtnl, skb, 0, RTMGRP !! 775 errout:
>> 776 if (err < 0)
>> 777 rtnl_set_sk_err(&init_net, RTNLGRP_DECnet_IFADDR, err);
765 } 778 }
766 779
767 static int dn_dev_dump_ifaddr(struct sk_buff * !! 780 static int dn_nl_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
768 { 781 {
769 int idx, dn_idx; !! 782 struct net *net = skb->sk->sk_net;
770 int s_idx, s_dn_idx; !! 783 int idx, dn_idx = 0, skip_ndevs, skip_naddr;
771 struct net_device *dev; 784 struct net_device *dev;
772 struct dn_dev *dn_db; 785 struct dn_dev *dn_db;
773 struct dn_ifaddr *ifa; 786 struct dn_ifaddr *ifa;
774 787
775 s_idx = cb->args[0]; !! 788 if (net != &init_net)
776 s_dn_idx = dn_idx = cb->args[1]; !! 789 return 0;
777 read_lock(&dev_base_lock); !! 790
778 for(dev = dev_base, idx = 0; dev; dev !! 791 skip_ndevs = cb->args[0];
779 if (idx < s_idx) !! 792 skip_naddr = cb->args[1];
780 continue; !! 793
781 if (idx > s_idx) !! 794 idx = 0;
782 s_dn_idx = 0; !! 795 for_each_netdev(&init_net, dev) {
>> 796 if (idx < skip_ndevs)
>> 797 goto cont;
>> 798 else if (idx > skip_ndevs) {
>> 799 /* Only skip over addresses for first dev dumped
>> 800 * in this iteration (idx == skip_ndevs) */
>> 801 skip_naddr = 0;
>> 802 }
>> 803
783 if ((dn_db = dev->dn_ptr) == N 804 if ((dn_db = dev->dn_ptr) == NULL)
784 continue; !! 805 goto cont;
785 806
786 for(ifa = dn_db->ifa_list, dn_ !! 807 for (ifa = dn_db->ifa_list, dn_idx = 0; ifa;
787 if (dn_idx < s_dn_idx) !! 808 ifa = ifa->ifa_next, dn_idx++) {
>> 809 if (dn_idx < skip_naddr)
788 continue; 810 continue;
789 811
790 if (dn_dev_fill_ifaddr !! 812 if (dn_nl_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
791 !! 813 cb->nlh->nlmsg_seq, RTM_NEWADDR,
792 !! 814 NLM_F_MULTI) < 0)
793 <<
794 goto done; 815 goto done;
795 } 816 }
>> 817 cont:
>> 818 idx++;
796 } 819 }
797 done: 820 done:
798 read_unlock(&dev_base_lock); <<
799 cb->args[0] = idx; 821 cb->args[0] = idx;
800 cb->args[1] = dn_idx; 822 cb->args[1] = dn_idx;
801 823
802 return skb->len; 824 return skb->len;
803 } 825 }
804 826
805 static int dn_dev_get_first(struct net_device !! 827 static int dn_dev_get_first(struct net_device *dev, __le16 *addr)
806 { 828 {
807 struct dn_dev *dn_db = (struct dn_dev 829 struct dn_dev *dn_db = (struct dn_dev *)dev->dn_ptr;
808 struct dn_ifaddr *ifa; 830 struct dn_ifaddr *ifa;
809 int rv = -ENODEV; 831 int rv = -ENODEV;
810 if (dn_db == NULL) 832 if (dn_db == NULL)
811 goto out; 833 goto out;
812 ifa = dn_db->ifa_list; 834 ifa = dn_db->ifa_list;
813 if (ifa != NULL) { 835 if (ifa != NULL) {
814 *addr = ifa->ifa_local; 836 *addr = ifa->ifa_local;
815 rv = 0; 837 rv = 0;
816 } 838 }
817 out: 839 out:
818 return rv; 840 return rv;
819 } 841 }
820 842
821 /* !! 843 /*
822 * Find a default address to bind to. 844 * Find a default address to bind to.
823 * 845 *
824 * This is one of those areas where the initia 846 * This is one of those areas where the initial VMS concepts don't really
825 * map onto the Linux concepts, and since we i 847 * map onto the Linux concepts, and since we introduced multiple addresses
826 * per interface we have to cope with slightly 848 * per interface we have to cope with slightly odd ways of finding out what
827 * "our address" really is. Mostly it's not a 849 * "our address" really is. Mostly it's not a problem; for this we just guess
828 * a sensible default. Eventually the routing 850 * a sensible default. Eventually the routing code will take care of all the
829 * nasties for us I hope. 851 * nasties for us I hope.
830 */ 852 */
831 int dn_dev_bind_default(dn_address *addr) !! 853 int dn_dev_bind_default(__le16 *addr)
832 { 854 {
833 struct net_device *dev; 855 struct net_device *dev;
834 int rv; 856 int rv;
835 dev = dn_dev_get_default(); 857 dev = dn_dev_get_default();
836 last_chance: 858 last_chance:
837 if (dev) { 859 if (dev) {
838 read_lock(&dev_base_lock); 860 read_lock(&dev_base_lock);
839 rv = dn_dev_get_first(dev, add 861 rv = dn_dev_get_first(dev, addr);
840 read_unlock(&dev_base_lock); 862 read_unlock(&dev_base_lock);
841 dev_put(dev); 863 dev_put(dev);
842 if (rv == 0 || dev == &loopbac !! 864 if (rv == 0 || dev == init_net.loopback_dev)
843 return rv; 865 return rv;
844 } 866 }
845 dev = &loopback_dev; !! 867 dev = init_net.loopback_dev;
846 dev_hold(dev); 868 dev_hold(dev);
847 goto last_chance; 869 goto last_chance;
848 } 870 }
849 871
850 static void dn_send_endnode_hello(struct net_d 872 static void dn_send_endnode_hello(struct net_device *dev, struct dn_ifaddr *ifa)
851 { 873 {
852 struct endnode_hello_message *msg; !! 874 struct endnode_hello_message *msg;
853 struct sk_buff *skb = NULL; !! 875 struct sk_buff *skb = NULL;
854 unsigned short int *pktlen; !! 876 __le16 *pktlen;
855 struct dn_dev *dn_db = (struct dn_dev 877 struct dn_dev *dn_db = (struct dn_dev *)dev->dn_ptr;
856 878
857 if ((skb = dn_alloc_skb(NULL, sizeof(* !! 879 if ((skb = dn_alloc_skb(NULL, sizeof(*msg), GFP_ATOMIC)) == NULL)
858 return; 880 return;
859 881
860 skb->dev = dev; !! 882 skb->dev = dev;
861 883
862 msg = (struct endnode_hello_message *) !! 884 msg = (struct endnode_hello_message *)skb_put(skb,sizeof(*msg));
863 885
864 msg->msgflg = 0x0D; !! 886 msg->msgflg = 0x0D;
865 memcpy(msg->tiver, dn_eco_version, 3); !! 887 memcpy(msg->tiver, dn_eco_version, 3);
866 dn_dn2eth(msg->id, ifa->ifa_local); 888 dn_dn2eth(msg->id, ifa->ifa_local);
867 msg->iinfo = DN_RT_INFO_ENDN; !! 889 msg->iinfo = DN_RT_INFO_ENDN;
868 msg->blksize = dn_htons(mtu2blksize(de !! 890 msg->blksize = dn_htons(mtu2blksize(dev));
869 msg->area = 0x00; !! 891 msg->area = 0x00;
870 memset(msg->seed, 0, 8); !! 892 memset(msg->seed, 0, 8);
871 memcpy(msg->neighbor, dn_hiord, ETH_AL !! 893 memcpy(msg->neighbor, dn_hiord, ETH_ALEN);
872 894
873 if (dn_db->router) { 895 if (dn_db->router) {
874 struct dn_neigh *dn = (struct 896 struct dn_neigh *dn = (struct dn_neigh *)dn_db->router;
875 dn_dn2eth(msg->neighbor, dn->a 897 dn_dn2eth(msg->neighbor, dn->addr);
876 } 898 }
877 899
878 msg->timer = dn_htons((unsigned shor !! 900 msg->timer = dn_htons((unsigned short)dn_db->parms.t3);
879 msg->mpd = 0x00; !! 901 msg->mpd = 0x00;
880 msg->datalen = 0x02; !! 902 msg->datalen = 0x02;
881 memset(msg->data, 0xAA, 2); !! 903 memset(msg->data, 0xAA, 2);
882 !! 904
883 pktlen = (unsigned short *)skb_push(sk !! 905 pktlen = (__le16 *)skb_push(skb,2);
884 *pktlen = dn_htons(skb->len - 2); !! 906 *pktlen = dn_htons(skb->len - 2);
885 907
886 skb->nh.raw = skb->data; !! 908 skb_reset_network_header(skb);
887 909
888 dn_rt_finish_output(skb, dn_rt_all_rt_ 910 dn_rt_finish_output(skb, dn_rt_all_rt_mcast, msg->id);
889 } 911 }
890 912
891 913
892 #define DRDELAY (5 * HZ) 914 #define DRDELAY (5 * HZ)
893 915
894 static int dn_am_i_a_router(struct dn_neigh *d 916 static int dn_am_i_a_router(struct dn_neigh *dn, struct dn_dev *dn_db, struct dn_ifaddr *ifa)
895 { 917 {
896 /* First check time since device went 918 /* First check time since device went up */
897 if ((jiffies - dn_db->uptime) < DRDELA 919 if ((jiffies - dn_db->uptime) < DRDELAY)
898 return 0; 920 return 0;
899 921
900 /* If there is no router, then yes... 922 /* If there is no router, then yes... */
901 if (!dn_db->router) 923 if (!dn_db->router)
902 return 1; 924 return 1;
903 925
904 /* otherwise only if we have a higher 926 /* otherwise only if we have a higher priority or.. */
905 if (dn->priority < dn_db->parms.priori 927 if (dn->priority < dn_db->parms.priority)
906 return 1; 928 return 1;
907 929
908 /* if we have equal priority and a hig 930 /* if we have equal priority and a higher node number */
909 if (dn->priority != dn_db->parms.prior 931 if (dn->priority != dn_db->parms.priority)
910 return 0; 932 return 0;
911 933
912 if (dn_ntohs(dn->addr) < dn_ntohs(ifa- 934 if (dn_ntohs(dn->addr) < dn_ntohs(ifa->ifa_local))
913 return 1; 935 return 1;
914 936
915 return 0; 937 return 0;
916 } 938 }
917 939
918 static void dn_send_router_hello(struct net_de 940 static void dn_send_router_hello(struct net_device *dev, struct dn_ifaddr *ifa)
919 { 941 {
920 int n; 942 int n;
921 struct dn_dev *dn_db = dev->dn_ptr; 943 struct dn_dev *dn_db = dev->dn_ptr;
922 struct dn_neigh *dn = (struct dn_neigh 944 struct dn_neigh *dn = (struct dn_neigh *)dn_db->router;
923 struct sk_buff *skb; 945 struct sk_buff *skb;
924 size_t size; 946 size_t size;
925 unsigned char *ptr; 947 unsigned char *ptr;
926 unsigned char *i1, *i2; 948 unsigned char *i1, *i2;
927 unsigned short *pktlen; !! 949 __le16 *pktlen;
928 char *src; 950 char *src;
929 951
930 if (mtu2blksize(dev) < (26 + 7)) 952 if (mtu2blksize(dev) < (26 + 7))
931 return; 953 return;
932 954
933 n = mtu2blksize(dev) - 26; 955 n = mtu2blksize(dev) - 26;
934 n /= 7; 956 n /= 7;
935 957
936 if (n > 32) 958 if (n > 32)
937 n = 32; 959 n = 32;
938 960
939 size = 2 + 26 + 7 * n; 961 size = 2 + 26 + 7 * n;
940 962
941 if ((skb = dn_alloc_skb(NULL, size, GF 963 if ((skb = dn_alloc_skb(NULL, size, GFP_ATOMIC)) == NULL)
942 return; 964 return;
943 965
944 skb->dev = dev; 966 skb->dev = dev;
945 ptr = skb_put(skb, size); 967 ptr = skb_put(skb, size);
946 968
947 *ptr++ = DN_RT_PKT_CNTL | DN_RT_PKT_ER 969 *ptr++ = DN_RT_PKT_CNTL | DN_RT_PKT_ERTH;
948 *ptr++ = 2; /* ECO */ 970 *ptr++ = 2; /* ECO */
949 *ptr++ = 0; 971 *ptr++ = 0;
950 *ptr++ = 0; 972 *ptr++ = 0;
951 dn_dn2eth(ptr, ifa->ifa_local); 973 dn_dn2eth(ptr, ifa->ifa_local);
952 src = ptr; 974 src = ptr;
953 ptr += ETH_ALEN; 975 ptr += ETH_ALEN;
954 *ptr++ = dn_db->parms.forwarding == 1 !! 976 *ptr++ = dn_db->parms.forwarding == 1 ?
955 DN_RT_INFO_L1RT : DN_R 977 DN_RT_INFO_L1RT : DN_RT_INFO_L2RT;
956 *((unsigned short *)ptr) = dn_htons(mt !! 978 *((__le16 *)ptr) = dn_htons(mtu2blksize(dev));
957 ptr += 2; 979 ptr += 2;
958 *ptr++ = dn_db->parms.priority; /* Pri !! 980 *ptr++ = dn_db->parms.priority; /* Priority */
959 *ptr++ = 0; /* Area: Reserved */ 981 *ptr++ = 0; /* Area: Reserved */
960 *((unsigned short *)ptr) = dn_htons((u !! 982 *((__le16 *)ptr) = dn_htons((unsigned short)dn_db->parms.t3);
961 ptr += 2; 983 ptr += 2;
962 *ptr++ = 0; /* MPD: Reserved */ 984 *ptr++ = 0; /* MPD: Reserved */
963 i1 = ptr++; 985 i1 = ptr++;
964 memset(ptr, 0, 7); /* Name: Reserved * 986 memset(ptr, 0, 7); /* Name: Reserved */
965 ptr += 7; 987 ptr += 7;
966 i2 = ptr++; 988 i2 = ptr++;
967 989
968 n = dn_neigh_elist(dev, ptr, n); 990 n = dn_neigh_elist(dev, ptr, n);
969 991
970 *i2 = 7 * n; 992 *i2 = 7 * n;
971 *i1 = 8 + *i2; 993 *i1 = 8 + *i2;
972 994
973 skb_trim(skb, (27 + *i2)); 995 skb_trim(skb, (27 + *i2));
974 996
975 pktlen = (unsigned short *)skb_push(sk !! 997 pktlen = (__le16 *)skb_push(skb, 2);
976 *pktlen = dn_htons(skb->len - 2); 998 *pktlen = dn_htons(skb->len - 2);
977 999
978 skb->nh.raw = skb->data; !! 1000 skb_reset_network_header(skb);
979 1001
980 if (dn_am_i_a_router(dn, dn_db, ifa)) 1002 if (dn_am_i_a_router(dn, dn_db, ifa)) {
981 struct sk_buff *skb2 = skb_cop 1003 struct sk_buff *skb2 = skb_copy(skb, GFP_ATOMIC);
982 if (skb2) { 1004 if (skb2) {
983 dn_rt_finish_output(sk 1005 dn_rt_finish_output(skb2, dn_rt_all_end_mcast, src);
984 } 1006 }
985 } 1007 }
986 1008
987 dn_rt_finish_output(skb, dn_rt_all_rt_ 1009 dn_rt_finish_output(skb, dn_rt_all_rt_mcast, src);
988 } 1010 }
989 1011
990 static void dn_send_brd_hello(struct net_devic 1012 static void dn_send_brd_hello(struct net_device *dev, struct dn_ifaddr *ifa)
991 { 1013 {
992 struct dn_dev *dn_db = (struct dn_dev 1014 struct dn_dev *dn_db = (struct dn_dev *)dev->dn_ptr;
993 1015
994 if (dn_db->parms.forwarding == 0) 1016 if (dn_db->parms.forwarding == 0)
995 dn_send_endnode_hello(dev, ifa 1017 dn_send_endnode_hello(dev, ifa);
996 else 1018 else
997 dn_send_router_hello(dev, ifa) 1019 dn_send_router_hello(dev, ifa);
998 } 1020 }
999 1021
1000 static void dn_send_ptp_hello(struct net_devi 1022 static void dn_send_ptp_hello(struct net_device *dev, struct dn_ifaddr *ifa)
1001 { 1023 {
1002 int tdlen = 16; 1024 int tdlen = 16;
1003 int size = dev->hard_header_len + 2 + 1025 int size = dev->hard_header_len + 2 + 4 + tdlen;
1004 struct sk_buff *skb = dn_alloc_skb(NU 1026 struct sk_buff *skb = dn_alloc_skb(NULL, size, GFP_ATOMIC);
1005 int i; 1027 int i;
1006 unsigned char *ptr; 1028 unsigned char *ptr;
1007 char src[ETH_ALEN]; 1029 char src[ETH_ALEN];
1008 1030
1009 if (skb == NULL) 1031 if (skb == NULL)
1010 return ; 1032 return ;
1011 1033
1012 skb->dev = dev; 1034 skb->dev = dev;
1013 skb_push(skb, dev->hard_header_len); 1035 skb_push(skb, dev->hard_header_len);
1014 ptr = skb_put(skb, 2 + 4 + tdlen); 1036 ptr = skb_put(skb, 2 + 4 + tdlen);
1015 1037
1016 *ptr++ = DN_RT_PKT_HELO; 1038 *ptr++ = DN_RT_PKT_HELO;
1017 *((dn_address *)ptr) = ifa->ifa_local !! 1039 *((__le16 *)ptr) = ifa->ifa_local;
1018 ptr += 2; 1040 ptr += 2;
1019 *ptr++ = tdlen; 1041 *ptr++ = tdlen;
1020 1042
1021 for(i = 0; i < tdlen; i++) 1043 for(i = 0; i < tdlen; i++)
1022 *ptr++ = 0252; 1044 *ptr++ = 0252;
1023 1045
1024 dn_dn2eth(src, ifa->ifa_local); 1046 dn_dn2eth(src, ifa->ifa_local);
1025 dn_rt_finish_output(skb, dn_rt_all_rt 1047 dn_rt_finish_output(skb, dn_rt_all_rt_mcast, src);
1026 } 1048 }
1027 1049
1028 static int dn_eth_up(struct net_device *dev) 1050 static int dn_eth_up(struct net_device *dev)
1029 { 1051 {
1030 struct dn_dev *dn_db = dev->dn_ptr; 1052 struct dn_dev *dn_db = dev->dn_ptr;
1031 1053
1032 if (dn_db->parms.forwarding == 0) 1054 if (dn_db->parms.forwarding == 0)
1033 dev_mc_add(dev, dn_rt_all_end 1055 dev_mc_add(dev, dn_rt_all_end_mcast, ETH_ALEN, 0);
1034 else 1056 else
1035 dev_mc_add(dev, dn_rt_all_rt_ 1057 dev_mc_add(dev, dn_rt_all_rt_mcast, ETH_ALEN, 0);
1036 1058
1037 dev_mc_upload(dev); <<
1038 <<
1039 dn_db->use_long = 1; 1059 dn_db->use_long = 1;
1040 1060
1041 return 0; 1061 return 0;
1042 } 1062 }
1043 1063
1044 static void dn_eth_down(struct net_device *de 1064 static void dn_eth_down(struct net_device *dev)
1045 { 1065 {
1046 struct dn_dev *dn_db = dev->dn_ptr; 1066 struct dn_dev *dn_db = dev->dn_ptr;
1047 1067
1048 if (dn_db->parms.forwarding == 0) 1068 if (dn_db->parms.forwarding == 0)
1049 dev_mc_delete(dev, dn_rt_all_ 1069 dev_mc_delete(dev, dn_rt_all_end_mcast, ETH_ALEN, 0);
1050 else 1070 else
1051 dev_mc_delete(dev, dn_rt_all_ 1071 dev_mc_delete(dev, dn_rt_all_rt_mcast, ETH_ALEN, 0);
1052 } 1072 }
1053 1073
1054 static void dn_dev_set_timer(struct net_devic 1074 static void dn_dev_set_timer(struct net_device *dev);
1055 1075
1056 static void dn_dev_timer_func(unsigned long a 1076 static void dn_dev_timer_func(unsigned long arg)
1057 { 1077 {
1058 struct net_device *dev = (struct net_ 1078 struct net_device *dev = (struct net_device *)arg;
1059 struct dn_dev *dn_db = dev->dn_ptr; 1079 struct dn_dev *dn_db = dev->dn_ptr;
1060 struct dn_ifaddr *ifa; 1080 struct dn_ifaddr *ifa;
1061 1081
1062 if (dn_db->t3 <= dn_db->parms.t2) { 1082 if (dn_db->t3 <= dn_db->parms.t2) {
1063 if (dn_db->parms.timer3) { !! 1083 if (dn_db->parms.dn_timer3) {
1064 for(ifa = dn_db->ifa_ 1084 for(ifa = dn_db->ifa_list; ifa; ifa = ifa->ifa_next) {
1065 if (!(ifa->if 1085 if (!(ifa->ifa_flags & IFA_F_SECONDARY))
1066 dn_db !! 1086 dn_db->parms.dn_timer3(dev, ifa);
1067 } 1087 }
1068 } 1088 }
1069 dn_db->t3 = dn_db->parms.t3; 1089 dn_db->t3 = dn_db->parms.t3;
1070 } else { 1090 } else {
1071 dn_db->t3 -= dn_db->parms.t2; 1091 dn_db->t3 -= dn_db->parms.t2;
1072 } 1092 }
1073 1093
1074 dn_dev_set_timer(dev); 1094 dn_dev_set_timer(dev);
1075 } 1095 }
1076 1096
1077 static void dn_dev_set_timer(struct net_devic 1097 static void dn_dev_set_timer(struct net_device *dev)
1078 { 1098 {
1079 struct dn_dev *dn_db = dev->dn_ptr; 1099 struct dn_dev *dn_db = dev->dn_ptr;
1080 1100
1081 if (dn_db->parms.t2 > dn_db->parms.t3 1101 if (dn_db->parms.t2 > dn_db->parms.t3)
1082 dn_db->parms.t2 = dn_db->parm 1102 dn_db->parms.t2 = dn_db->parms.t3;
1083 1103
1084 dn_db->timer.data = (unsigned long)de 1104 dn_db->timer.data = (unsigned long)dev;
1085 dn_db->timer.function = dn_dev_timer_ 1105 dn_db->timer.function = dn_dev_timer_func;
1086 dn_db->timer.expires = jiffies + (dn_ 1106 dn_db->timer.expires = jiffies + (dn_db->parms.t2 * HZ);
1087 1107
1088 add_timer(&dn_db->timer); 1108 add_timer(&dn_db->timer);
1089 } 1109 }
1090 1110
1091 struct dn_dev *dn_dev_create(struct net_devic 1111 struct dn_dev *dn_dev_create(struct net_device *dev, int *err)
1092 { 1112 {
1093 int i; 1113 int i;
1094 struct dn_dev_parms *p = dn_dev_list; 1114 struct dn_dev_parms *p = dn_dev_list;
1095 struct dn_dev *dn_db; 1115 struct dn_dev *dn_db;
1096 1116
1097 for(i = 0; i < DN_DEV_LIST_SIZE; i++, 1117 for(i = 0; i < DN_DEV_LIST_SIZE; i++, p++) {
1098 if (p->type == dev->type) 1118 if (p->type == dev->type)
1099 break; 1119 break;
1100 } 1120 }
1101 1121
1102 *err = -ENODEV; 1122 *err = -ENODEV;
1103 if (i == DN_DEV_LIST_SIZE) 1123 if (i == DN_DEV_LIST_SIZE)
1104 return NULL; 1124 return NULL;
1105 1125
1106 *err = -ENOBUFS; 1126 *err = -ENOBUFS;
1107 if ((dn_db = kmalloc(sizeof(struct dn !! 1127 if ((dn_db = kzalloc(sizeof(struct dn_dev), GFP_ATOMIC)) == NULL)
1108 return NULL; 1128 return NULL;
1109 1129
1110 memset(dn_db, 0, sizeof(struct dn_dev <<
1111 memcpy(&dn_db->parms, p, sizeof(struc 1130 memcpy(&dn_db->parms, p, sizeof(struct dn_dev_parms));
1112 smp_wmb(); 1131 smp_wmb();
1113 dev->dn_ptr = dn_db; 1132 dev->dn_ptr = dn_db;
1114 dn_db->dev = dev; 1133 dn_db->dev = dev;
1115 init_timer(&dn_db->timer); 1134 init_timer(&dn_db->timer);
1116 1135
1117 dn_db->uptime = jiffies; 1136 dn_db->uptime = jiffies;
1118 if (dn_db->parms.up) { !! 1137
1119 if (dn_db->parms.up(dev) < 0) !! 1138 dn_db->neigh_parms = neigh_parms_alloc(dev, &dn_neigh_table);
>> 1139 if (!dn_db->neigh_parms) {
>> 1140 dev->dn_ptr = NULL;
>> 1141 kfree(dn_db);
>> 1142 return NULL;
>> 1143 }
>> 1144
>> 1145 if (dn_db->parms.dn_up) {
>> 1146 if (dn_db->parms.dn_up(dev) < 0) {
>> 1147 neigh_parms_release(&dn_neigh_table, dn_db->neigh_parms);
1120 dev->dn_ptr = NULL; 1148 dev->dn_ptr = NULL;
1121 kfree(dn_db); 1149 kfree(dn_db);
1122 return NULL; 1150 return NULL;
1123 } 1151 }
1124 } 1152 }
1125 1153
1126 dn_db->neigh_parms = neigh_parms_allo <<
1127 <<
1128 dn_dev_sysctl_register(dev, &dn_db->p 1154 dn_dev_sysctl_register(dev, &dn_db->parms);
1129 1155
1130 dn_dev_set_timer(dev); 1156 dn_dev_set_timer(dev);
1131 1157
1132 *err = 0; 1158 *err = 0;
1133 return dn_db; 1159 return dn_db;
1134 } 1160 }
1135 1161
1136 1162
1137 /* 1163 /*
1138 * This processes a device up event. We only 1164 * This processes a device up event. We only start up
1139 * the loopback device & ethernet devices wit 1165 * the loopback device & ethernet devices with correct
1140 * MAC addreses automatically. Others must be 1166 * MAC addreses automatically. Others must be started
1141 * specifically. 1167 * specifically.
1142 * 1168 *
1143 * FIXME: How should we configure the loopbac 1169 * FIXME: How should we configure the loopback address ? If we could dispense
1144 * with using decnet_address here and for aut 1170 * with using decnet_address here and for autobind, it will be one less thing
1145 * for users to worry about setting up. 1171 * for users to worry about setting up.
1146 */ 1172 */
1147 1173
1148 void dn_dev_up(struct net_device *dev) 1174 void dn_dev_up(struct net_device *dev)
1149 { 1175 {
1150 struct dn_ifaddr *ifa; 1176 struct dn_ifaddr *ifa;
1151 dn_address addr = decnet_address; !! 1177 __le16 addr = decnet_address;
1152 int maybe_default = 0; 1178 int maybe_default = 0;
1153 struct dn_dev *dn_db = (struct dn_dev 1179 struct dn_dev *dn_db = (struct dn_dev *)dev->dn_ptr;
1154 1180
1155 if ((dev->type != ARPHRD_ETHER) && (d 1181 if ((dev->type != ARPHRD_ETHER) && (dev->type != ARPHRD_LOOPBACK))
1156 return; 1182 return;
1157 1183
1158 /* 1184 /*
1159 * Need to ensure that loopback devic 1185 * Need to ensure that loopback device has a dn_db attached to it
1160 * to allow creation of neighbours ag 1186 * to allow creation of neighbours against it, even though it might
1161 * not have a local address of its ow 1187 * not have a local address of its own. Might as well do the same for
1162 * all autoconfigured interfaces. 1188 * all autoconfigured interfaces.
1163 */ 1189 */
1164 if (dn_db == NULL) { 1190 if (dn_db == NULL) {
1165 int err; 1191 int err;
1166 dn_db = dn_dev_create(dev, &e 1192 dn_db = dn_dev_create(dev, &err);
1167 if (dn_db == NULL) 1193 if (dn_db == NULL)
1168 return; 1194 return;
1169 } 1195 }
1170 1196
1171 if (dev->type == ARPHRD_ETHER) { 1197 if (dev->type == ARPHRD_ETHER) {
1172 if (memcmp(dev->dev_addr, dn_ 1198 if (memcmp(dev->dev_addr, dn_hiord, 4) != 0)
1173 return; 1199 return;
1174 addr = dn_htons(dn_eth2dn(dev !! 1200 addr = dn_eth2dn(dev->dev_addr);
1175 maybe_default = 1; 1201 maybe_default = 1;
1176 } 1202 }
1177 1203
1178 if (addr == 0) 1204 if (addr == 0)
1179 return; 1205 return;
1180 1206
1181 if ((ifa = dn_dev_alloc_ifa()) == NUL 1207 if ((ifa = dn_dev_alloc_ifa()) == NULL)
1182 return; 1208 return;
1183 1209
1184 ifa->ifa_local = ifa->ifa_address = a 1210 ifa->ifa_local = ifa->ifa_address = addr;
1185 ifa->ifa_flags = 0; 1211 ifa->ifa_flags = 0;
1186 ifa->ifa_scope = RT_SCOPE_UNIVERSE; 1212 ifa->ifa_scope = RT_SCOPE_UNIVERSE;
1187 strcpy(ifa->ifa_label, dev->name); 1213 strcpy(ifa->ifa_label, dev->name);
1188 1214
1189 dn_dev_set_ifa(dev, ifa); 1215 dn_dev_set_ifa(dev, ifa);
1190 1216
1191 /* 1217 /*
1192 * Automagically set the default devi 1218 * Automagically set the default device to the first automatically
1193 * configured ethernet card in the sy 1219 * configured ethernet card in the system.
1194 */ 1220 */
1195 if (maybe_default) { 1221 if (maybe_default) {
1196 dev_hold(dev); 1222 dev_hold(dev);
1197 if (dn_dev_set_default(dev, 0 1223 if (dn_dev_set_default(dev, 0))
1198 dev_put(dev); 1224 dev_put(dev);
1199 } 1225 }
1200 } 1226 }
1201 1227
1202 static void dn_dev_delete(struct net_device * 1228 static void dn_dev_delete(struct net_device *dev)
1203 { 1229 {
1204 struct dn_dev *dn_db = dev->dn_ptr; 1230 struct dn_dev *dn_db = dev->dn_ptr;
1205 1231
1206 if (dn_db == NULL) 1232 if (dn_db == NULL)
1207 return; 1233 return;
1208 1234
1209 del_timer_sync(&dn_db->timer); 1235 del_timer_sync(&dn_db->timer);
1210 dn_dev_sysctl_unregister(&dn_db->parm 1236 dn_dev_sysctl_unregister(&dn_db->parms);
1211 dn_dev_check_default(dev); 1237 dn_dev_check_default(dev);
1212 neigh_ifdown(&dn_neigh_table, dev); 1238 neigh_ifdown(&dn_neigh_table, dev);
1213 1239
1214 if (dn_db->parms.down) !! 1240 if (dn_db->parms.dn_down)
1215 dn_db->parms.down(dev); !! 1241 dn_db->parms.dn_down(dev);
1216 1242
1217 dev->dn_ptr = NULL; 1243 dev->dn_ptr = NULL;
1218 1244
1219 neigh_parms_release(&dn_neigh_table, 1245 neigh_parms_release(&dn_neigh_table, dn_db->neigh_parms);
1220 neigh_ifdown(&dn_neigh_table, dev); 1246 neigh_ifdown(&dn_neigh_table, dev);
1221 1247
1222 if (dn_db->router) 1248 if (dn_db->router)
1223 neigh_release(dn_db->router); 1249 neigh_release(dn_db->router);
1224 if (dn_db->peer) 1250 if (dn_db->peer)
1225 neigh_release(dn_db->peer); 1251 neigh_release(dn_db->peer);
1226 1252
1227 kfree(dn_db); 1253 kfree(dn_db);
1228 } 1254 }
1229 1255
1230 void dn_dev_down(struct net_device *dev) 1256 void dn_dev_down(struct net_device *dev)
1231 { 1257 {
1232 struct dn_dev *dn_db = dev->dn_ptr; 1258 struct dn_dev *dn_db = dev->dn_ptr;
1233 struct dn_ifaddr *ifa; 1259 struct dn_ifaddr *ifa;
1234 1260
1235 if (dn_db == NULL) 1261 if (dn_db == NULL)
1236 return; 1262 return;
1237 1263
1238 while((ifa = dn_db->ifa_list) != NULL 1264 while((ifa = dn_db->ifa_list) != NULL) {
1239 dn_dev_del_ifa(dn_db, &dn_db- 1265 dn_dev_del_ifa(dn_db, &dn_db->ifa_list, 0);
1240 dn_dev_free_ifa(ifa); 1266 dn_dev_free_ifa(ifa);
1241 } 1267 }
1242 1268
1243 dn_dev_delete(dev); 1269 dn_dev_delete(dev);
1244 } 1270 }
1245 1271
1246 void dn_dev_init_pkt(struct sk_buff *skb) 1272 void dn_dev_init_pkt(struct sk_buff *skb)
1247 { 1273 {
1248 return; 1274 return;
1249 } 1275 }
1250 1276
1251 void dn_dev_veri_pkt(struct sk_buff *skb) 1277 void dn_dev_veri_pkt(struct sk_buff *skb)
1252 { 1278 {
1253 return; 1279 return;
1254 } 1280 }
1255 1281
1256 void dn_dev_hello(struct sk_buff *skb) 1282 void dn_dev_hello(struct sk_buff *skb)
1257 { 1283 {
1258 return; 1284 return;
1259 } 1285 }
1260 1286
1261 void dn_dev_devices_off(void) 1287 void dn_dev_devices_off(void)
1262 { 1288 {
1263 struct net_device *dev; 1289 struct net_device *dev;
1264 1290
1265 rtnl_lock(); 1291 rtnl_lock();
1266 for(dev = dev_base; dev; dev = dev->n !! 1292 for_each_netdev(&init_net, dev)
1267 dn_dev_down(dev); 1293 dn_dev_down(dev);
1268 rtnl_unlock(); 1294 rtnl_unlock();
1269 1295
1270 } 1296 }
1271 1297
1272 void dn_dev_devices_on(void) 1298 void dn_dev_devices_on(void)
1273 { 1299 {
1274 struct net_device *dev; 1300 struct net_device *dev;
1275 1301
1276 rtnl_lock(); 1302 rtnl_lock();
1277 for(dev = dev_base; dev; dev = dev->n !! 1303 for_each_netdev(&init_net, dev) {
1278 if (dev->flags & IFF_UP) 1304 if (dev->flags & IFF_UP)
1279 dn_dev_up(dev); 1305 dn_dev_up(dev);
1280 } 1306 }
1281 rtnl_unlock(); 1307 rtnl_unlock();
1282 } 1308 }
1283 1309
1284 int register_dnaddr_notifier(struct notifier_ 1310 int register_dnaddr_notifier(struct notifier_block *nb)
1285 { 1311 {
1286 return notifier_chain_register(&dnadd !! 1312 return blocking_notifier_chain_register(&dnaddr_chain, nb);
1287 } 1313 }
1288 1314
1289 int unregister_dnaddr_notifier(struct notifie 1315 int unregister_dnaddr_notifier(struct notifier_block *nb)
1290 { 1316 {
1291 return notifier_chain_unregister(&dna !! 1317 return blocking_notifier_chain_unregister(&dnaddr_chain, nb);
1292 } 1318 }
1293 1319
1294 #ifdef CONFIG_PROC_FS 1320 #ifdef CONFIG_PROC_FS
1295 static inline struct net_device *dn_dev_get_n !! 1321 static inline int is_dn_dev(struct net_device *dev)
1296 { 1322 {
1297 do { !! 1323 return dev->dn_ptr != NULL;
1298 dev = dev->next; <<
1299 } while(dev && !dev->dn_ptr); <<
1300 <<
1301 return dev; <<
1302 } 1324 }
1303 1325
1304 static struct net_device *dn_dev_get_idx(stru !! 1326 static void *dn_dev_seq_start(struct seq_file *seq, loff_t *pos)
1305 { 1327 {
>> 1328 int i;
1306 struct net_device *dev; 1329 struct net_device *dev;
1307 1330
1308 dev = dev_base; !! 1331 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 1332
1318 static void *dn_dev_seq_start(struct seq_file !! 1333 if (*pos == 0)
1319 { !! 1334 return SEQ_START_TOKEN;
1320 if (*pos) { !! 1335
1321 struct net_device *dev; !! 1336 i = 1;
1322 read_lock(&dev_base_lock); !! 1337 for_each_netdev(&init_net, dev) {
1323 dev = dn_dev_get_idx(seq, *po !! 1338 if (!is_dn_dev(dev))
1324 if (dev == NULL) !! 1339 continue;
1325 read_unlock(&dev_base !! 1340
1326 return dev; !! 1341 if (i++ == *pos)
>> 1342 return dev;
1327 } 1343 }
1328 return SEQ_START_TOKEN; !! 1344
>> 1345 return NULL;
1329 } 1346 }
1330 1347
1331 static void *dn_dev_seq_next(struct seq_file 1348 static void *dn_dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1332 { 1349 {
1333 struct net_device *dev = v; !! 1350 struct net_device *dev;
1334 loff_t one = 1; <<
1335 1351
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; 1352 ++*pos;
1344 return dev; !! 1353
>> 1354 dev = (struct net_device *)v;
>> 1355 if (v == SEQ_START_TOKEN)
>> 1356 dev = net_device_entry(&init_net.dev_base_head);
>> 1357
>> 1358 for_each_netdev_continue(&init_net, dev) {
>> 1359 if (!is_dn_dev(dev))
>> 1360 continue;
>> 1361
>> 1362 return dev;
>> 1363 }
>> 1364
>> 1365 return NULL;
1345 } 1366 }
1346 1367
1347 static void dn_dev_seq_stop(struct seq_file * 1368 static void dn_dev_seq_stop(struct seq_file *seq, void *v)
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(dn_ntohs(*(__le16 *)dn_db->router->primary_key), router_buf) : "",
1387 dn_db->peer ? !! 1407 dn_db->peer ? dn_addr2asc(dn_ntohs(*(__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 = dn_htons((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.
|