~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/econet/af_econet.c

Version: ~ [ linux-5.0-rc6 ] ~ [ linux-4.20.10 ] ~ [ linux-4.19.23 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.101 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.158 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.174 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.134 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.63 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp