dn_dev.c 34 KB

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