开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
ddp.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：52k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

ddp.c：源码内容
  1. /*
  2.  * DDP: An implementation of the AppleTalk DDP protocol for
  3.  * Ethernet 'ELAP'.
  4.  *
  5.  * Alan Cox  <Alan.Cox@linux.org>
  6.  *
  7.  * With more than a little assistance from
  8.  *
  9.  * Wesley Craig <netatalk@umich.edu>
  10.  *
  11.  * Fixes:
  12.  * Michael Callahan : Made routing work
  13.  * Wesley Craig : Fix probing to listen to a
  14.  * passed node id.
  15.  * Alan Cox : Added send/recvmsg support
  16.  * Alan Cox : Moved at. to protinfo in
  17.  * socket.
  18.  * Alan Cox : Added firewall hooks.
  19.  * Alan Cox : Supports new ARPHRD_LOOPBACK
  20.  * Christer Weinigel :  Routing and /proc fixes.
  21.  * Bradford Johnson : LocalTalk.
  22.  * Tom Dyas : Module support.
  23.  * Alan Cox : Hooks for PPP (based on the
  24.  * LocalTalk hook).
  25.  * Alan Cox : Posix bits
  26.  * Alan Cox/Mike Freeman : Possible fix to NBP problems
  27.  * Bradford Johnson : IP-over-DDP (experimental)
  28.  * Jay Schulist : Moved IP-over-DDP to its own
  29.  * driver file. (ipddp.c & ipddp.h)
  30.  * Jay Schulist : Made work as module with 
  31.  * AppleTalk drivers, cleaned it.
  32.  * Rob Newberry : Added proxy AARP and AARP
  33.  * procfs, moved probing to AARP
  34.  * module.
  35.  *              Adrian Sun/ 
  36.  *              Michael Zuelsdorff      :       fix for net.0 packets. don't 
  37.  *                                              allow illegal ether/tokentalk
  38.  *                                              port assignment. we lose a 
  39.  *                                              valid localtalk port as a 
  40.  *                                              result.
  41.  * Arnaldo C. de Melo : Cleanup, in preparation for
  42.  * shared skb support 8)
  43.  *
  44.  * This program is free software; you can redistribute it and/or
  45.  * modify it under the terms of the GNU General Public License
  46.  * as published by the Free Software Foundation; either version
  47.  * 2 of the License, or (at your option) any later version.
  48.  * 
  49.  */
  51. #include <linux/config.h>
  52. #if defined(CONFIG_ATALK) || defined(CONFIG_ATALK_MODULE)
  53. #include <linux/module.h>
  54. #include <asm/uaccess.h>
  55. #include <asm/system.h>
  56. #include <asm/bitops.h>
  57. #include <linux/types.h>
  58. #include <linux/kernel.h>
  59. #include <linux/sched.h>
  60. #include <linux/string.h>
  61. #include <linux/mm.h>
  62. #include <linux/socket.h>
  63. #include <linux/sockios.h>
  64. #include <linux/in.h>
  65. #include <linux/errno.h>
  66. #include <linux/interrupt.h>
  67. #include <linux/if_ether.h>
  68. #include <linux/notifier.h>
  69. #include <linux/netdevice.h>
  70. #include <linux/inetdevice.h>
  71. #include <linux/route.h>
  72. #include <linux/inet.h>
  73. #include <linux/etherdevice.h>
  74. #include <linux/if_arp.h>
  75. #include <linux/skbuff.h>
  76. #include <linux/spinlock.h>
  77. #include <linux/termios.h> /* For TIOCOUTQ/INQ */
  78. #include <net/datalink.h>
  79. #include <net/p8022.h>
  80. #include <net/psnap.h>
  81. #include <net/sock.h>
  82. #include <linux/ip.h>
  83. #include <net/route.h>
  84. #include <linux/atalk.h>
  85. #include <linux/proc_fs.h>
  86. #include <linux/stat.h>
  87. #include <linux/init.h>
  89. #ifdef CONFIG_PROC_FS
  90. extern void aarp_register_proc_fs(void);
  91. extern void aarp_unregister_proc_fs(void);
  92. #endif
  94. extern void aarp_cleanup_module(void);
  96. extern void aarp_probe_network(struct atalk_iface *atif);
  97. extern int  aarp_proxy_probe_network(struct atalk_iface *atif,
  98. struct at_addr *sa);
  99. extern void aarp_proxy_remove(struct net_device *dev, struct at_addr *sa);
  101. #undef APPLETALK_DEBUG
  102. #ifdef APPLETALK_DEBUG
  103. #define DPRINT(x) print(x)
  104. #else
  105. #define DPRINT(x)
  106. #endif /* APPLETALK_DEBUG */
  108. #ifdef CONFIG_SYSCTL
  109. extern inline void atalk_register_sysctl(void);
  110. extern inline void atalk_unregister_sysctl(void);
  111. #endif /* CONFIG_SYSCTL */
  113. struct datalink_proto *ddp_dl, *aarp_dl;
  114. static struct proto_ops atalk_dgram_ops;
  116. /**************************************************************************
  117. *                                                                          *
  118. * Handlers for the socket list.                                            *
  119. *                                                                          *
  120. **************************************************************************/
  122. static struct sock *atalk_sockets;
  123. static spinlock_t atalk_sockets_lock = SPIN_LOCK_UNLOCKED;
  125. extern inline void atalk_insert_socket(struct sock *sk)
  126. {
  127. spin_lock_bh(&atalk_sockets_lock);
  128. sk->next = atalk_sockets;
  129. if (sk->next)
  130. atalk_sockets->pprev = &sk->next;
  131. atalk_sockets = sk;
  132. sk->pprev = &atalk_sockets;
  133. spin_unlock_bh(&atalk_sockets_lock);
  134. }
  136. extern inline void atalk_remove_socket(struct sock *sk)
  137. {
  138. spin_lock_bh(&atalk_sockets_lock);
  139. if (sk->pprev) {
  140. if (sk->next)
  141. sk->next->pprev = sk->pprev;
  142. *sk->pprev = sk->next;
  143. sk->pprev = NULL;
  144. }
  145. spin_unlock_bh(&atalk_sockets_lock);
  146. }
  148. static struct sock *atalk_search_socket(struct sockaddr_at *to,
  149. struct atalk_iface *atif)
  150. {
  151. struct sock *s;
  153. spin_lock_bh(&atalk_sockets_lock);
  154. for (s = atalk_sockets; s; s = s->next) {
  155. if (to->sat_port != s->protinfo.af_at.src_port)
  156. continue;
  158.      if (to->sat_addr.s_net == ATADDR_ANYNET &&
  159.     to->sat_addr.s_node == ATADDR_BCAST &&
  160.     s->protinfo.af_at.src_net == atif->address.s_net)
  161. break;
  163.      if (to->sat_addr.s_net == s->protinfo.af_at.src_net &&
  164.     (to->sat_addr.s_node == s->protinfo.af_at.src_node ||
  165.      to->sat_addr.s_node == ATADDR_BCAST ||
  166.      to->sat_addr.s_node == ATADDR_ANYNODE))
  167. break;
  169.      /* XXXX.0 -- we got a request for this router. make sure
  170.  * that the node is appropriately set. */
  171. if (to->sat_addr.s_node == ATADDR_ANYNODE &&
  172.     to->sat_addr.s_net != ATADDR_ANYNET &&
  173.     atif->address.s_node == s->protinfo.af_at.src_node) {
  174. to->sat_addr.s_node = atif->address.s_node;
  175. break; 
  176. }
  177. }
  178. spin_unlock_bh(&atalk_sockets_lock);
  179. return s;
  180. }
  182. /*
  183.  * Try to find a socket matching ADDR in the socket list,
  184.  * if found then return it.  If not, insert SK into the
  185.  * socket list.
  186.  *
  187.  * This entire operation must execute atomically.
  188.  */
  189. static struct sock *atalk_find_or_insert_socket(struct sock *sk,
  190. struct sockaddr_at *sat)
  191. {
  192. struct sock *s;
  194. spin_lock_bh(&atalk_sockets_lock);
  195. for (s = atalk_sockets; s; s = s->next)
  196. if (s->protinfo.af_at.src_net == sat->sat_addr.s_net &&
  197.     s->protinfo.af_at.src_node == sat->sat_addr.s_node &&
  198.     s->protinfo.af_at.src_port == sat->sat_port)
  199. break;
  201. if (!s) {
  202. /* Wheee, it's free, assign and insert. */
  203. sk->next = atalk_sockets;
  204. if (sk->next)
  205. atalk_sockets->pprev = &sk->next;
  206. atalk_sockets = sk;
  207. sk->pprev = &atalk_sockets;
  208. }
  210. spin_unlock_bh(&atalk_sockets_lock);
  211. return s;
  212. }
  214. static void atalk_destroy_timer(unsigned long data)
  215. {
  216. struct sock *sk = (struct sock *) data;
  218. if (!atomic_read(&sk->wmem_alloc) &&
  219.     !atomic_read(&sk->rmem_alloc) && sk->dead) {
  220. sock_put(sk);
  221. MOD_DEC_USE_COUNT;
  222. } else {
  223. sk->timer.expires = jiffies + SOCK_DESTROY_TIME;
  224. add_timer(&sk->timer);
  225. }
  226. }
  228. extern inline void atalk_destroy_socket(struct sock *sk)
  229. {
  230. atalk_remove_socket(sk);
  231. skb_queue_purge(&sk->receive_queue);
  233. if (!atomic_read(&sk->wmem_alloc) &&
  234.     !atomic_read(&sk->rmem_alloc) && sk->dead) {
  235. sock_put(sk);
  236. MOD_DEC_USE_COUNT;
  237. } else {
  238. init_timer(&sk->timer);
  239. sk->timer.expires = jiffies + SOCK_DESTROY_TIME;
  240. sk->timer.function = atalk_destroy_timer;
  241. sk->timer.data = (unsigned long) sk;
  242. add_timer(&sk->timer);
  243. }
  244. }
  246. /* Called from proc fs */
  247. static int atalk_get_info(char *buffer, char **start, off_t offset, int length)
  248. {
  249. off_t pos = 0;
  250. off_t begin = 0;
  251. int len = sprintf(buffer, "Type local_addr  remote_addr tx_queue "
  252.   "rx_queue st uidn");
  253. struct sock *s;
  254. /* Output the AppleTalk data for the /proc filesystem */
  256. spin_lock_bh(&atalk_sockets_lock);
  257. for (s = atalk_sockets; s; s = s->next) {
  258. len += sprintf(buffer + len,"%02X   ", s->type);
  259. len += sprintf(buffer + len,"%04X:%02X:%02X  ",
  260.        ntohs(s->protinfo.af_at.src_net),
  261.        s->protinfo.af_at.src_node,
  262.        s->protinfo.af_at.src_port);
  263. len += sprintf(buffer + len,"%04X:%02X:%02X  ",
  264.        ntohs(s->protinfo.af_at.dest_net),
  265.        s->protinfo.af_at.dest_node,
  266.        s->protinfo.af_at.dest_port);
  267. len += sprintf(buffer + len,"%08X:%08X ",
  268.        atomic_read(&s->wmem_alloc),
  269.        atomic_read(&s->rmem_alloc));
  270. len += sprintf(buffer + len,"%02X %dn", s->state, 
  271.        SOCK_INODE(s->socket)->i_uid);
  273. /* Are we still dumping unwanted data then discard the record */
  274. pos = begin + len;
  276. if (pos < offset) {
  277. len = 0; /* Keep dumping into the buffer start */
  278. begin = pos;
  279. }
  280. if (pos > offset + length) /* We have dumped enough */
  281. break;
  282. }
  283. spin_unlock_bh(&atalk_sockets_lock);
  285. /* The data in question runs from begin to begin+len */
  286. *start = buffer + offset - begin; /* Start of wanted data */
  287. len -= offset - begin;   /* Remove unwanted header data from length */
  288. if (len > length)
  289. len = length;    /* Remove unwanted tail data from length */
  291. return len;
  292. }
  294. /**************************************************************************
  295. *                                                                          *
  296. * Routing tables for the AppleTalk socket layer.                           *
  297. *                                                                          *
  298. **************************************************************************/
  300. /* Anti-deadlock ordering is router_lock --> iface_lock -DaveM */
  301. static struct atalk_route *atalk_router_list;
  302. static rwlock_t atalk_router_lock = RW_LOCK_UNLOCKED;
  304. static struct atalk_iface *atalk_iface_list;
  305. static spinlock_t atalk_iface_lock = SPIN_LOCK_UNLOCKED;
  307. /* For probing devices or in a routerless network */
  308. static struct atalk_route atrtr_default;
  310. /* AppleTalk interface control */
  311. /*
  312.  * Drop a device. Doesn't drop any of its routes - that is the caller's
  313.  * problem. Called when we down the interface or delete the address.
  314.  */
  315. static void atif_drop_device(struct net_device *dev)
  316. {
  317. struct atalk_iface **iface = &atalk_iface_list;
  318. struct atalk_iface *tmp;
  320. spin_lock_bh(&atalk_iface_lock);
  321. while ((tmp = *iface) != NULL) {
  322. if (tmp->dev == dev) {
  323. *iface = tmp->next;
  324. kfree(tmp);
  325. dev->atalk_ptr = NULL;
  326. MOD_DEC_USE_COUNT;
  327. } else
  328. iface = &tmp->next;
  329. }
  330. spin_unlock_bh(&atalk_iface_lock);
  331. }
  333. static struct atalk_iface *atif_add_device(struct net_device *dev,
  334.    struct at_addr *sa)
  335. {
  336. struct atalk_iface *iface = kmalloc(sizeof(*iface), GFP_KERNEL);
  338. if (!iface)
  339. return NULL;
  341. iface->dev = dev;
  342. dev->atalk_ptr = iface;
  343. iface->address = *sa;
  344. iface->status = 0;
  346. spin_lock_bh(&atalk_iface_lock);
  347. iface->next = atalk_iface_list;
  348. atalk_iface_list = iface;
  349. spin_unlock_bh(&atalk_iface_lock);
  351. MOD_INC_USE_COUNT;
  352. return iface;
  353. }
  355. /* Perform phase 2 AARP probing on our tentative address */
  356. static int atif_probe_device(struct atalk_iface *atif)
  357. {
  358. int netrange = ntohs(atif->nets.nr_lastnet) -
  359. ntohs(atif->nets.nr_firstnet) + 1;
  360. int probe_net = ntohs(atif->address.s_net);
  361. int probe_node = atif->address.s_node;
  362. int netct, nodect;
  364. /* Offset the network we start probing with */
  365. if (probe_net == ATADDR_ANYNET) {
  366. probe_net = ntohs(atif->nets.nr_firstnet);
  367. if (netrange)
  368. probe_net += jiffies % netrange;
  369. }
  370. if (probe_node == ATADDR_ANYNODE)
  371. probe_node = jiffies & 0xFF;
  373. /* Scan the networks */
  374. atif->status |= ATIF_PROBE;
  375. for (netct = 0; netct <= netrange; netct++) {
  376. /* Sweep the available nodes from a given start */
  377. atif->address.s_net = htons(probe_net);
  378. for (nodect = 0; nodect < 256; nodect++) {
  379. atif->address.s_node = ((nodect+probe_node) & 0xFF);
  380. if (atif->address.s_node > 0 &&
  381.     atif->address.s_node < 254) {
  382. /* Probe a proposed address */
  383. aarp_probe_network(atif);
  385. if (!(atif->status & ATIF_PROBE_FAIL)) {
  386. atif->status &= ~ATIF_PROBE;
  387. return 0;
  388. }
  389. }
  390. atif->status &= ~ATIF_PROBE_FAIL;
  391. }
  392. probe_net++;
  393. if (probe_net > ntohs(atif->nets.nr_lastnet))
  394. probe_net = ntohs(atif->nets.nr_firstnet);
  395. }
  396. atif->status &= ~ATIF_PROBE;
  398. return -EADDRINUSE; /* Network is full... */
  399. }
  402. /* Perform AARP probing for a proxy address */
  403. static int atif_proxy_probe_device(struct atalk_iface *atif,
  404.    struct at_addr* proxy_addr)
  405. {
  406. int netrange = ntohs(atif->nets.nr_lastnet) -
  407. ntohs(atif->nets.nr_firstnet) + 1;
  408. /* we probe the interface's network */
  409. int probe_net = ntohs(atif->address.s_net);
  410. int probe_node = ATADDR_ANYNODE;     /* we'll take anything */
  411. int netct, nodect;
  413. /* Offset the network we start probing with */
  414. if (probe_net == ATADDR_ANYNET) {
  415. probe_net = ntohs(atif->nets.nr_firstnet);
  416. if (netrange)
  417. probe_net += jiffies % netrange;
  418. }
  420. if (probe_node == ATADDR_ANYNODE)
  421. probe_node = jiffies & 0xFF;
  423. /* Scan the networks */
  424. for (netct = 0; netct <= netrange; netct++) {
  425. /* Sweep the available nodes from a given start */
  426. proxy_addr->s_net = htons(probe_net);
  427. for (nodect = 0; nodect < 256; nodect++) {
  428. proxy_addr->s_node = ((nodect + probe_node) & 0xFF);
  429. if (proxy_addr->s_node > 0 &&
  430.     proxy_addr->s_node < 254) {
  431. /* Tell AARP to probe a proposed address */
  432. int ret = aarp_proxy_probe_network(atif,
  433.     proxy_addr);
  435. if (ret != -EADDRINUSE)
  436. return ret;
  437. }
  438. }
  439. probe_net++;
  440. if (probe_net > ntohs(atif->nets.nr_lastnet))
  441. probe_net = ntohs(atif->nets.nr_firstnet);
  442. }
  444. return -EADDRINUSE; /* Network is full... */
  445. }
  448. struct at_addr *atalk_find_dev_addr(struct net_device *dev)
  449. {
  450. struct atalk_iface *iface = dev->atalk_ptr;
  451. return iface ? &iface->address : NULL;
  452. }
  454. static struct at_addr *atalk_find_primary(void)
  455. {
  456. struct atalk_iface *fiface = NULL;
  457. struct at_addr *retval;
  458. struct atalk_iface *iface;
  460. /*
  461.  * Return a point-to-point interface only if
  462.  * there is no non-ptp interface available.
  463.  */
  464. spin_lock_bh(&atalk_iface_lock);
  465. for (iface = atalk_iface_list; iface; iface = iface->next) {
  466. if (!fiface && !(iface->dev->flags & IFF_LOOPBACK))
  467. fiface = iface;
  468. if (!(iface->dev->flags & (IFF_LOOPBACK | IFF_POINTOPOINT))) {
  469. retval = &iface->address;
  470. goto out;
  471. }
  472. }
  474. if (fiface)
  475. retval = &fiface->address;
  476. else if (atalk_iface_list)
  477. retval = &atalk_iface_list->address;
  478. else
  479. retval = NULL;
  480. out: spin_unlock_bh(&atalk_iface_lock);
  481. return retval;
  482. }
  484. /*
  485.  * Find a match for 'any network' - ie any of our interfaces with that
  486.  * node number will do just nicely.
  487.  */
  488. static struct atalk_iface *atalk_find_anynet(int node, struct net_device *dev)
  489. {
  490. struct atalk_iface *iface = dev->atalk_ptr;
  492. if (!iface || iface->status & ATIF_PROBE)
  493. return NULL;
  495. if (node == ATADDR_BCAST ||
  496.     iface->address.s_node == node ||
  497.     node == ATADDR_ANYNODE)
  498. return iface;
  500. return NULL;
  501. }
  503. /* Find a match for a specific network:node pair */
  504. static struct atalk_iface *atalk_find_interface(int net, int node)
  505. {
  506. struct atalk_iface *iface;
  508. spin_lock_bh(&atalk_iface_lock);
  509. for (iface = atalk_iface_list; iface; iface = iface->next) {
  510. if ((node == ATADDR_BCAST ||
  511.      node == ATADDR_ANYNODE ||
  512.      iface->address.s_node == node) &&
  513.     iface->address.s_net == net &&
  514.     !(iface->status & ATIF_PROBE))
  515. break;
  517. /* XXXX.0 -- net.0 returns the iface associated with net */
  518. if (node == ATADDR_ANYNODE && net != ATADDR_ANYNET &&
  519.     ntohs(iface->nets.nr_firstnet) <= ntohs(net) &&
  520.     ntohs(net) <= ntohs(iface->nets.nr_lastnet))
  521.         break;
  522. }
  523. spin_unlock_bh(&atalk_iface_lock);
  524. return iface;
  525. }
  528. /*
  529.  * Find a route for an AppleTalk packet. This ought to get cached in
  530.  * the socket (later on...). We know about host routes and the fact
  531.  * that a route must be direct to broadcast.
  532.  */
  533. static struct atalk_route *atrtr_find(struct at_addr *target)
  534. {
  535. /*
  536.  * we must search through all routes unless we find a 
  537.  * host route, because some host routes might overlap
  538.  * network routes
  539.  */
  540. struct atalk_route *net_route = NULL;
  541. struct atalk_route *r;
  543. read_lock_bh(&atalk_router_lock);
  544. for (r = atalk_router_list; r; r = r->next) {
  545. if (!(r->flags & RTF_UP))
  546. continue;
  548. if (r->target.s_net == target->s_net) {
  549. if (r->flags & RTF_HOST) {
  550. /*
  551.  * if this host route is for the target,
  552.  * the we're done
  553.  */
  554. if (r->target.s_node == target->s_node)
  555. goto out;
  556. } else
  557. /*
  558.  * this route will work if there isn't a
  559.  * direct host route, so cache it
  560.  */
  561. net_route = r;
  562. }
  563. }
  565. /* 
  566.  * if we found a network route but not a direct host
  567.  * route, then return it
  568.  */
  569. if (net_route)
  570. r = net_route;
  571. else if (atrtr_default.dev)
  572. r = &atrtr_default;
  573. else /* No route can be found */
  574. r = NULL;
  575. out: read_unlock_bh(&atalk_router_lock);
  576. return r;
  577. }
  580. /*
  581.  * Given an AppleTalk network, find the device to use. This can be
  582.  * a simple lookup.
  583.  */
  584. struct net_device *atrtr_get_dev(struct at_addr *sa)
  585. {
  586. struct atalk_route *atr = atrtr_find(sa);
  587. return atr ? atr->dev : NULL;
  588. }
  590. /* Set up a default router */
  591. static void atrtr_set_default(struct net_device *dev)
  592. {
  593. atrtr_default.dev = dev;
  594. atrtr_default.flags = RTF_UP;
  595. atrtr_default.gateway.s_net = htons(0);
  596. atrtr_default.gateway.s_node = 0;
  597. }
  599. /*
  600.  * Add a router. Basically make sure it looks valid and stuff the
  601.  * entry in the list. While it uses netranges we always set them to one
  602.  * entry to work like netatalk.
  603.  */
  604. static int atrtr_create(struct rtentry *r, struct net_device *devhint)
  605. {
  606. struct sockaddr_at *ta = (struct sockaddr_at *)&r->rt_dst;
  607. struct sockaddr_at *ga = (struct sockaddr_at *)&r->rt_gateway;
  608. struct atalk_route *rt;
  609. struct atalk_iface *iface, *riface;
  610. int retval;
  612. /*
  613.  * Fixme: Raise/Lower a routing change semaphore for these
  614.  * operations.
  615.  */
  617. /* Validate the request */
  618. if (ta->sat_family != AF_APPLETALK)
  619. return -EINVAL;
  621. if (!devhint && ga->sat_family != AF_APPLETALK)
  622. return -EINVAL;
  624. /* Now walk the routing table and make our decisions */
  625. write_lock_bh(&atalk_router_lock);
  626. for (rt = atalk_router_list; rt; rt = rt->next) {
  627. if (r->rt_flags != rt->flags)
  628. continue;
  630. if (ta->sat_addr.s_net == rt->target.s_net) {
  631. if (!(rt->flags & RTF_HOST))
  632. break;
  633. if (ta->sat_addr.s_node == rt->target.s_node)
  634. break;
  635. }
  636. }
  638. if (!devhint) {
  639. riface = NULL;
  641. spin_lock_bh(&atalk_iface_lock);
  642. for (iface = atalk_iface_list; iface; iface = iface->next) {
  643. if (!riface &&
  644.     ntohs(ga->sat_addr.s_net) >=
  645.      ntohs(iface->nets.nr_firstnet) &&
  646.     ntohs(ga->sat_addr.s_net) <=
  647.      ntohs(iface->nets.nr_lastnet))
  648. riface = iface;
  650. if (ga->sat_addr.s_net == iface->address.s_net &&
  651.     ga->sat_addr.s_node == iface->address.s_node)
  652. riface = iface;
  653. }
  654. spin_unlock_bh(&atalk_iface_lock);
  656. retval = -ENETUNREACH;
  657. if (!riface)
  658. goto out;
  660. devhint = riface->dev;
  661. }
  663. if (!rt) {
  664. rt = kmalloc(sizeof(struct atalk_route), GFP_ATOMIC);
  666. retval = -ENOBUFS;
  667. if (!rt)
  668. goto out;
  670. rt->next = atalk_router_list;
  671. atalk_router_list = rt;
  672. }
  674. /* Fill in the routing entry */
  675. rt->target  = ta->sat_addr;
  676. rt->dev     = devhint;
  677. rt->flags   = r->rt_flags;
  678. rt->gateway = ga->sat_addr;
  680. retval = 0;
  681. out: write_unlock_bh(&atalk_router_lock);
  682. return retval;
  683. }
  685. /* Delete a route. Find it and discard it */
  686. static int atrtr_delete(struct at_addr * addr)
  687. {
  688. struct atalk_route **r = &atalk_router_list;
  689. int retval = 0;
  690. struct atalk_route *tmp;
  692. write_lock_bh(&atalk_router_lock);
  693. while ((tmp = *r) != NULL) {
  694. if (tmp->target.s_net == addr->s_net &&
  695.     (!(tmp->flags&RTF_GATEWAY) ||
  696.      tmp->target.s_node == addr->s_node)) {
  697. *r = tmp->next;
  698. kfree(tmp);
  699. goto out;
  700. }
  701. r = &tmp->next;
  702. }
  703. retval = -ENOENT;
  704. out: write_unlock_bh(&atalk_router_lock);
  705. return retval;
  706. }
  708. /*
  709.  * Called when a device is downed. Just throw away any routes
  710.  * via it.
  711.  */
  712. void atrtr_device_down(struct net_device *dev)
  713. {
  714. struct atalk_route **r = &atalk_router_list;
  715. struct atalk_route *tmp;
  717. write_lock_bh(&atalk_router_lock);
  718. while ((tmp = *r) != NULL) {
  719. if (tmp->dev == dev) {
  720. *r = tmp->next;
  721. kfree(tmp);
  722. } else
  723. r = &tmp->next;
  724. }
  725. write_unlock_bh(&atalk_router_lock);
  727. if (atrtr_default.dev == dev)
  728. atrtr_set_default(NULL);
  729. }
  731. /* Actually down the interface */
  732. static inline void atalk_dev_down(struct net_device *dev)
  733. {
  734. atrtr_device_down(dev); /* Remove all routes for the device */
  735. aarp_device_down(dev); /* Remove AARP entries for the device */
  736. atif_drop_device(dev); /* Remove the device */
  737. }
  739. /*
  740.  * A device event has occurred. Watch for devices going down and
  741.  * delete our use of them (iface and route).
  742.  */
  743. static int ddp_device_event(struct notifier_block *this, unsigned long event,
  744. void *ptr)
  745. {
  746. if (event == NETDEV_DOWN)
  747. /* Discard any use of this */
  748.         atalk_dev_down((struct net_device *) ptr);
  750. return NOTIFY_DONE;
  751. }
  753. /* ioctl calls. Shouldn't even need touching */
  754. /* Device configuration ioctl calls */
  755. static int atif_ioctl(int cmd, void *arg)
  756. {
  757. static char aarp_mcast[6] = {0x09, 0x00, 0x00, 0xFF, 0xFF, 0xFF};
  758. struct ifreq atreq;
  759. struct netrange *nr;
  760. struct sockaddr_at *sa;
  761. struct net_device *dev;
  762. struct atalk_iface *atif;
  763. int ct;
  764. int limit;
  765. struct rtentry rtdef;
  766. int add_route;
  768. if (copy_from_user(&atreq, arg, sizeof(atreq)))
  769. return -EFAULT;
  771. dev = __dev_get_by_name(atreq.ifr_name);
  772. if (!dev)
  773. return -ENODEV;
  775. sa = (struct sockaddr_at*) &atreq.ifr_addr;
  776. atif = atalk_find_dev(dev);
  778. switch (cmd) {
  779. case SIOCSIFADDR:
  780. if (!capable(CAP_NET_ADMIN))
  781. return -EPERM;
  782. if (sa->sat_family != AF_APPLETALK)
  783. return -EINVAL;
  784. if (dev->type != ARPHRD_ETHER &&
  785.     dev->type != ARPHRD_LOOPBACK &&
  786.     dev->type != ARPHRD_LOCALTLK &&
  787.     dev->type != ARPHRD_PPP)
  788. return -EPROTONOSUPPORT;
  790. nr = (struct netrange *) &sa->sat_zero[0];
  791. add_route = 1;
  793. /*
  794.  * if this is a point-to-point iface, and we already
  795.  * have an iface for this AppleTalk address, then we
  796.  * should not add a route
  797.  */
  798. if ((dev->flags & IFF_POINTOPOINT) &&
  799.     atalk_find_interface(sa->sat_addr.s_net,
  800.       sa->sat_addr.s_node)) {
  801. printk(KERN_DEBUG "AppleTalk: point-to-point "
  802.   "interface added with "
  803.   "existing addressn");
  804. add_route = 0;
  805. }
  807. /*
  808.  * Phase 1 is fine on LocalTalk but we don't do
  809.  * EtherTalk phase 1. Anyone wanting to add it go ahead.
  810.  */
  811. if (dev->type == ARPHRD_ETHER && nr->nr_phase != 2)
  812. return -EPROTONOSUPPORT;
  813. if (sa->sat_addr.s_node == ATADDR_BCAST ||
  814.     sa->sat_addr.s_node == 254)
  815. return -EINVAL;
  816. if (atif) {
  817. /* Already setting address */
  818. if (atif->status & ATIF_PROBE)
  819. return -EBUSY;
  821. atif->address.s_net  = sa->sat_addr.s_net;
  822. atif->address.s_node = sa->sat_addr.s_node;
  823. atrtr_device_down(dev); /* Flush old routes */
  824. } else {
  825. atif = atif_add_device(dev, &sa->sat_addr);
  826. if (!atif)
  827. return -ENOMEM;
  828. }
  829. atif->nets = *nr;
  831. /*
  832.  * Check if the chosen address is used. If so we
  833.  * error and atalkd will try another.
  834.  */
  836. if (!(dev->flags & IFF_LOOPBACK) &&
  837.     !(dev->flags & IFF_POINTOPOINT) &&
  838.     atif_probe_device(atif) < 0) {
  839. atif_drop_device(dev);
  840. return -EADDRINUSE;
  841. }
  843. /* Hey it worked - add the direct routes */
  844. sa = (struct sockaddr_at *) &rtdef.rt_gateway;
  845. sa->sat_family = AF_APPLETALK;
  846. sa->sat_addr.s_net  = atif->address.s_net;
  847. sa->sat_addr.s_node = atif->address.s_node;
  848. sa = (struct sockaddr_at *) &rtdef.rt_dst;
  849. rtdef.rt_flags = RTF_UP;
  850. sa->sat_family = AF_APPLETALK;
  851. sa->sat_addr.s_node = ATADDR_ANYNODE;
  852. if (dev->flags & IFF_LOOPBACK ||
  853.     dev->flags & IFF_POINTOPOINT)
  854. rtdef.rt_flags |= RTF_HOST;
  856. /* Routerless initial state */
  857. if (nr->nr_firstnet == htons(0) &&
  858.     nr->nr_lastnet == htons(0xFFFE)) {
  859. sa->sat_addr.s_net = atif->address.s_net;
  860. atrtr_create(&rtdef, dev);
  861. atrtr_set_default(dev);
  862. } else {
  863. limit = ntohs(nr->nr_lastnet);
  864. if (limit - ntohs(nr->nr_firstnet) > 4096) {
  865. printk(KERN_WARNING "Too many routes/"
  866.     "iface.n");
  867. return -EINVAL;
  868. }
  869. if (add_route)
  870. for (ct = ntohs(nr->nr_firstnet);
  871.      ct <= limit; ct++) {
  872. sa->sat_addr.s_net = htons(ct);
  873. atrtr_create(&rtdef, dev);
  874. }
  875. }
  876. dev_mc_add(dev, aarp_mcast, 6, 1);
  877. return 0;
  879. case SIOCGIFADDR:
  880. if (!atif)
  881. return -EADDRNOTAVAIL;
  883. sa->sat_family = AF_APPLETALK;
  884. sa->sat_addr = atif->address;
  885. break;
  887. case SIOCGIFBRDADDR:
  888. if (!atif)
  889. return -EADDRNOTAVAIL;
  891. sa->sat_family = AF_APPLETALK;
  892. sa->sat_addr.s_net = atif->address.s_net;
  893. sa->sat_addr.s_node = ATADDR_BCAST;
  894. break;
  896.         case SIOCATALKDIFADDR:
  897.         case SIOCDIFADDR:
  898. if (!capable(CAP_NET_ADMIN))
  899. return -EPERM;
  900. if (sa->sat_family != AF_APPLETALK)
  901. return -EINVAL;
  902. atalk_dev_down(dev);
  903. break;
  905. case SIOCSARP:
  906. if (!capable(CAP_NET_ADMIN))
  907.                                 return -EPERM;
  908.                         if (sa->sat_family != AF_APPLETALK)
  909.                                 return -EINVAL;
  910.                         if (!atif)
  911.                                 return -EADDRNOTAVAIL;
  913.                         /*
  914.                          * for now, we only support proxy AARP on ELAP;
  915.                          * we should be able to do it for LocalTalk, too.
  916.                          */
  917.                         if (dev->type != ARPHRD_ETHER)
  918.                                 return -EPROTONOSUPPORT;
  920.                         /*
  921.                          * atif points to the current interface on this network;
  922.                          * we aren't concerned about its current status (at
  923.  * least for now), but it has all the settings about
  924.  * the network we're going to probe. Consequently, it
  925.  * must exist.
  926.                          */
  927.                         if (!atif)
  928.                                 return -EADDRNOTAVAIL;
  930.                         nr = (struct netrange *) &(atif->nets);
  931.                         /*
  932.                          * Phase 1 is fine on Localtalk but we don't do
  933.                          * Ethertalk phase 1. Anyone wanting to add it go ahead.
  934.                          */
  935.                         if (dev->type == ARPHRD_ETHER && nr->nr_phase != 2)
  936.                                 return -EPROTONOSUPPORT;
  938.                         if (sa->sat_addr.s_node == ATADDR_BCAST ||
  939.     sa->sat_addr.s_node == 254)
  940.                                 return -EINVAL;
  942.                         /*
  943.                          * Check if the chosen address is used. If so we
  944.                          * error and ATCP will try another.
  945.                          */
  946.                        if (atif_proxy_probe_device(atif, &(sa->sat_addr)) < 0)
  947.                        return -EADDRINUSE;
  948.                       
  949. /*
  950.                          * We now have an address on the local network, and
  951.  * the AARP code will defend it for us until we take it
  952.  * down. We don't set up any routes right now, because
  953.  * ATCP will install them manually via SIOCADDRT.
  954.                          */
  955.                         break;
  957.                 case SIOCDARP:
  958.                         if (!capable(CAP_NET_ADMIN))
  959.                                 return -EPERM;
  960.                         if (sa->sat_family != AF_APPLETALK)
  961.                                 return -EINVAL;
  962.                         if (!atif)
  963.                                 return -EADDRNOTAVAIL;
  965.                         /* give to aarp module to remove proxy entry */
  966.                         aarp_proxy_remove(atif->dev, &(sa->sat_addr));
  967.                         return 0;
  968. }
  970. return copy_to_user(arg, &atreq, sizeof(atreq)) ? -EFAULT : 0;
  971. }
  973. /* Routing ioctl() calls */
  974. static int atrtr_ioctl(unsigned int cmd, void *arg)
  975. {
  976. struct net_device *dev = NULL;
  977. struct rtentry rt;
  979. if (copy_from_user(&rt, arg, sizeof(rt)))
  980. return -EFAULT;
  982. switch (cmd) {
  983. case SIOCDELRT:
  984. if (rt.rt_dst.sa_family != AF_APPLETALK)
  985. return -EINVAL;
  986. return atrtr_delete(&((struct sockaddr_at *)
  987. &rt.rt_dst)->sat_addr);
  989. case SIOCADDRT:
  990. /* FIXME: the name of the device is still in user
  991.  * space, isn't it? */
  992. if (rt.rt_dev) {
  993. dev = __dev_get_by_name(rt.rt_dev);
  994. if (!dev)
  995. return -ENODEV;
  996. }
  997. return atrtr_create(&rt, dev);
  998. }
  999. return -EINVAL;
  1000. }
  1002. /* Called from proc fs - just make it print the ifaces neatly */
  1003. static int atalk_if_get_info(char *buffer, char **start, off_t offset,
  1004.      int length)
  1005. {
  1006. off_t pos = 0;
  1007. off_t begin = 0;
  1008. struct atalk_iface *iface;
  1009. int len = sprintf(buffer, "Interface   Address   "
  1010.   "Networks   Statusn");
  1012. spin_lock_bh(&atalk_iface_lock);
  1013. for (iface = atalk_iface_list; iface; iface = iface->next) {
  1014. len += sprintf(buffer+len,"%-16s %04X:%02X  %04X-%04X  %dn",
  1015.        iface->dev->name, ntohs(iface->address.s_net),
  1016.        iface->address.s_node,
  1017.        ntohs(iface->nets.nr_firstnet),
  1018.        ntohs(iface->nets.nr_lastnet), iface->status);
  1019. pos = begin + len;
  1020. if (pos < offset) {
  1021. len   = 0;
  1022. begin = pos;
  1023. }
  1024. if (pos > offset + length)
  1025. break;
  1026. }
  1027. spin_unlock_bh(&atalk_iface_lock);
  1029. *start = buffer + (offset - begin);
  1030. len -= (offset - begin);
  1031. if (len > length)
  1032. len = length;
  1033. return len;
  1034. }
  1036. /* Called from proc fs - just make it print the routes neatly */
  1037. static int atalk_rt_get_info(char *buffer, char **start, off_t offset,
  1038.      int length)
  1039. {
  1040. off_t pos = 0;
  1041. off_t begin = 0;
  1042. int len = sprintf(buffer, "Target        Router  Flags Devn");
  1043. struct atalk_route *rt;
  1045. if (atrtr_default.dev) {
  1046. rt = &atrtr_default;
  1047. len += sprintf(buffer + len,"Default     %04X:%02X  %-4d  %sn",
  1048.        ntohs(rt->gateway.s_net), rt->gateway.s_node,
  1049.        rt->flags, rt->dev->name);
  1050. }
  1052. read_lock_bh(&atalk_router_lock);
  1053. for (rt = atalk_router_list; rt; rt = rt->next) {
  1054. len += sprintf(buffer + len,
  1055. "%04X:%02X     %04X:%02X  %-4d  %sn",
  1056.        ntohs(rt->target.s_net), rt->target.s_node,
  1057.        ntohs(rt->gateway.s_net), rt->gateway.s_node,
  1058.        rt->flags, rt->dev->name);
  1059. pos = begin + len;
  1060. if (pos < offset) {
  1061. len = 0;
  1062. begin = pos;
  1063. }
  1064. if (pos > offset + length)
  1065. break;
  1066. }
  1067. read_unlock_bh(&atalk_router_lock);
  1069. *start = buffer + (offset - begin);
  1070. len -= (offset - begin);
  1071. if (len > length)
  1072. len = length;
  1073. return len;
  1074. }
  1076. /**************************************************************************
  1077. *                                                                          *
  1078. * Handling for system calls applied via the various interfaces to an       *
  1079. * AppleTalk socket object.                                                 *
  1080. *                                                                          *
  1081. **************************************************************************/
  1083. /*
  1084.  * Checksum: This is 'optional'. It's quite likely also a good
  1085.  * candidate for assembler hackery 8)
  1086.  */
  1087. unsigned short atalk_checksum(struct ddpehdr *ddp, int len)
  1088. {
  1089. unsigned long sum = 0; /* Assume unsigned long is >16 bits */
  1090. unsigned char *data = (unsigned char *) ddp;
  1092. len  -= 4; /* skip header 4 bytes */
  1093. data += 4;
  1095. /* This ought to be unwrapped neatly. I'll trust gcc for now */
  1096. while (len--) {
  1097. sum += *data;
  1098. sum <<= 1;
  1099. if (sum & 0x10000) {
  1100. sum++;
  1101. sum &= 0xFFFF;
  1102. }
  1103. data++;
  1104. }
  1105. /* Use 0xFFFF for 0. 0 itself means none */
  1106. return sum ? htons((unsigned short) sum) : 0xFFFF;
  1107. }
  1109. /*
  1110.  * Create a socket. Initialise the socket, blank the addresses
  1111.  * set the state.
  1112.  */
  1113. static int atalk_create(struct socket *sock, int protocol)
  1114. {
  1115. struct sock *sk = sk_alloc(PF_APPLETALK, GFP_KERNEL, 1);
  1117. if (!sk)
  1118. return -ENOMEM;
  1120. switch (sock->type) {
  1121. /*
  1122.  * We permit SOCK_DGRAM and RAW is an extension. It is
  1123.  * trivial to do and gives you the full ELAP frame.
  1124.  * Should be handy for CAP 8) 
  1125.  */
  1126. case SOCK_RAW:
  1127. case SOCK_DGRAM:
  1128. sock->ops = &atalk_dgram_ops;
  1129. break;
  1131. case SOCK_STREAM:
  1132. /*
  1133.  * TODO: if you want to implement ADSP, here's the
  1134.  * place to start
  1135.  */
  1136. /*
  1137. sock->ops = &atalk_stream_ops;
  1138. break;
  1139. */
  1140. default:
  1141. sk_free(sk);
  1142. return -ESOCKTNOSUPPORT;
  1143. }
  1145. MOD_INC_USE_COUNT;
  1146. sock_init_data(sock, sk);
  1147. sk->destruct = NULL;
  1148. /* Checksums on by default */
  1149. sk->zapped = 1;
  1150. return 0;
  1151. }
  1153. /* Free a socket. No work needed */
  1154. static int atalk_release(struct socket *sock)
  1155. {
  1156. struct sock *sk = sock->sk;
  1158. if (!sk)
  1159. return 0;
  1161. if (!sk->dead)
  1162. sk->state_change(sk);
  1164. sk->dead = 1;
  1165. sock->sk = NULL;
  1166. atalk_destroy_socket(sk);
  1167. return 0;
  1168. }
  1170. /*
  1171.  * Pick a source port when one is not given. If we can
  1172.  * find a suitable free one, we insert the socket into
  1173.  * the tables using it.
  1174.  *
  1175.  * This whole operation must be atomic.
  1176.  */
  1177. static int atalk_pick_and_bind_port(struct sock *sk, struct sockaddr_at *sat)
  1178. {
  1179. struct sock *s;
  1180. int retval;
  1182. spin_lock_bh(&atalk_sockets_lock);
  1184. for (sat->sat_port = ATPORT_RESERVED;
  1185.      sat->sat_port < ATPORT_LAST;
  1186.      sat->sat_port++) {
  1187. for (s = atalk_sockets; s; s = s->next) {
  1188. if (s->protinfo.af_at.src_net == sat->sat_addr.s_net &&
  1189.     s->protinfo.af_at.src_node ==
  1190.      sat->sat_addr.s_node &&
  1191.     s->protinfo.af_at.src_port == sat->sat_port)
  1192. goto try_next_port;
  1193. }
  1195. /* Wheee, it's free, assign and insert. */
  1196. sk->next = atalk_sockets;
  1197. if (sk->next)
  1198. atalk_sockets->pprev = &sk->next;
  1199. atalk_sockets = sk;
  1200. sk->pprev = &atalk_sockets;
  1201. sk->protinfo.af_at.src_port = sat->sat_port;
  1202. retval = 0;
  1203. goto out;
  1205. try_next_port:
  1206. ;
  1207. }
  1209. retval = -EBUSY;
  1210. out: spin_unlock_bh(&atalk_sockets_lock);
  1211. return retval;
  1212. }
  1214. static int atalk_autobind(struct sock *sk)
  1215. {
  1216. struct sockaddr_at sat;
  1217. int n;
  1218. struct at_addr *ap = atalk_find_primary();
  1220. if (!ap || ap->s_net == htons(ATADDR_ANYNET))
  1221. return -EADDRNOTAVAIL;
  1223. sk->protinfo.af_at.src_net  = sat.sat_addr.s_net  = ap->s_net;
  1224. sk->protinfo.af_at.src_node = sat.sat_addr.s_node = ap->s_node;
  1226. n = atalk_pick_and_bind_port(sk, &sat);
  1227. if (n < 0)
  1228. return n;
  1230. sk->zapped = 0;
  1231. return 0;
  1232. }
  1234. /* Set the address 'our end' of the connection */
  1235. static int atalk_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
  1236. {
  1237. struct sockaddr_at *addr = (struct sockaddr_at *)uaddr;
  1238. struct sock *sk = sock->sk;
  1240. if (!sk->zapped || addr_len != sizeof(struct sockaddr_at))
  1241. return -EINVAL;
  1243. if (addr->sat_family != AF_APPLETALK)
  1244. return -EAFNOSUPPORT;
  1246. if (addr->sat_addr.s_net == htons(ATADDR_ANYNET)) {
  1247. struct at_addr *ap = atalk_find_primary();
  1249. if (!ap)
  1250. return -EADDRNOTAVAIL;
  1252. sk->protinfo.af_at.src_net  = addr->sat_addr.s_net = ap->s_net;
  1253. sk->protinfo.af_at.src_node = addr->sat_addr.s_node= ap->s_node;
  1254. } else {
  1255. if (!atalk_find_interface(addr->sat_addr.s_net,
  1256.   addr->sat_addr.s_node))
  1257. return -EADDRNOTAVAIL;
  1259. sk->protinfo.af_at.src_net  = addr->sat_addr.s_net;
  1260. sk->protinfo.af_at.src_node = addr->sat_addr.s_node;
  1261. }
  1263. if (addr->sat_port == ATADDR_ANYPORT) {
  1264. int n = atalk_pick_and_bind_port(sk, addr);
  1266. if (n < 0)
  1267. return n;
  1268. } else {
  1269. sk->protinfo.af_at.src_port = addr->sat_port;
  1271. if (atalk_find_or_insert_socket(sk, addr))
  1272. return -EADDRINUSE;
  1273. }
  1275. sk->zapped = 0;
  1276. return 0;
  1277. }
  1279. /* Set the address we talk to */
  1280. static int atalk_connect(struct socket *sock, struct sockaddr *uaddr,
  1281.  int addr_len, int flags)
  1282. {
  1283. struct sock *sk = sock->sk;
  1284. struct sockaddr_at *addr;
  1286. sk->state   = TCP_CLOSE;
  1287. sock->state = SS_UNCONNECTED;
  1289. if (addr_len != sizeof(*addr))
  1290. return -EINVAL;
  1292. addr = (struct sockaddr_at *)uaddr;
  1294. if (addr->sat_family != AF_APPLETALK)
  1295. return -EAFNOSUPPORT;
  1297. if (addr->sat_addr.s_node == ATADDR_BCAST && !sk->broadcast) {
  1298. #if 1
  1299. printk(KERN_WARNING "%s is broken and did not set "
  1300.     "SO_BROADCAST. It will break when 2.2 is "
  1301.     "released.n",
  1302. current->comm);
  1303. #else
  1304. return -EACCES;
  1305. #endif
  1306. }
  1308. if (sk->zapped)
  1309. if (atalk_autobind(sk) < 0)
  1310. return -EBUSY;
  1312. if (!atrtr_get_dev(&addr->sat_addr))
  1313. return -ENETUNREACH;
  1315. sk->protinfo.af_at.dest_port = addr->sat_port;
  1316. sk->protinfo.af_at.dest_net  = addr->sat_addr.s_net;
  1317. sk->protinfo.af_at.dest_node = addr->sat_addr.s_node;
  1319. sock->state = SS_CONNECTED;
  1320. sk->state   = TCP_ESTABLISHED;
  1321. return 0;
  1322. }
  1325. /*
  1326.  * Find the name of an AppleTalk socket. Just copy the right
  1327.  * fields into the sockaddr.
  1328.  */
  1329. static int atalk_getname(struct socket *sock, struct sockaddr *uaddr,
  1330.  int *uaddr_len, int peer)
  1331. {
  1332. struct sockaddr_at sat;
  1333. struct sock *sk = sock->sk;
  1335. if (sk->zapped)
  1336. if (atalk_autobind(sk) < 0)
  1337. return -ENOBUFS;
  1339. *uaddr_len = sizeof(struct sockaddr_at);
  1341. if (peer) {
  1342. if (sk->state != TCP_ESTABLISHED)
  1343. return -ENOTCONN;
  1345. sat.sat_addr.s_net  = sk->protinfo.af_at.dest_net;
  1346. sat.sat_addr.s_node = sk->protinfo.af_at.dest_node;
  1347. sat.sat_port = sk->protinfo.af_at.dest_port;
  1348. } else {
  1349. sat.sat_addr.s_net  = sk->protinfo.af_at.src_net;
  1350. sat.sat_addr.s_node = sk->protinfo.af_at.src_node;
  1351. sat.sat_port = sk->protinfo.af_at.src_port;
  1352. }
  1354. sat.sat_family = AF_APPLETALK;
  1355. memcpy(uaddr, &sat, sizeof(sat));
  1356. return 0;
  1357. }
  1359. /*
  1360.  * Receive a packet (in skb) from device dev. This has come from the SNAP
  1361.  * decoder, and on entry skb->h.raw is the DDP header, skb->len is the DDP
  1362.  * header, skb->len is the DDP length. The physical headers have been
  1363.  * extracted. PPP should probably pass frames marked as for this layer.
  1364.  * [ie ARPHRD_ETHERTALK]
  1365.  */
  1366. static int atalk_rcv(struct sk_buff *skb, struct net_device *dev,
  1367. struct packet_type *pt)
  1368. {
  1369. struct ddpehdr *ddp = (void *) skb->h.raw;
  1370. struct sock *sock;
  1371. struct atalk_iface *atif;
  1372. struct sockaddr_at tosat;
  1373.         int origlen;
  1374.         struct ddpebits ddphv;
  1376. /* Size check */
  1377. if (skb->len < sizeof(*ddp))
  1378. goto freeit;
  1380. /*
  1381.  * Fix up the length field [Ok this is horrible but otherwise
  1382.  * I end up with unions of bit fields and messy bit field order
  1383.  * compiler/endian dependencies..]
  1384.  *
  1385.  * FIXME: This is a write to a shared object. Granted it
  1386.  * happens to be safe BUT.. (Its safe as user space will not
  1387.  * run until we put it back)
  1388.  */
  1389. *((__u16 *)&ddphv) = ntohs(*((__u16 *)ddp));
  1391. /* Trim buffer in case of stray trailing data */
  1392. origlen = skb->len;
  1393. skb_trim(skb, min_t(unsigned int, skb->len, ddphv.deh_len));
  1395. /*
  1396.  * Size check to see if ddp->deh_len was crap
  1397.  * (Otherwise we'll detonate most spectacularly
  1398.  * in the middle of recvmsg()).
  1399.  */
  1400. if (skb->len < sizeof(*ddp))
  1401. goto freeit;
  1403. /*
  1404.  * Any checksums. Note we don't do htons() on this == is assumed to be
  1405.  * valid for net byte orders all over the networking code...
  1406.  */
  1407. if (ddp->deh_sum &&
  1408.     atalk_checksum(ddp, ddphv.deh_len) != ddp->deh_sum)
  1409. /* Not a valid AppleTalk frame - dustbin time */
  1410. goto freeit;
  1412. /* Check the packet is aimed at us */
  1413. if (!ddp->deh_dnet) /* Net 0 is 'this network' */
  1414. atif = atalk_find_anynet(ddp->deh_dnode, dev);
  1415. else
  1416. atif = atalk_find_interface(ddp->deh_dnet, ddp->deh_dnode);
  1418. /* Not ours, so we route the packet via the correct AppleTalk iface */
  1419. if (!atif) {
  1420. struct atalk_route *rt;
  1421. struct at_addr ta;
  1423. /*
  1424.  * Don't route multicast, etc., packets, or packets
  1425.  * sent to "this network" 
  1426.  */
  1427. if (skb->pkt_type != PACKET_HOST || !ddp->deh_dnet) {
  1428. /* FIXME:
  1429.  * Can it ever happen that a packet is from a PPP
  1430.  * iface and needs to be broadcast onto the default
  1431.  * network? */
  1432. if (dev->type == ARPHRD_PPP)
  1433. printk(KERN_DEBUG "AppleTalk: didn't forward "
  1434.   "broadcast packet received "
  1435.   "from PPP ifacen");
  1436. goto freeit;
  1437. }
  1439. ta.s_net  = ddp->deh_dnet;
  1440. ta.s_node = ddp->deh_dnode;
  1442. /* Route the packet */
  1443. rt = atrtr_find(&ta);
  1444. if (!rt || ddphv.deh_hops == DDP_MAXHOPS)
  1445. goto freeit;
  1446. ddphv.deh_hops++;
  1448. /*
  1449.  * Route goes through another gateway, so
  1450.  * set the target to the gateway instead.
  1451.  */
  1452. if (rt->flags & RTF_GATEWAY) {
  1453. ta.s_net  = rt->gateway.s_net;
  1454. ta.s_node = rt->gateway.s_node;
  1455. }
  1457.                 /* Fix up skb->len field */
  1458.                 skb_trim(skb, min_t(unsigned int, origlen, rt->dev->hard_header_len +
  1459. ddp_dl->header_length + ddphv.deh_len));
  1461. /* Mend the byte order */
  1462. *((__u16 *)ddp) = ntohs(*((__u16 *)&ddphv));
  1464. /*
  1465.  * Send the buffer onwards
  1466.  *
  1467.  * Now we must always be careful. If it's come from 
  1468.  * LocalTalk to EtherTalk it might not fit
  1469.  *
  1470.  * Order matters here: If a packet has to be copied
  1471.  * to make a new headroom (rare hopefully) then it
  1472.  * won't need unsharing.
  1473.  *
  1474.  * Note. ddp-> becomes invalid at the realloc.
  1475.  */
  1476. if (skb_headroom(skb) < 22) {
  1477. /* 22 bytes - 12 ether, 2 len, 3 802.2 5 snap */
  1478. struct sk_buff *nskb = skb_realloc_headroom(skb, 32);
  1479. kfree_skb(skb);
  1480. if (!nskb) 
  1481. goto out;
  1482. skb = nskb;
  1483. } else
  1484. skb = skb_unshare(skb, GFP_ATOMIC);
  1486. /*
  1487.  * If the buffer didn't vanish into the lack of
  1488.  * space bitbucket we can send it.
  1489.  */
  1490. if (skb && aarp_send_ddp(rt->dev, skb, &ta, NULL) == -1)
  1491. goto freeit;
  1492. goto out;
  1493. }
  1495. #if defined(CONFIG_IPDDP) || defined(CONFIG_IPDDP_MODULE)
  1496.         /* Check if IP-over-DDP */
  1497.         if (skb->data[12] == 22) {
  1498.                 struct net_device *dev = __dev_get_by_name("ipddp0");
  1499. struct net_device_stats *stats;
  1501. /* This needs to be able to handle ipddp"N" devices */
  1502.                 if (!dev)
  1503.                         return -ENODEV;
  1505.                 skb->protocol = htons(ETH_P_IP);
  1506.                 skb_pull(skb, 13);
  1507.                 skb->dev = dev;
  1508.                 skb->h.raw = skb->data;
  1510. stats = dev->priv;
  1511.                 stats->rx_packets++;
  1512.                 stats->rx_bytes += skb->len + 13;
  1513.                 netif_rx(skb);  /* Send the SKB up to a higher place. */
  1514. goto out;
  1515.         }
  1516. #endif
  1517. /*
  1518.  * Which socket - atalk_search_socket() looks for a *full match*
  1519.  * of the <net,node,port> tuple.
  1520.  */
  1521. tosat.sat_addr.s_net  = ddp->deh_dnet;
  1522. tosat.sat_addr.s_node = ddp->deh_dnode;
  1523. tosat.sat_port = ddp->deh_dport;
  1525. sock = atalk_search_socket(&tosat, atif);
  1526. if (!sock) /* But not one of our sockets */
  1527. goto freeit;
  1529. /* Queue packet (standard) */
  1530. skb->sk = sock;
  1532. if (sock_queue_rcv_skb(sock, skb) < 0)
  1533. goto freeit;
  1534. goto out;
  1535. freeit: kfree_skb(skb);
  1536. out: return 0;
  1537. }
  1539. /*
  1540.  * Receive a LocalTalk frame. We make some demands on the caller here.
  1541.  * Caller must provide enough headroom on the packet to pull the short
  1542.  * header and append a long one.
  1543.  */
  1544. static int ltalk_rcv(struct sk_buff *skb, struct net_device *dev,
  1545. struct packet_type *pt)
  1546. {
  1547. struct ddpehdr *ddp;
  1548. struct at_addr *ap;
  1550. /* Expand any short form frames */
  1551. if (skb->mac.raw[2] == 1) {
  1552. /* Find our address */
  1554. ap = atalk_find_dev_addr(dev);
  1555. if (!ap || skb->len < sizeof(struct ddpshdr)) {
  1556. kfree_skb(skb);
  1557. return 0;
  1558. }
  1560. /*
  1561.  * The push leaves us with a ddephdr not an shdr, and
  1562.  * handily the port bytes in the right place preset.
  1563.  */
  1565. skb_push(skb, sizeof(*ddp) - 4);
  1566. ddp = (struct ddpehdr *)skb->data;
  1568. /* Now fill in the long header */
  1570.   /*
  1571.    * These two first. The mac overlays the new source/dest
  1572.    * network information so we MUST copy these before
  1573.    * we write the network numbers !
  1574.    */
  1576. ddp->deh_dnode = skb->mac.raw[0];     /* From physical header */
  1577. ddp->deh_snode = skb->mac.raw[1];     /* From physical header */
  1579. ddp->deh_dnet  = ap->s_net; /* Network number */
  1580. ddp->deh_snet  = ap->s_net;
  1581. ddp->deh_sum   = 0; /* No checksum */
  1582. /*
  1583.  * Not sure about this bit...
  1584.  */
  1585. ddp->deh_len   = skb->len;
  1586. ddp->deh_hops  = DDP_MAXHOPS; /* Non routable, so force a drop
  1587.    if we slip up later */
  1588. /* Mend the byte order */
  1589. *((__u16 *)ddp) = htons(*((__u16 *)ddp));
  1590. }
  1591. skb->h.raw = skb->data;
  1593. return atalk_rcv(skb, dev, pt);
  1594. }
  1596. static int atalk_sendmsg(struct socket *sock, struct msghdr *msg, int len,
  1597. struct scm_cookie *scm)
  1598. {
  1599. struct sock *sk = sock->sk;
  1600. struct sockaddr_at *usat = (struct sockaddr_at *)msg->msg_name;
  1601. int flags = msg->msg_flags;
  1602. int loopback = 0;
  1603. struct sockaddr_at local_satalk, gsat;
  1604. struct sk_buff *skb;
  1605. struct net_device *dev;
  1606. struct ddpehdr *ddp;
  1607. int size;
  1608. struct atalk_route *rt;
  1609. int err;
  1611. if (flags & ~MSG_DONTWAIT)
  1612. return -EINVAL;
  1614. if (len > DDP_MAXSZ)
  1615. return -EMSGSIZE;
  1617. if (usat) {
  1618. if (sk->zapped)
  1619. if (atalk_autobind(sk) < 0)
  1620. return -EBUSY;
  1622. if (msg->msg_namelen < sizeof(*usat) ||
  1623.     usat->sat_family != AF_APPLETALK)
  1624. return -EINVAL;
  1626. /* netatalk doesn't implement this check */
  1627. if (usat->sat_addr.s_node == ATADDR_BCAST && !sk->broadcast) {
  1628. printk(KERN_INFO "SO_BROADCAST: Fix your netatalk as "
  1629.  "it will break before 2.2n");
  1630. #if 0
  1631. return -EPERM;
  1632. #endif
  1633. }
  1634. } else {
  1635. if (sk->state != TCP_ESTABLISHED)
  1636. return -ENOTCONN;
  1637. usat = &local_satalk;
  1638. usat->sat_family = AF_APPLETALK;
  1639. usat->sat_port   = sk->protinfo.af_at.dest_port;
  1640. usat->sat_addr.s_node = sk->protinfo.af_at.dest_node;
  1641. usat->sat_addr.s_net  = sk->protinfo.af_at.dest_net;
  1642. }
  1644. /* Build a packet */
  1645. SOCK_DEBUG(sk, "SK %p: Got address.n", sk);
  1647. /* For headers */
  1648. size = sizeof(struct ddpehdr) + len + ddp_dl->header_length;
  1650. if (usat->sat_addr.s_net || usat->sat_addr.s_node == ATADDR_ANYNODE) {
  1651. rt = atrtr_find(&usat->sat_addr);
  1652. if (!rt)
  1653. return -ENETUNREACH;
  1655. dev = rt->dev;
  1656. } else {
  1657. struct at_addr at_hint;
  1659. at_hint.s_node = 0;
  1660. at_hint.s_net  = sk->protinfo.af_at.src_net;
  1662. rt = atrtr_find(&at_hint);
  1663. if (!rt)
  1664. return -ENETUNREACH;
  1666. dev = rt->dev;
  1667. }
  1669. SOCK_DEBUG(sk, "SK %p: Size needed %d, device %sn",
  1670. sk, size, dev->name);
  1672. size += dev->hard_header_len;
  1673. skb = sock_alloc_send_skb(sk, size, (flags & MSG_DONTWAIT), &err);
  1674. if (!skb)
  1675. return err;
  1677. skb->sk = sk;
  1678. skb_reserve(skb, ddp_dl->header_length);
  1679. skb_reserve(skb, dev->hard_header_len);
  1680. skb->dev = dev;
  1682. SOCK_DEBUG(sk, "SK %p: Begin build.n", sk);
  1684. ddp = (struct ddpehdr *)skb_put(skb, sizeof(struct ddpehdr));
  1685. ddp->deh_pad  = 0;
  1686. ddp->deh_hops = 0;
  1687. ddp->deh_len  = len + sizeof(*ddp);
  1688. /*
  1689.  * Fix up the length field [Ok this is horrible but otherwise
  1690.  * I end up with unions of bit fields and messy bit field order
  1691.  * compiler/endian dependencies..
  1692.  */
  1693. *((__u16 *)ddp) = ntohs(*((__u16 *)ddp));
  1695. ddp->deh_dnet  = usat->sat_addr.s_net;
  1696. ddp->deh_snet  = sk->protinfo.af_at.src_net;
  1697. ddp->deh_dnode = usat->sat_addr.s_node;
  1698. ddp->deh_snode = sk->protinfo.af_at.src_node;
  1699. ddp->deh_dport = usat->sat_port;
  1700. ddp->deh_sport = sk->protinfo.af_at.src_port;
  1702. SOCK_DEBUG(sk, "SK %p: Copy user data (%d bytes).n", sk, len);
  1704. err = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
  1705. if (err) {
  1706. kfree_skb(skb);
  1707. return -EFAULT;
  1708. }
  1710. if (sk->no_check == 1)
  1711. ddp->deh_sum = 0;
  1712. else
  1713. ddp->deh_sum = atalk_checksum(ddp, len + sizeof(*ddp));
  1715. /*
  1716.  * Loopback broadcast packets to non gateway targets (ie routes
  1717.  * to group we are in)
  1718.  */
  1719. if (ddp->deh_dnode == ATADDR_BCAST &&
  1720.     !(rt->flags & RTF_GATEWAY) && !(dev->flags & IFF_LOOPBACK)) {
  1721. struct sk_buff *skb2 = skb_copy(skb, GFP_KERNEL);
  1723. if (skb2) {
  1724. loopback = 1;
  1725. SOCK_DEBUG(sk, "SK %p: send out(copy).n", sk);
  1726. if (aarp_send_ddp(dev, skb2,
  1727.   &usat->sat_addr, NULL) == -1)
  1728. kfree_skb(skb2);
  1729. /* else queued/sent above in the aarp queue */
  1730. }
  1731. }
  1733. if (dev->flags & IFF_LOOPBACK || loopback) {
  1734. SOCK_DEBUG(sk, "SK %p: Loop back.n", sk);
  1735. /* loop back */
  1736. skb_orphan(skb);
  1737. ddp_dl->datalink_header(ddp_dl, skb, dev->dev_addr);
  1738. skb->mac.raw = skb->data;
  1739. skb->h.raw   = skb->data + ddp_dl->header_length +
  1740. dev->hard_header_len;
  1741. skb_pull(skb, dev->hard_header_len);
  1742. skb_pull(skb, ddp_dl->header_length);
  1743. atalk_rcv(skb, dev, NULL);
  1744. } else {
  1745. SOCK_DEBUG(sk, "SK %p: send out.n", sk);
  1746. if (rt->flags & RTF_GATEWAY) {
  1747.     gsat.sat_addr = rt->gateway;
  1748.     usat = &gsat;
  1749. }
  1751. if (aarp_send_ddp(dev, skb, &usat->sat_addr, NULL) == -1)
  1752. kfree_skb(skb);
  1753. /* else queued/sent above in the aarp queue */
  1754. }
  1755. SOCK_DEBUG(sk, "SK %p: Done write (%d).n", sk, len);
  1757. return len;
  1758. }
  1760. static int atalk_recvmsg(struct socket *sock, struct msghdr *msg, int size,
  1761.  int flags, struct scm_cookie *scm)
  1762. {
  1763. struct sock *sk = sock->sk;
  1764. struct sockaddr_at *sat = (struct sockaddr_at *)msg->msg_name;
  1765. struct ddpehdr *ddp = NULL;
  1766. int copied = 0;
  1767. int err = 0;
  1768.         struct ddpebits ddphv;
  1769. struct sk_buff *skb;
  1771. skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
  1772. flags & MSG_DONTWAIT, &err);
  1773. if (!skb)
  1774. return err;
  1776. ddp = (struct ddpehdr *)(skb->h.raw);
  1777. *((__u16 *)&ddphv) = ntohs(*((__u16 *)ddp));
  1779. if (sk->type == SOCK_RAW) {
  1780. copied = ddphv.deh_len;
  1781. if (copied > size) {
  1782. copied = size;
  1783. msg->msg_flags |= MSG_TRUNC;
  1784. }
  1786. err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
  1787. } else {
  1788. copied = ddphv.deh_len - sizeof(*ddp);
  1789. if (copied > size) {
  1790. copied = size;
  1791. msg->msg_flags |= MSG_TRUNC;
  1792. }
  1793. err = skb_copy_datagram_iovec(skb, sizeof(*ddp),
  1794. msg->msg_iov, copied);
  1795. }
  1797. if (!err) {
  1798. if (sat) {
  1799. sat->sat_family      = AF_APPLETALK;
  1800. sat->sat_port        = ddp->deh_sport;
  1801. sat->sat_addr.s_node = ddp->deh_snode;
  1802. sat->sat_addr.s_net  = ddp->deh_snet;
  1803. }
  1804. msg->msg_namelen = sizeof(*sat);
  1805. }
  1807. skb_free_datagram(sk, skb); /* Free the datagram. */
  1808. return err ? err : copied;
  1809. }
  1812. /*
  1813.  * AppleTalk ioctl calls.
  1814.  */
  1815. static int atalk_ioctl(struct socket *sock,unsigned int cmd, unsigned long arg)
  1816. {
  1817. long amount = 0;
  1818. struct sock *sk = sock->sk;
  1820. switch (cmd) {
  1821. /* Protocol layer */
  1822. case TIOCOUTQ:
  1823. amount = sk->sndbuf - atomic_read(&sk->wmem_alloc);
  1824. if (amount < 0)
  1825. amount = 0;
  1826. break;
  1827. case TIOCINQ:
  1828. {
  1829. /* These two are safe on a single CPU system as only
  1830.  * user tasks fiddle here */
  1831. struct sk_buff *skb = skb_peek(&sk->receive_queue);
  1833. if (skb)
  1834. amount = skb->len-sizeof(struct ddpehdr);
  1835. break;
  1836. }
  1837. case SIOCGSTAMP:
  1838. if (!sk)
  1839. return -EINVAL;
  1840. if (!sk->stamp.tv_sec)
  1841. return -ENOENT;
  1842. return copy_to_user((void *)arg, &sk->stamp,
  1843. sizeof(struct timeval)) ? -EFAULT : 0;
  1844. /* Routing */
  1845. case SIOCADDRT:
  1846. case SIOCDELRT:
  1847. if (!capable(CAP_NET_ADMIN))
  1848. return -EPERM;
  1849. return atrtr_ioctl(cmd, (void *)arg);
  1850. /* Interface */
  1851. case SIOCGIFADDR:
  1852. case SIOCSIFADDR:
  1853. case SIOCGIFBRDADDR:
  1854. case SIOCATALKDIFADDR:
  1855. case SIOCDIFADDR:
  1856. case SIOCSARP: /* proxy AARP */
  1857. case SIOCDARP: /* proxy AARP */
  1858. {
  1859. int ret;
  1861. rtnl_lock();
  1862. ret = atif_ioctl(cmd, (void *)arg);
  1863. rtnl_unlock();
  1865. return ret;
  1866. }
  1867. /* Physical layer ioctl calls */
  1868. case SIOCSIFLINK:
  1869. case SIOCGIFHWADDR:
  1870. case SIOCSIFHWADDR:
  1871. case SIOCGIFFLAGS:
  1872. case SIOCSIFFLAGS:
  1873. case SIOCGIFMTU:
  1874. case SIOCGIFCONF:
  1875. case SIOCADDMULTI:
  1876. case SIOCDELMULTI:
  1877. case SIOCGIFCOUNT:
  1878. case SIOCGIFINDEX:
  1879. case SIOCGIFNAME:
  1880. return dev_ioctl(cmd,(void *) arg);
  1881. case SIOCSIFMETRIC:
  1882. case SIOCSIFBRDADDR:
  1883. case SIOCGIFNETMASK:
  1884. case SIOCSIFNETMASK:
  1885. case SIOCGIFMEM:
  1886. case SIOCSIFMEM:
  1887. case SIOCGIFDSTADDR:
  1888. case SIOCSIFDSTADDR:
  1889. return -EINVAL;
  1890. default:
  1891. return -EINVAL;
  1892. }
  1894. return put_user(amount, (int *)arg);
  1895. }
  1897. static struct net_proto_family atalk_family_ops =
  1898. {
  1899. PF_APPLETALK,
  1900. atalk_create
  1901. };
  1903. static struct proto_ops SOCKOPS_WRAPPED(atalk_dgram_ops)=
  1904. {
  1905. family: PF_APPLETALK,
  1907. release: atalk_release,
  1908. bind: atalk_bind,
  1909. connect: atalk_connect,
  1910. socketpair: sock_no_socketpair,
  1911. accept: sock_no_accept,
  1912. getname: atalk_getname,
  1913. poll: datagram_poll,
  1914. ioctl: atalk_ioctl,
  1915. listen: sock_no_listen,
  1916. shutdown: sock_no_shutdown,
  1917. setsockopt: sock_no_setsockopt,
  1918. getsockopt: sock_no_getsockopt,
  1919. sendmsg: atalk_sendmsg,
  1920. recvmsg: atalk_recvmsg,
  1921. mmap: sock_no_mmap,
  1922. sendpage: sock_no_sendpage,
  1923. };
  1925. #include <linux/smp_lock.h>
  1926. SOCKOPS_WRAP(atalk_dgram, PF_APPLETALK);
  1928. static struct notifier_block ddp_notifier=
  1929. {
  1930. ddp_device_event,
  1931. NULL,
  1932. 0
  1933. };
  1935. struct packet_type ltalk_packet_type=
  1936. {
  1937. 0,
  1938. NULL,
  1939. ltalk_rcv,
  1940. NULL,
  1941. NULL
  1942. };
  1944. struct packet_type ppptalk_packet_type=
  1945. {
  1946. 0,
  1947. NULL,
  1948. atalk_rcv,
  1949. NULL,
  1950. NULL
  1951. };
  1953. static char ddp_snap_id[] = {0x08, 0x00, 0x07, 0x80, 0x9B};
  1955. /* Export symbols for use by drivers when AppleTalk is a module */
  1956. EXPORT_SYMBOL(aarp_send_ddp);
  1957. EXPORT_SYMBOL(atrtr_get_dev);
  1958. EXPORT_SYMBOL(atalk_find_dev_addr);
  1960. /* Called by proto.c on kernel start up */
  1961. static int __init atalk_init(void)
  1962. {
  1963. (void) sock_register(&atalk_family_ops);
  1964. ddp_dl = register_snap_client(ddp_snap_id, atalk_rcv);
  1965. if (!ddp_dl)
  1966. printk(KERN_CRIT "Unable to register DDP with SNAP.n");
  1968. ltalk_packet_type.type = htons(ETH_P_LOCALTALK);
  1969. dev_add_pack(&ltalk_packet_type);
  1971. ppptalk_packet_type.type = htons(ETH_P_PPPTALK);
  1972. dev_add_pack(&ppptalk_packet_type);
  1974. register_netdevice_notifier(&ddp_notifier);
  1975. aarp_proto_init();
  1977. proc_net_create("appletalk", 0, atalk_get_info);
  1978. proc_net_create("atalk_route", 0, atalk_rt_get_info);
  1979. proc_net_create("atalk_iface", 0, atalk_if_get_info);
  1980. #ifdef CONFIG_PROC_FS
  1981. aarp_register_proc_fs();
  1982. #endif /* CONFIG_PROC_FS */
  1983. #ifdef CONFIG_SYSCTL
  1984. atalk_register_sysctl();
  1985. #endif /* CONFIG_SYSCTL */
  1986. printk(KERN_INFO "NET4: AppleTalk 0.18a for Linux NET4.0n");
  1987. return 0;
  1988. }
  1989. module_init(atalk_init);
  1991. #ifdef MODULE
  1992. /*
  1993.  * Note on MOD_{INC,DEC}_USE_COUNT:
  1994.  *
  1995.  * Use counts are incremented/decremented when
  1996.  * sockets are created/deleted.
  1997.  *
  1998.  * AppleTalk interfaces are not incremented until atalkd is run
  1999.  * and are only decremented when they are downed.
  2000.  *
  2001.  * Ergo, before the AppleTalk module can be removed, all AppleTalk
  2002.  * sockets be closed from user space.
  2003.  */
  2004. static void __exit atalk_exit(void)
  2005. {
  2006. #ifdef CONFIG_SYSCTL
  2007. atalk_unregister_sysctl();
  2008. #endif /* CONFIG_SYSCTL */
  2009. proc_net_remove("appletalk");
  2010. proc_net_remove("atalk_route");
  2011. proc_net_remove("atalk_iface");
  2012. #ifdef CONFIG_PROC_FS
  2013. aarp_unregister_proc_fs();
  2014. #endif /* CONFIG_PROC_FS */
  2015. aarp_cleanup_module(); /* General aarp clean-up. */
  2016. unregister_netdevice_notifier(&ddp_notifier);
  2017. dev_remove_pack(&ltalk_packet_type);
  2018. dev_remove_pack(&ppptalk_packet_type);
  2019. unregister_snap_client(ddp_snap_id);
  2020. sock_unregister(PF_APPLETALK);
  2021. }
  2022. module_exit(atalk_exit);
  2023. #endif  /* MODULE */
  2024. #endif  /* CONFIG_ATALK || CONFIG_ATALK_MODULE */