af_econet.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173
  1. /*
  2. * An implementation of the Acorn Econet and AUN protocols.
  3. * Philip Blundell <philb@gnu.org>
  4. *
  5. * This program is free software; you can redistribute it and/or
  6. * modify it under the terms of the GNU General Public License
  7. * as published by the Free Software Foundation; either version
  8. * 2 of the License, or (at your option) any later version.
  9. *
  10. */
  11. #include <linux/module.h>
  12. #include <linux/types.h>
  13. #include <linux/kernel.h>
  14. #include <linux/string.h>
  15. #include <linux/mm.h>
  16. #include <linux/socket.h>
  17. #include <linux/sockios.h>
  18. #include <linux/in.h>
  19. #include <linux/errno.h>
  20. #include <linux/interrupt.h>
  21. #include <linux/if_ether.h>
  22. #include <linux/netdevice.h>
  23. #include <linux/inetdevice.h>
  24. #include <linux/route.h>
  25. #include <linux/inet.h>
  26. #include <linux/etherdevice.h>
  27. #include <linux/if_arp.h>
  28. #include <linux/wireless.h>
  29. #include <linux/skbuff.h>
  30. #include <linux/udp.h>
  31. #include <net/sock.h>
  32. #include <net/inet_common.h>
  33. #include <linux/stat.h>
  34. #include <linux/init.h>
  35. #include <linux/if_ec.h>
  36. #include <net/udp.h>
  37. #include <net/ip.h>
  38. #include <linux/spinlock.h>
  39. #include <linux/rcupdate.h>
  40. #include <linux/bitops.h>
  41. #include <linux/mutex.h>
  42. #include <asm/uaccess.h>
  43. #include <asm/system.h>
  44. static const struct proto_ops econet_ops;
  45. static struct hlist_head econet_sklist;
  46. static DEFINE_RWLOCK(econet_lock);
  47. static DEFINE_MUTEX(econet_mutex);
  48. /* Since there are only 256 possible network numbers (or fewer, depends
  49. how you count) it makes sense to use a simple lookup table. */
  50. static struct net_device *net2dev_map[256];
  51. #define EC_PORT_IP 0xd2
  52. #ifdef CONFIG_ECONET_AUNUDP
  53. static DEFINE_SPINLOCK(aun_queue_lock);
  54. static struct socket *udpsock;
  55. #define AUN_PORT 0x8000
  56. struct aunhdr
  57. {
  58. unsigned char code; /* AUN magic protocol byte */
  59. unsigned char port;
  60. unsigned char cb;
  61. unsigned char pad;
  62. unsigned long handle;
  63. };
  64. static unsigned long aun_seq;
  65. /* Queue of packets waiting to be transmitted. */
  66. static struct sk_buff_head aun_queue;
  67. static struct timer_list ab_cleanup_timer;
  68. #endif /* CONFIG_ECONET_AUNUDP */
  69. /* Per-packet information */
  70. struct ec_cb
  71. {
  72. struct sockaddr_ec sec;
  73. unsigned long cookie; /* Supplied by user. */
  74. #ifdef CONFIG_ECONET_AUNUDP
  75. int done;
  76. unsigned long seq; /* Sequencing */
  77. unsigned long timeout; /* Timeout */
  78. unsigned long start; /* jiffies */
  79. #endif
  80. #ifdef CONFIG_ECONET_NATIVE
  81. void (*sent)(struct sk_buff *, int result);
  82. #endif
  83. };
  84. static void econet_remove_socket(struct hlist_head *list, struct sock *sk)
  85. {
  86. write_lock_bh(&econet_lock);
  87. sk_del_node_init(sk);
  88. write_unlock_bh(&econet_lock);
  89. }
  90. static void econet_insert_socket(struct hlist_head *list, struct sock *sk)
  91. {
  92. write_lock_bh(&econet_lock);
  93. sk_add_node(sk, list);
  94. write_unlock_bh(&econet_lock);
  95. }
  96. /*
  97. * Pull a packet from our receive queue and hand it to the user.
  98. * If necessary we block.
  99. */
  100. static int econet_recvmsg(struct kiocb *iocb, struct socket *sock,
  101. struct msghdr *msg, size_t len, int flags)
  102. {
  103. struct sock *sk = sock->sk;
  104. struct sk_buff *skb;
  105. size_t copied;
  106. int err;
  107. msg->msg_namelen = sizeof(struct sockaddr_ec);
  108. mutex_lock(&econet_mutex);
  109. /*
  110. * Call the generic datagram receiver. This handles all sorts
  111. * of horrible races and re-entrancy so we can forget about it
  112. * in the protocol layers.
  113. *
  114. * Now it will return ENETDOWN, if device have just gone down,
  115. * but then it will block.
  116. */
  117. skb=skb_recv_datagram(sk,flags,flags&MSG_DONTWAIT,&err);
  118. /*
  119. * An error occurred so return it. Because skb_recv_datagram()
  120. * handles the blocking we don't see and worry about blocking
  121. * retries.
  122. */
  123. if(skb==NULL)
  124. goto out;
  125. /*
  126. * You lose any data beyond the buffer you gave. If it worries a
  127. * user program they can ask the device for its MTU anyway.
  128. */
  129. copied = skb->len;
  130. if (copied > len)
  131. {
  132. copied=len;
  133. msg->msg_flags|=MSG_TRUNC;
  134. }
  135. /* We can't use skb_copy_datagram here */
  136. err = memcpy_toiovec(msg->msg_iov, skb->data, copied);
  137. if (err)
  138. goto out_free;
  139. skb_get_timestamp(skb, &sk->sk_stamp);
  140. if (msg->msg_name)
  141. memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
  142. /*
  143. * Free or return the buffer as appropriate. Again this
  144. * hides all the races and re-entrancy issues from us.
  145. */
  146. err = copied;
  147. out_free:
  148. skb_free_datagram(sk, skb);
  149. out:
  150. mutex_unlock(&econet_mutex);
  151. return err;
  152. }
  153. /*
  154. * Bind an Econet socket.
  155. */
  156. static int econet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
  157. {
  158. struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
  159. struct sock *sk;
  160. struct econet_sock *eo;
  161. /*
  162. * Check legality
  163. */
  164. if (addr_len < sizeof(struct sockaddr_ec) ||
  165. sec->sec_family != AF_ECONET)
  166. return -EINVAL;
  167. mutex_lock(&econet_mutex);
  168. sk = sock->sk;
  169. eo = ec_sk(sk);
  170. eo->cb = sec->cb;
  171. eo->port = sec->port;
  172. eo->station = sec->addr.station;
  173. eo->net = sec->addr.net;
  174. mutex_unlock(&econet_mutex);
  175. return 0;
  176. }
  177. #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
  178. /*
  179. * Queue a transmit result for the user to be told about.
  180. */
  181. static void tx_result(struct sock *sk, unsigned long cookie, int result)
  182. {
  183. struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
  184. struct ec_cb *eb;
  185. struct sockaddr_ec *sec;
  186. if (skb == NULL)
  187. {
  188. printk(KERN_DEBUG "ec: memory squeeze, transmit result dropped.\n");
  189. return;
  190. }
  191. eb = (struct ec_cb *)&skb->cb;
  192. sec = (struct sockaddr_ec *)&eb->sec;
  193. memset(sec, 0, sizeof(struct sockaddr_ec));
  194. sec->cookie = cookie;
  195. sec->type = ECTYPE_TRANSMIT_STATUS | result;
  196. sec->sec_family = AF_ECONET;
  197. if (sock_queue_rcv_skb(sk, skb) < 0)
  198. kfree_skb(skb);
  199. }
  200. #endif
  201. #ifdef CONFIG_ECONET_NATIVE
  202. /*
  203. * Called by the Econet hardware driver when a packet transmit
  204. * has completed. Tell the user.
  205. */
  206. static void ec_tx_done(struct sk_buff *skb, int result)
  207. {
  208. struct ec_cb *eb = (struct ec_cb *)&skb->cb;
  209. tx_result(skb->sk, eb->cookie, result);
  210. }
  211. #endif
  212. /*
  213. * Send a packet. We have to work out which device it's going out on
  214. * and hence whether to use real Econet or the UDP emulation.
  215. */
  216. static int econet_sendmsg(struct kiocb *iocb, struct socket *sock,
  217. struct msghdr *msg, size_t len)
  218. {
  219. struct sock *sk = sock->sk;
  220. struct sockaddr_ec *saddr=(struct sockaddr_ec *)msg->msg_name;
  221. struct net_device *dev;
  222. struct ec_addr addr;
  223. int err;
  224. unsigned char port, cb;
  225. #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
  226. struct sk_buff *skb;
  227. struct ec_cb *eb;
  228. #endif
  229. #ifdef CONFIG_ECONET_AUNUDP
  230. struct msghdr udpmsg;
  231. struct iovec iov[msg->msg_iovlen+1];
  232. struct aunhdr ah;
  233. struct sockaddr_in udpdest;
  234. __kernel_size_t size;
  235. int i;
  236. mm_segment_t oldfs;
  237. #endif
  238. /*
  239. * Check the flags.
  240. */
  241. if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
  242. return -EINVAL;
  243. /*
  244. * Get and verify the address.
  245. */
  246. mutex_lock(&econet_mutex);
  247. if (saddr == NULL) {
  248. struct econet_sock *eo = ec_sk(sk);
  249. addr.station = eo->station;
  250. addr.net = eo->net;
  251. port = eo->port;
  252. cb = eo->cb;
  253. } else {
  254. if (msg->msg_namelen < sizeof(struct sockaddr_ec)) {
  255. mutex_unlock(&econet_mutex);
  256. return -EINVAL;
  257. }
  258. addr.station = saddr->addr.station;
  259. addr.net = saddr->addr.net;
  260. port = saddr->port;
  261. cb = saddr->cb;
  262. }
  263. /* Look for a device with the right network number. */
  264. dev = net2dev_map[addr.net];
  265. /* If not directly reachable, use some default */
  266. if (dev == NULL) {
  267. dev = net2dev_map[0];
  268. /* No interfaces at all? */
  269. if (dev == NULL) {
  270. mutex_unlock(&econet_mutex);
  271. return -ENETDOWN;
  272. }
  273. }
  274. if (len + 15 > dev->mtu) {
  275. mutex_unlock(&econet_mutex);
  276. return -EMSGSIZE;
  277. }
  278. if (dev->type == ARPHRD_ECONET) {
  279. /* Real hardware Econet. We're not worthy etc. */
  280. #ifdef CONFIG_ECONET_NATIVE
  281. unsigned short proto = 0;
  282. dev_hold(dev);
  283. skb = sock_alloc_send_skb(sk, len+LL_RESERVED_SPACE(dev),
  284. msg->msg_flags & MSG_DONTWAIT, &err);
  285. if (skb==NULL)
  286. goto out_unlock;
  287. skb_reserve(skb, LL_RESERVED_SPACE(dev));
  288. skb->nh.raw = skb->data;
  289. eb = (struct ec_cb *)&skb->cb;
  290. /* BUG: saddr may be NULL */
  291. eb->cookie = saddr->cookie;
  292. eb->sec = *saddr;
  293. eb->sent = ec_tx_done;
  294. if (dev->hard_header) {
  295. int res;
  296. struct ec_framehdr *fh;
  297. err = -EINVAL;
  298. res = dev->hard_header(skb, dev, ntohs(proto),
  299. &addr, NULL, len);
  300. /* Poke in our control byte and
  301. port number. Hack, hack. */
  302. fh = (struct ec_framehdr *)(skb->data);
  303. fh->cb = cb;
  304. fh->port = port;
  305. if (sock->type != SOCK_DGRAM) {
  306. skb->tail = skb->data;
  307. skb->len = 0;
  308. } else if (res < 0)
  309. goto out_free;
  310. }
  311. /* Copy the data. Returns -EFAULT on error */
  312. err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
  313. skb->protocol = proto;
  314. skb->dev = dev;
  315. skb->priority = sk->sk_priority;
  316. if (err)
  317. goto out_free;
  318. err = -ENETDOWN;
  319. if (!(dev->flags & IFF_UP))
  320. goto out_free;
  321. /*
  322. * Now send it
  323. */
  324. dev_queue_xmit(skb);
  325. dev_put(dev);
  326. mutex_unlock(&econet_mutex);
  327. return(len);
  328. out_free:
  329. kfree_skb(skb);
  330. out_unlock:
  331. if (dev)
  332. dev_put(dev);
  333. #else
  334. err = -EPROTOTYPE;
  335. #endif
  336. mutex_unlock(&econet_mutex);
  337. return err;
  338. }
  339. #ifdef CONFIG_ECONET_AUNUDP
  340. /* AUN virtual Econet. */
  341. if (udpsock == NULL) {
  342. mutex_unlock(&econet_mutex);
  343. return -ENETDOWN; /* No socket - can't send */
  344. }
  345. /* Make up a UDP datagram and hand it off to some higher intellect. */
  346. memset(&udpdest, 0, sizeof(udpdest));
  347. udpdest.sin_family = AF_INET;
  348. udpdest.sin_port = htons(AUN_PORT);
  349. /* At the moment we use the stupid Acorn scheme of Econet address
  350. y.x maps to IP a.b.c.x. This should be replaced with something
  351. more flexible and more aware of subnet masks. */
  352. {
  353. struct in_device *idev;
  354. unsigned long network = 0;
  355. rcu_read_lock();
  356. idev = __in_dev_get_rcu(dev);
  357. if (idev) {
  358. if (idev->ifa_list)
  359. network = ntohl(idev->ifa_list->ifa_address) &
  360. 0xffffff00; /* !!! */
  361. }
  362. rcu_read_unlock();
  363. udpdest.sin_addr.s_addr = htonl(network | addr.station);
  364. }
  365. ah.port = port;
  366. ah.cb = cb & 0x7f;
  367. ah.code = 2; /* magic */
  368. ah.pad = 0;
  369. /* tack our header on the front of the iovec */
  370. size = sizeof(struct aunhdr);
  371. /*
  372. * XXX: that is b0rken. We can't mix userland and kernel pointers
  373. * in iovec, since on a lot of platforms copy_from_user() will
  374. * *not* work with the kernel and userland ones at the same time,
  375. * regardless of what we do with set_fs(). And we are talking about
  376. * econet-over-ethernet here, so "it's only ARM anyway" doesn't
  377. * apply. Any suggestions on fixing that code? -- AV
  378. */
  379. iov[0].iov_base = (void *)&ah;
  380. iov[0].iov_len = size;
  381. for (i = 0; i < msg->msg_iovlen; i++) {
  382. void __user *base = msg->msg_iov[i].iov_base;
  383. size_t len = msg->msg_iov[i].iov_len;
  384. /* Check it now since we switch to KERNEL_DS later. */
  385. if (!access_ok(VERIFY_READ, base, len)) {
  386. mutex_unlock(&econet_mutex);
  387. return -EFAULT;
  388. }
  389. iov[i+1].iov_base = base;
  390. iov[i+1].iov_len = len;
  391. size += len;
  392. }
  393. /* Get a skbuff (no data, just holds our cb information) */
  394. if ((skb = sock_alloc_send_skb(sk, 0,
  395. msg->msg_flags & MSG_DONTWAIT,
  396. &err)) == NULL) {
  397. mutex_unlock(&econet_mutex);
  398. return err;
  399. }
  400. eb = (struct ec_cb *)&skb->cb;
  401. eb->cookie = saddr->cookie;
  402. eb->timeout = (5*HZ);
  403. eb->start = jiffies;
  404. ah.handle = aun_seq;
  405. eb->seq = (aun_seq++);
  406. eb->sec = *saddr;
  407. skb_queue_tail(&aun_queue, skb);
  408. udpmsg.msg_name = (void *)&udpdest;
  409. udpmsg.msg_namelen = sizeof(udpdest);
  410. udpmsg.msg_iov = &iov[0];
  411. udpmsg.msg_iovlen = msg->msg_iovlen + 1;
  412. udpmsg.msg_control = NULL;
  413. udpmsg.msg_controllen = 0;
  414. udpmsg.msg_flags=0;
  415. oldfs = get_fs(); set_fs(KERNEL_DS); /* More privs :-) */
  416. err = sock_sendmsg(udpsock, &udpmsg, size);
  417. set_fs(oldfs);
  418. #else
  419. err = -EPROTOTYPE;
  420. #endif
  421. mutex_unlock(&econet_mutex);
  422. return err;
  423. }
  424. /*
  425. * Look up the address of a socket.
  426. */
  427. static int econet_getname(struct socket *sock, struct sockaddr *uaddr,
  428. int *uaddr_len, int peer)
  429. {
  430. struct sock *sk;
  431. struct econet_sock *eo;
  432. struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
  433. if (peer)
  434. return -EOPNOTSUPP;
  435. mutex_lock(&econet_mutex);
  436. sk = sock->sk;
  437. eo = ec_sk(sk);
  438. sec->sec_family = AF_ECONET;
  439. sec->port = eo->port;
  440. sec->addr.station = eo->station;
  441. sec->addr.net = eo->net;
  442. mutex_unlock(&econet_mutex);
  443. *uaddr_len = sizeof(*sec);
  444. return 0;
  445. }
  446. static void econet_destroy_timer(unsigned long data)
  447. {
  448. struct sock *sk=(struct sock *)data;
  449. if (!atomic_read(&sk->sk_wmem_alloc) &&
  450. !atomic_read(&sk->sk_rmem_alloc)) {
  451. sk_free(sk);
  452. return;
  453. }
  454. sk->sk_timer.expires = jiffies + 10 * HZ;
  455. add_timer(&sk->sk_timer);
  456. printk(KERN_DEBUG "econet socket destroy delayed\n");
  457. }
  458. /*
  459. * Close an econet socket.
  460. */
  461. static int econet_release(struct socket *sock)
  462. {
  463. struct sock *sk;
  464. mutex_lock(&econet_mutex);
  465. sk = sock->sk;
  466. if (!sk)
  467. goto out_unlock;
  468. econet_remove_socket(&econet_sklist, sk);
  469. /*
  470. * Now the socket is dead. No more input will appear.
  471. */
  472. sk->sk_state_change(sk); /* It is useless. Just for sanity. */
  473. sock->sk = NULL;
  474. sk->sk_socket = NULL;
  475. sock_set_flag(sk, SOCK_DEAD);
  476. /* Purge queues */
  477. skb_queue_purge(&sk->sk_receive_queue);
  478. if (atomic_read(&sk->sk_rmem_alloc) ||
  479. atomic_read(&sk->sk_wmem_alloc)) {
  480. sk->sk_timer.data = (unsigned long)sk;
  481. sk->sk_timer.expires = jiffies + HZ;
  482. sk->sk_timer.function = econet_destroy_timer;
  483. add_timer(&sk->sk_timer);
  484. goto out_unlock;
  485. }
  486. sk_free(sk);
  487. out_unlock:
  488. mutex_unlock(&econet_mutex);
  489. return 0;
  490. }
  491. static struct proto econet_proto = {
  492. .name = "ECONET",
  493. .owner = THIS_MODULE,
  494. .obj_size = sizeof(struct econet_sock),
  495. };
  496. /*
  497. * Create an Econet socket
  498. */
  499. static int econet_create(struct socket *sock, int protocol)
  500. {
  501. struct sock *sk;
  502. struct econet_sock *eo;
  503. int err;
  504. /* Econet only provides datagram services. */
  505. if (sock->type != SOCK_DGRAM)
  506. return -ESOCKTNOSUPPORT;
  507. sock->state = SS_UNCONNECTED;
  508. err = -ENOBUFS;
  509. sk = sk_alloc(PF_ECONET, GFP_KERNEL, &econet_proto, 1);
  510. if (sk == NULL)
  511. goto out;
  512. sk->sk_reuse = 1;
  513. sock->ops = &econet_ops;
  514. sock_init_data(sock, sk);
  515. eo = ec_sk(sk);
  516. sock_reset_flag(sk, SOCK_ZAPPED);
  517. sk->sk_family = PF_ECONET;
  518. eo->num = protocol;
  519. econet_insert_socket(&econet_sklist, sk);
  520. return(0);
  521. out:
  522. return err;
  523. }
  524. /*
  525. * Handle Econet specific ioctls
  526. */
  527. static int ec_dev_ioctl(struct socket *sock, unsigned int cmd, void __user *arg)
  528. {
  529. struct ifreq ifr;
  530. struct ec_device *edev;
  531. struct net_device *dev;
  532. struct sockaddr_ec *sec;
  533. int err;
  534. /*
  535. * Fetch the caller's info block into kernel space
  536. */
  537. if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
  538. return -EFAULT;
  539. if ((dev = dev_get_by_name(ifr.ifr_name)) == NULL)
  540. return -ENODEV;
  541. sec = (struct sockaddr_ec *)&ifr.ifr_addr;
  542. mutex_lock(&econet_mutex);
  543. err = 0;
  544. switch (cmd) {
  545. case SIOCSIFADDR:
  546. edev = dev->ec_ptr;
  547. if (edev == NULL) {
  548. /* Magic up a new one. */
  549. edev = kzalloc(sizeof(struct ec_device), GFP_KERNEL);
  550. if (edev == NULL) {
  551. err = -ENOMEM;
  552. break;
  553. }
  554. dev->ec_ptr = edev;
  555. } else
  556. net2dev_map[edev->net] = NULL;
  557. edev->station = sec->addr.station;
  558. edev->net = sec->addr.net;
  559. net2dev_map[sec->addr.net] = dev;
  560. if (!net2dev_map[0])
  561. net2dev_map[0] = dev;
  562. break;
  563. case SIOCGIFADDR:
  564. edev = dev->ec_ptr;
  565. if (edev == NULL) {
  566. err = -ENODEV;
  567. break;
  568. }
  569. memset(sec, 0, sizeof(struct sockaddr_ec));
  570. sec->addr.station = edev->station;
  571. sec->addr.net = edev->net;
  572. sec->sec_family = AF_ECONET;
  573. dev_put(dev);
  574. if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
  575. err = -EFAULT;
  576. break;
  577. default:
  578. err = -EINVAL;
  579. break;
  580. }
  581. mutex_unlock(&econet_mutex);
  582. dev_put(dev);
  583. return err;
  584. }
  585. /*
  586. * Handle generic ioctls
  587. */
  588. static int econet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
  589. {
  590. struct sock *sk = sock->sk;
  591. void __user *argp = (void __user *)arg;
  592. switch(cmd) {
  593. case SIOCGSTAMP:
  594. return sock_get_timestamp(sk, argp);
  595. case SIOCSIFADDR:
  596. case SIOCGIFADDR:
  597. return ec_dev_ioctl(sock, cmd, argp);
  598. break;
  599. default:
  600. return -ENOIOCTLCMD;
  601. }
  602. /*NOTREACHED*/
  603. return 0;
  604. }
  605. static struct net_proto_family econet_family_ops = {
  606. .family = PF_ECONET,
  607. .create = econet_create,
  608. .owner = THIS_MODULE,
  609. };
  610. static const struct proto_ops econet_ops = {
  611. .family = PF_ECONET,
  612. .owner = THIS_MODULE,
  613. .release = econet_release,
  614. .bind = econet_bind,
  615. .connect = sock_no_connect,
  616. .socketpair = sock_no_socketpair,
  617. .accept = sock_no_accept,
  618. .getname = econet_getname,
  619. .poll = datagram_poll,
  620. .ioctl = econet_ioctl,
  621. .listen = sock_no_listen,
  622. .shutdown = sock_no_shutdown,
  623. .setsockopt = sock_no_setsockopt,
  624. .getsockopt = sock_no_getsockopt,
  625. .sendmsg = econet_sendmsg,
  626. .recvmsg = econet_recvmsg,
  627. .mmap = sock_no_mmap,
  628. .sendpage = sock_no_sendpage,
  629. };
  630. #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
  631. /*
  632. * Find the listening socket, if any, for the given data.
  633. */
  634. static struct sock *ec_listening_socket(unsigned char port, unsigned char
  635. station, unsigned char net)
  636. {
  637. struct sock *sk;
  638. struct hlist_node *node;
  639. sk_for_each(sk, node, &econet_sklist) {
  640. struct econet_sock *opt = ec_sk(sk);
  641. if ((opt->port == port || opt->port == 0) &&
  642. (opt->station == station || opt->station == 0) &&
  643. (opt->net == net || opt->net == 0))
  644. goto found;
  645. }
  646. sk = NULL;
  647. found:
  648. return sk;
  649. }
  650. /*
  651. * Queue a received packet for a socket.
  652. */
  653. static int ec_queue_packet(struct sock *sk, struct sk_buff *skb,
  654. unsigned char stn, unsigned char net,
  655. unsigned char cb, unsigned char port)
  656. {
  657. struct ec_cb *eb = (struct ec_cb *)&skb->cb;
  658. struct sockaddr_ec *sec = (struct sockaddr_ec *)&eb->sec;
  659. memset(sec, 0, sizeof(struct sockaddr_ec));
  660. sec->sec_family = AF_ECONET;
  661. sec->type = ECTYPE_PACKET_RECEIVED;
  662. sec->port = port;
  663. sec->cb = cb;
  664. sec->addr.net = net;
  665. sec->addr.station = stn;
  666. return sock_queue_rcv_skb(sk, skb);
  667. }
  668. #endif
  669. #ifdef CONFIG_ECONET_AUNUDP
  670. /*
  671. * Send an AUN protocol response.
  672. */
  673. static void aun_send_response(__u32 addr, unsigned long seq, int code, int cb)
  674. {
  675. struct sockaddr_in sin = {
  676. .sin_family = AF_INET,
  677. .sin_port = htons(AUN_PORT),
  678. .sin_addr = {.s_addr = addr}
  679. };
  680. struct aunhdr ah = {.code = code, .cb = cb, .handle = seq};
  681. struct kvec iov = {.iov_base = (void *)&ah, .iov_len = sizeof(ah)};
  682. struct msghdr udpmsg;
  683. udpmsg.msg_name = (void *)&sin;
  684. udpmsg.msg_namelen = sizeof(sin);
  685. udpmsg.msg_control = NULL;
  686. udpmsg.msg_controllen = 0;
  687. udpmsg.msg_flags=0;
  688. kernel_sendmsg(udpsock, &udpmsg, &iov, 1, sizeof(ah));
  689. }
  690. /*
  691. * Handle incoming AUN packets. Work out if anybody wants them,
  692. * and send positive or negative acknowledgements as appropriate.
  693. */
  694. static void aun_incoming(struct sk_buff *skb, struct aunhdr *ah, size_t len)
  695. {
  696. struct iphdr *ip = skb->nh.iph;
  697. unsigned char stn = ntohl(ip->saddr) & 0xff;
  698. struct sock *sk;
  699. struct sk_buff *newskb;
  700. struct ec_device *edev = skb->dev->ec_ptr;
  701. if (! edev)
  702. goto bad;
  703. if ((sk = ec_listening_socket(ah->port, stn, edev->net)) == NULL)
  704. goto bad; /* Nobody wants it */
  705. newskb = alloc_skb((len - sizeof(struct aunhdr) + 15) & ~15,
  706. GFP_ATOMIC);
  707. if (newskb == NULL)
  708. {
  709. printk(KERN_DEBUG "AUN: memory squeeze, dropping packet.\n");
  710. /* Send nack and hope sender tries again */
  711. goto bad;
  712. }
  713. memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah+1),
  714. len - sizeof(struct aunhdr));
  715. if (ec_queue_packet(sk, newskb, stn, edev->net, ah->cb, ah->port))
  716. {
  717. /* Socket is bankrupt. */
  718. kfree_skb(newskb);
  719. goto bad;
  720. }
  721. aun_send_response(ip->saddr, ah->handle, 3, 0);
  722. return;
  723. bad:
  724. aun_send_response(ip->saddr, ah->handle, 4, 0);
  725. }
  726. /*
  727. * Handle incoming AUN transmit acknowledgements. If the sequence
  728. * number matches something in our backlog then kill it and tell
  729. * the user. If the remote took too long to reply then we may have
  730. * dropped the packet already.
  731. */
  732. static void aun_tx_ack(unsigned long seq, int result)
  733. {
  734. struct sk_buff *skb;
  735. unsigned long flags;
  736. struct ec_cb *eb;
  737. spin_lock_irqsave(&aun_queue_lock, flags);
  738. skb = skb_peek(&aun_queue);
  739. while (skb && skb != (struct sk_buff *)&aun_queue)
  740. {
  741. struct sk_buff *newskb = skb->next;
  742. eb = (struct ec_cb *)&skb->cb;
  743. if (eb->seq == seq)
  744. goto foundit;
  745. skb = newskb;
  746. }
  747. spin_unlock_irqrestore(&aun_queue_lock, flags);
  748. printk(KERN_DEBUG "AUN: unknown sequence %ld\n", seq);
  749. return;
  750. foundit:
  751. tx_result(skb->sk, eb->cookie, result);
  752. skb_unlink(skb, &aun_queue);
  753. spin_unlock_irqrestore(&aun_queue_lock, flags);
  754. kfree_skb(skb);
  755. }
  756. /*
  757. * Deal with received AUN frames - sort out what type of thing it is
  758. * and hand it to the right function.
  759. */
  760. static void aun_data_available(struct sock *sk, int slen)
  761. {
  762. int err;
  763. struct sk_buff *skb;
  764. unsigned char *data;
  765. struct aunhdr *ah;
  766. struct iphdr *ip;
  767. size_t len;
  768. while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
  769. if (err == -EAGAIN) {
  770. printk(KERN_ERR "AUN: no data available?!");
  771. return;
  772. }
  773. printk(KERN_DEBUG "AUN: recvfrom() error %d\n", -err);
  774. }
  775. data = skb->h.raw + sizeof(struct udphdr);
  776. ah = (struct aunhdr *)data;
  777. len = skb->len - sizeof(struct udphdr);
  778. ip = skb->nh.iph;
  779. switch (ah->code)
  780. {
  781. case 2:
  782. aun_incoming(skb, ah, len);
  783. break;
  784. case 3:
  785. aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_OK);
  786. break;
  787. case 4:
  788. aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_NOT_LISTENING);
  789. break;
  790. #if 0
  791. /* This isn't quite right yet. */
  792. case 5:
  793. aun_send_response(ip->saddr, ah->handle, 6, ah->cb);
  794. break;
  795. #endif
  796. default:
  797. printk(KERN_DEBUG "unknown AUN packet (type %d)\n", data[0]);
  798. }
  799. skb_free_datagram(sk, skb);
  800. }
  801. /*
  802. * Called by the timer to manage the AUN transmit queue. If a packet
  803. * was sent to a dead or nonexistent host then we will never get an
  804. * acknowledgement back. After a few seconds we need to spot this and
  805. * drop the packet.
  806. */
  807. static void ab_cleanup(unsigned long h)
  808. {
  809. struct sk_buff *skb;
  810. unsigned long flags;
  811. spin_lock_irqsave(&aun_queue_lock, flags);
  812. skb = skb_peek(&aun_queue);
  813. while (skb && skb != (struct sk_buff *)&aun_queue)
  814. {
  815. struct sk_buff *newskb = skb->next;
  816. struct ec_cb *eb = (struct ec_cb *)&skb->cb;
  817. if ((jiffies - eb->start) > eb->timeout)
  818. {
  819. tx_result(skb->sk, eb->cookie,
  820. ECTYPE_TRANSMIT_NOT_PRESENT);
  821. skb_unlink(skb, &aun_queue);
  822. kfree_skb(skb);
  823. }
  824. skb = newskb;
  825. }
  826. spin_unlock_irqrestore(&aun_queue_lock, flags);
  827. mod_timer(&ab_cleanup_timer, jiffies + (HZ*2));
  828. }
  829. static int __init aun_udp_initialise(void)
  830. {
  831. int error;
  832. struct sockaddr_in sin;
  833. skb_queue_head_init(&aun_queue);
  834. spin_lock_init(&aun_queue_lock);
  835. init_timer(&ab_cleanup_timer);
  836. ab_cleanup_timer.expires = jiffies + (HZ*2);
  837. ab_cleanup_timer.function = ab_cleanup;
  838. add_timer(&ab_cleanup_timer);
  839. memset(&sin, 0, sizeof(sin));
  840. sin.sin_port = htons(AUN_PORT);
  841. /* We can count ourselves lucky Acorn machines are too dim to
  842. speak IPv6. :-) */
  843. if ((error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock)) < 0)
  844. {
  845. printk("AUN: socket error %d\n", -error);
  846. return error;
  847. }
  848. udpsock->sk->sk_reuse = 1;
  849. udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
  850. from interrupts */
  851. error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
  852. sizeof(sin));
  853. if (error < 0)
  854. {
  855. printk("AUN: bind error %d\n", -error);
  856. goto release;
  857. }
  858. udpsock->sk->sk_data_ready = aun_data_available;
  859. return 0;
  860. release:
  861. sock_release(udpsock);
  862. udpsock = NULL;
  863. return error;
  864. }
  865. #endif
  866. #ifdef CONFIG_ECONET_NATIVE
  867. /*
  868. * Receive an Econet frame from a device.
  869. */
  870. static int econet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
  871. {
  872. struct ec_framehdr *hdr;
  873. struct sock *sk;
  874. struct ec_device *edev = dev->ec_ptr;
  875. if (skb->pkt_type == PACKET_OTHERHOST)
  876. goto drop;
  877. if (!edev)
  878. goto drop;
  879. if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
  880. return NET_RX_DROP;
  881. if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
  882. goto drop;
  883. hdr = (struct ec_framehdr *) skb->data;
  884. /* First check for encapsulated IP */
  885. if (hdr->port == EC_PORT_IP) {
  886. skb->protocol = htons(ETH_P_IP);
  887. skb_pull(skb, sizeof(struct ec_framehdr));
  888. netif_rx(skb);
  889. return 0;
  890. }
  891. sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
  892. if (!sk)
  893. goto drop;
  894. if (ec_queue_packet(sk, skb, edev->net, hdr->src_stn, hdr->cb,
  895. hdr->port))
  896. goto drop;
  897. return 0;
  898. drop:
  899. kfree_skb(skb);
  900. return NET_RX_DROP;
  901. }
  902. static struct packet_type econet_packet_type = {
  903. .type = __constant_htons(ETH_P_ECONET),
  904. .func = econet_rcv,
  905. };
  906. static void econet_hw_initialise(void)
  907. {
  908. dev_add_pack(&econet_packet_type);
  909. }
  910. #endif
  911. static int econet_notifier(struct notifier_block *this, unsigned long msg, void *data)
  912. {
  913. struct net_device *dev = (struct net_device *)data;
  914. struct ec_device *edev;
  915. switch (msg) {
  916. case NETDEV_UNREGISTER:
  917. /* A device has gone down - kill any data we hold for it. */
  918. edev = dev->ec_ptr;
  919. if (edev)
  920. {
  921. if (net2dev_map[0] == dev)
  922. net2dev_map[0] = NULL;
  923. net2dev_map[edev->net] = NULL;
  924. kfree(edev);
  925. dev->ec_ptr = NULL;
  926. }
  927. break;
  928. }
  929. return NOTIFY_DONE;
  930. }
  931. static struct notifier_block econet_netdev_notifier = {
  932. .notifier_call =econet_notifier,
  933. };
  934. static void __exit econet_proto_exit(void)
  935. {
  936. #ifdef CONFIG_ECONET_AUNUDP
  937. del_timer(&ab_cleanup_timer);
  938. if (udpsock)
  939. sock_release(udpsock);
  940. #endif
  941. unregister_netdevice_notifier(&econet_netdev_notifier);
  942. sock_unregister(econet_family_ops.family);
  943. proto_unregister(&econet_proto);
  944. }
  945. static int __init econet_proto_init(void)
  946. {
  947. int err = proto_register(&econet_proto, 0);
  948. if (err != 0)
  949. goto out;
  950. sock_register(&econet_family_ops);
  951. #ifdef CONFIG_ECONET_AUNUDP
  952. spin_lock_init(&aun_queue_lock);
  953. aun_udp_initialise();
  954. #endif
  955. #ifdef CONFIG_ECONET_NATIVE
  956. econet_hw_initialise();
  957. #endif
  958. register_netdevice_notifier(&econet_netdev_notifier);
  959. out:
  960. return err;
  961. }
  962. module_init(econet_proto_init);
  963. module_exit(econet_proto_exit);
  964. MODULE_LICENSE("GPL");
  965. MODULE_ALIAS_NETPROTO(PF_ECONET);