dn_dev.c 34 KB

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