1/* net/atm/clip.c - RFC1577 Classical IP over ATM */
  2
  3/* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
  4
  5#define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
  6
  7#include <linux/string.h>
  8#include <linux/errno.h>
  9#include <linux/kernel.h> /* for UINT_MAX */
 10#include <linux/module.h>
 11#include <linux/init.h>
 12#include <linux/netdevice.h>
 13#include <linux/skbuff.h>
 14#include <linux/wait.h>
 15#include <linux/timer.h>
 16#include <linux/if_arp.h> /* for some manifest constants */
 17#include <linux/notifier.h>
 18#include <linux/atm.h>
 19#include <linux/atmdev.h>
 20#include <linux/atmclip.h>
 21#include <linux/atmarp.h>
 22#include <linux/capability.h>
 23#include <linux/ip.h> /* for net/route.h */
 24#include <linux/in.h> /* for struct sockaddr_in */
 25#include <linux/if.h> /* for IFF_UP */
 26#include <linux/inetdevice.h>
 27#include <linux/bitops.h>
 28#include <linux/poison.h>
 29#include <linux/proc_fs.h>
 30#include <linux/seq_file.h>
 31#include <linux/rcupdate.h>
 32#include <linux/jhash.h>
 33#include <linux/slab.h>
 34#include <net/route.h> /* for struct rtable and routing */
 35#include <net/icmp.h> /* icmp_send */
 36#include <net/arp.h>
 37#include <linux/param.h> /* for HZ */
 38#include <linux/uaccess.h>
 39#include <asm/byteorder.h> /* for htons etc. */
 40#include <linux/atomic.h>
 41
 42#include "common.h"
 43#include "resources.h"
 44#include <net/atmclip.h>
 45
 46static struct net_device *clip_devs;
 47static struct atm_vcc *atmarpd;
 48static struct timer_list idle_timer;
 49static const struct neigh_ops clip_neigh_ops;
 50
 51static int to_atmarpd(enum atmarp_ctrl_type type, int itf, __be32 ip)
 52{
 53	struct sock *sk;
 54	struct atmarp_ctrl *ctrl;
 55	struct sk_buff *skb;
 56
 57	pr_debug("(%d)\n", type);
 58	if (!atmarpd)
 59		return -EUNATCH;
 60	skb = alloc_skb(sizeof(struct atmarp_ctrl), GFP_ATOMIC);
 61	if (!skb)
 62		return -ENOMEM;
 63	ctrl = (struct atmarp_ctrl *)skb_put(skb, sizeof(struct atmarp_ctrl));
 64	ctrl->type = type;
 65	ctrl->itf_num = itf;
 66	ctrl->ip = ip;
 67	atm_force_charge(atmarpd, skb->truesize);
 68
 69	sk = sk_atm(atmarpd);
 70	skb_queue_tail(&sk->sk_receive_queue, skb);
 71	sk->sk_data_ready(sk);
 72	return 0;
 73}
 74
 75static void link_vcc(struct clip_vcc *clip_vcc, struct atmarp_entry *entry)
 76{
 77	pr_debug("%p to entry %p (neigh %p)\n", clip_vcc, entry, entry->neigh);
 78	clip_vcc->entry = entry;
 79	clip_vcc->xoff = 0;	/* @@@ may overrun buffer by one packet */
 80	clip_vcc->next = entry->vccs;
 81	entry->vccs = clip_vcc;
 82	entry->neigh->used = jiffies;
 83}
 84
 85static void unlink_clip_vcc(struct clip_vcc *clip_vcc)
 86{
 87	struct atmarp_entry *entry = clip_vcc->entry;
 88	struct clip_vcc **walk;
 89
 90	if (!entry) {
 91		pr_crit("!clip_vcc->entry (clip_vcc %p)\n", clip_vcc);
 92		return;
 93	}
 94	netif_tx_lock_bh(entry->neigh->dev);	/* block clip_start_xmit() */
 95	entry->neigh->used = jiffies;
 96	for (walk = &entry->vccs; *walk; walk = &(*walk)->next)
 97		if (*walk == clip_vcc) {
 98			int error;
 99
100			*walk = clip_vcc->next;	/* atomic */
101			clip_vcc->entry = NULL;
102			if (clip_vcc->xoff)
103				netif_wake_queue(entry->neigh->dev);
104			if (entry->vccs)
105				goto out;
106			entry->expires = jiffies - 1;
107			/* force resolution or expiration */
108			error = neigh_update(entry->neigh, NULL, NUD_NONE,
109					     NEIGH_UPDATE_F_ADMIN);
110			if (error)
111				pr_crit("neigh_update failed with %d\n", error);
112			goto out;
113		}
114	pr_crit("ATMARP: failed (entry %p, vcc 0x%p)\n", entry, clip_vcc);
115out:
116	netif_tx_unlock_bh(entry->neigh->dev);
117}
118
119/* The neighbour entry n->lock is held. */
120static int neigh_check_cb(struct neighbour *n)
121{
122	struct atmarp_entry *entry = neighbour_priv(n);
123	struct clip_vcc *cv;
124
125	if (n->ops != &clip_neigh_ops)
126		return 0;
127	for (cv = entry->vccs; cv; cv = cv->next) {
128		unsigned long exp = cv->last_use + cv->idle_timeout;
129
130		if (cv->idle_timeout && time_after(jiffies, exp)) {
131			pr_debug("releasing vcc %p->%p of entry %p\n",
132				 cv, cv->vcc, entry);
133			vcc_release_async(cv->vcc, -ETIMEDOUT);
134		}
135	}
136
137	if (entry->vccs || time_before(jiffies, entry->expires))
138		return 0;
139
140	if (atomic_read(&n->refcnt) > 1) {
141		struct sk_buff *skb;
142
143		pr_debug("destruction postponed with ref %d\n",
144			 atomic_read(&n->refcnt));
145
146		while ((skb = skb_dequeue(&n->arp_queue)) != NULL)
147			dev_kfree_skb(skb);
148
149		return 0;
150	}
151
152	pr_debug("expired neigh %p\n", n);
153	return 1;
154}
155
156static void idle_timer_check(unsigned long dummy)
157{
158	write_lock(&arp_tbl.lock);
159	__neigh_for_each_release(&arp_tbl, neigh_check_cb);
160	mod_timer(&idle_timer, jiffies + CLIP_CHECK_INTERVAL * HZ);
161	write_unlock(&arp_tbl.lock);
162}
163
164static int clip_arp_rcv(struct sk_buff *skb)
165{
166	struct atm_vcc *vcc;
167
168	pr_debug("\n");
169	vcc = ATM_SKB(skb)->vcc;
170	if (!vcc || !atm_charge(vcc, skb->truesize)) {
171		dev_kfree_skb_any(skb);
172		return 0;
173	}
174	pr_debug("pushing to %p\n", vcc);
175	pr_debug("using %p\n", CLIP_VCC(vcc)->old_push);
176	CLIP_VCC(vcc)->old_push(vcc, skb);
177	return 0;
178}
179
180static const unsigned char llc_oui[] = {
181	0xaa,	/* DSAP: non-ISO */
182	0xaa,	/* SSAP: non-ISO */
183	0x03,	/* Ctrl: Unnumbered Information Command PDU */
184	0x00,	/* OUI: EtherType */
185	0x00,
186	0x00
187};
188
189static void clip_push(struct atm_vcc *vcc, struct sk_buff *skb)
190{
191	struct clip_vcc *clip_vcc = CLIP_VCC(vcc);
192
193	pr_debug("\n");
194
195	if (!clip_devs) {
196		atm_return(vcc, skb->truesize);
197		kfree_skb(skb);
198		return;
199	}
200
201	if (!skb) {
202		pr_debug("removing VCC %p\n", clip_vcc);
203		if (clip_vcc->entry)
204			unlink_clip_vcc(clip_vcc);
205		clip_vcc->old_push(vcc, NULL);	/* pass on the bad news */
206		kfree(clip_vcc);
207		return;
208	}
209	atm_return(vcc, skb->truesize);
210	skb->dev = clip_vcc->entry ? clip_vcc->entry->neigh->dev : clip_devs;
211	/* clip_vcc->entry == NULL if we don't have an IP address yet */
212	if (!skb->dev) {
213		dev_kfree_skb_any(skb);
214		return;
215	}
216	ATM_SKB(skb)->vcc = vcc;
217	skb_reset_mac_header(skb);
218	if (!clip_vcc->encap ||
219	    skb->len < RFC1483LLC_LEN ||
220	    memcmp(skb->data, llc_oui, sizeof(llc_oui)))
221		skb->protocol = htons(ETH_P_IP);
222	else {
223		skb->protocol = ((__be16 *)skb->data)[3];
224		skb_pull(skb, RFC1483LLC_LEN);
225		if (skb->protocol == htons(ETH_P_ARP)) {
226			skb->dev->stats.rx_packets++;
227			skb->dev->stats.rx_bytes += skb->len;
228			clip_arp_rcv(skb);
229			return;
230		}
231	}
232	clip_vcc->last_use = jiffies;
233	skb->dev->stats.rx_packets++;
234	skb->dev->stats.rx_bytes += skb->len;
235	memset(ATM_SKB(skb), 0, sizeof(struct atm_skb_data));
236	netif_rx(skb);
237}
238
239/*
240 * Note: these spinlocks _must_not_ block on non-SMP. The only goal is that
241 * clip_pop is atomic with respect to the critical section in clip_start_xmit.
242 */
243
244static void clip_pop(struct atm_vcc *vcc, struct sk_buff *skb)
245{
246	struct clip_vcc *clip_vcc = CLIP_VCC(vcc);
247	struct net_device *dev = skb->dev;
248	int old;
249	unsigned long flags;
250
251	pr_debug("(vcc %p)\n", vcc);
252	clip_vcc->old_pop(vcc, skb);
253	/* skb->dev == NULL in outbound ARP packets */
254	if (!dev)
255		return;
256	spin_lock_irqsave(&PRIV(dev)->xoff_lock, flags);
257	if (atm_may_send(vcc, 0)) {
258		old = xchg(&clip_vcc->xoff, 0);
259		if (old)
260			netif_wake_queue(dev);
261	}
262	spin_unlock_irqrestore(&PRIV(dev)->xoff_lock, flags);
263}
264
265static void clip_neigh_solicit(struct neighbour *neigh, struct sk_buff *skb)
266{
267	__be32 *ip = (__be32 *) neigh->primary_key;
268
269	pr_debug("(neigh %p, skb %p)\n", neigh, skb);
270	to_atmarpd(act_need, PRIV(neigh->dev)->number, *ip);
271}
272
273static void clip_neigh_error(struct neighbour *neigh, struct sk_buff *skb)
274{
275#ifndef CONFIG_ATM_CLIP_NO_ICMP
276	icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
277#endif
278	kfree_skb(skb);
279}
280
281static const struct neigh_ops clip_neigh_ops = {
282	.family =		AF_INET,
283	.solicit =		clip_neigh_solicit,
284	.error_report =		clip_neigh_error,
285	.output =		neigh_direct_output,
286	.connected_output =	neigh_direct_output,
287};
288
289static int clip_constructor(struct neighbour *neigh)
290{
291	struct atmarp_entry *entry = neighbour_priv(neigh);
292
293	if (neigh->tbl->family != AF_INET)
294		return -EINVAL;
295
296	if (neigh->type != RTN_UNICAST)
297		return -EINVAL;
298
299	neigh->nud_state = NUD_NONE;
300	neigh->ops = &clip_neigh_ops;
301	neigh->output = neigh->ops->output;
302	entry->neigh = neigh;
303	entry->vccs = NULL;
304	entry->expires = jiffies - 1;
305
306	return 0;
307}
308
309/* @@@ copy bh locking from arp.c -- need to bh-enable atm code before */
310
311/*
312 * We play with the resolve flag: 0 and 1 have the usual meaning, but -1 means
313 * to allocate the neighbour entry but not to ask atmarpd for resolution. Also,
314 * don't increment the usage count. This is used to create entries in
315 * clip_setentry.
316 */
317
318static int clip_encap(struct atm_vcc *vcc, int mode)
319{
320	CLIP_VCC(vcc)->encap = mode;
321	return 0;
322}
323
324static netdev_tx_t clip_start_xmit(struct sk_buff *skb,
325				   struct net_device *dev)
326{
327	struct clip_priv *clip_priv = PRIV(dev);
328	struct dst_entry *dst = skb_dst(skb);
329	struct atmarp_entry *entry;
330	struct neighbour *n;
331	struct atm_vcc *vcc;
332	struct rtable *rt;
333	__be32 *daddr;
334	int old;
335	unsigned long flags;
336
337	pr_debug("(skb %p)\n", skb);
338	if (!dst) {
339		pr_err("skb_dst(skb) == NULL\n");
340		dev_kfree_skb(skb);
341		dev->stats.tx_dropped++;
342		return NETDEV_TX_OK;
343	}
344	rt = (struct rtable *) dst;
345	if (rt->rt_gateway)
346		daddr = &rt->rt_gateway;
347	else
348		daddr = &ip_hdr(skb)->daddr;
349	n = dst_neigh_lookup(dst, daddr);
350	if (!n) {
351		pr_err("NO NEIGHBOUR !\n");
352		dev_kfree_skb(skb);
353		dev->stats.tx_dropped++;
354		return NETDEV_TX_OK;
355	}
356	entry = neighbour_priv(n);
357	if (!entry->vccs) {
358		if (time_after(jiffies, entry->expires)) {
359			/* should be resolved */
360			entry->expires = jiffies + ATMARP_RETRY_DELAY * HZ;
361			to_atmarpd(act_need, PRIV(dev)->number, *((__be32 *)n->primary_key));
362		}
363		if (entry->neigh->arp_queue.qlen < ATMARP_MAX_UNRES_PACKETS)
364			skb_queue_tail(&entry->neigh->arp_queue, skb);
365		else {
366			dev_kfree_skb(skb);
367			dev->stats.tx_dropped++;
368		}
369		goto out_release_neigh;
370	}
371	pr_debug("neigh %p, vccs %p\n", entry, entry->vccs);
372	ATM_SKB(skb)->vcc = vcc = entry->vccs->vcc;
373	pr_debug("using neighbour %p, vcc %p\n", n, vcc);
374	if (entry->vccs->encap) {
375		void *here;
376
377		here = skb_push(skb, RFC1483LLC_LEN);
378		memcpy(here, llc_oui, sizeof(llc_oui));
379		((__be16 *) here)[3] = skb->protocol;
380	}
381	atomic_add(skb->truesize, &sk_atm(vcc)->sk_wmem_alloc);
382	ATM_SKB(skb)->atm_options = vcc->atm_options;
383	entry->vccs->last_use = jiffies;
384	pr_debug("atm_skb(%p)->vcc(%p)->dev(%p)\n", skb, vcc, vcc->dev);
385	old = xchg(&entry->vccs->xoff, 1);	/* assume XOFF ... */
386	if (old) {
387		pr_warning("XOFF->XOFF transition\n");
388		goto out_release_neigh;
389	}
390	dev->stats.tx_packets++;
391	dev->stats.tx_bytes += skb->len;
392	vcc->send(vcc, skb);
393	if (atm_may_send(vcc, 0)) {
394		entry->vccs->xoff = 0;
395		goto out_release_neigh;
396	}
397	spin_lock_irqsave(&clip_priv->xoff_lock, flags);
398	netif_stop_queue(dev);	/* XOFF -> throttle immediately */
399	barrier();
400	if (!entry->vccs->xoff)
401		netif_start_queue(dev);
402	/* Oh, we just raced with clip_pop. netif_start_queue should be
403	   good enough, because nothing should really be asleep because
404	   of the brief netif_stop_queue. If this isn't true or if it
405	   changes, use netif_wake_queue instead. */
406	spin_unlock_irqrestore(&clip_priv->xoff_lock, flags);
407out_release_neigh:
408	neigh_release(n);
409	return NETDEV_TX_OK;
410}
411
412static int clip_mkip(struct atm_vcc *vcc, int timeout)
413{
414	struct clip_vcc *clip_vcc;
415
416	if (!vcc->push)
417		return -EBADFD;
418	clip_vcc = kmalloc(sizeof(struct clip_vcc), GFP_KERNEL);
419	if (!clip_vcc)
420		return -ENOMEM;
421	pr_debug("%p vcc %p\n", clip_vcc, vcc);
422	clip_vcc->vcc = vcc;
423	vcc->user_back = clip_vcc;
424	set_bit(ATM_VF_IS_CLIP, &vcc->flags);
425	clip_vcc->entry = NULL;
426	clip_vcc->xoff = 0;
427	clip_vcc->encap = 1;
428	clip_vcc->last_use = jiffies;
429	clip_vcc->idle_timeout = timeout * HZ;
430	clip_vcc->old_push = vcc->push;
431	clip_vcc->old_pop = vcc->pop;
432	vcc->push = clip_push;
433	vcc->pop = clip_pop;
434
435	/* re-process everything received between connection setup and MKIP */
436	vcc_process_recv_queue(vcc);
437
438	return 0;
439}
440
441static int clip_setentry(struct atm_vcc *vcc, __be32 ip)
442{
443	struct neighbour *neigh;
444	struct atmarp_entry *entry;
445	int error;
446	struct clip_vcc *clip_vcc;
447	struct rtable *rt;
448
449	if (vcc->push != clip_push) {
450		pr_warning("non-CLIP VCC\n");
451		return -EBADF;
452	}
453	clip_vcc = CLIP_VCC(vcc);
454	if (!ip) {
455		if (!clip_vcc->entry) {
456			pr_err("hiding hidden ATMARP entry\n");
457			return 0;
458		}
459		pr_debug("remove\n");
460		unlink_clip_vcc(clip_vcc);
461		return 0;
462	}
463	rt = ip_route_output(&init_net, ip, 0, 1, 0);
464	if (IS_ERR(rt))
465		return PTR_ERR(rt);
466	neigh = __neigh_lookup(&arp_tbl, &ip, rt->dst.dev, 1);
467	ip_rt_put(rt);
468	if (!neigh)
469		return -ENOMEM;
470	entry = neighbour_priv(neigh);
471	if (entry != clip_vcc->entry) {
472		if (!clip_vcc->entry)
473			pr_debug("add\n");
474		else {
475			pr_debug("update\n");
476			unlink_clip_vcc(clip_vcc);
477		}
478		link_vcc(clip_vcc, entry);
479	}
480	error = neigh_update(neigh, llc_oui, NUD_PERMANENT,
481			     NEIGH_UPDATE_F_OVERRIDE | NEIGH_UPDATE_F_ADMIN);
482	neigh_release(neigh);
483	return error;
484}
485
486static const struct net_device_ops clip_netdev_ops = {
487	.ndo_start_xmit		= clip_start_xmit,
488	.ndo_neigh_construct	= clip_constructor,
489};
490
491static void clip_setup(struct net_device *dev)
492{
493	dev->netdev_ops = &clip_netdev_ops;
494	dev->type = ARPHRD_ATM;
495	dev->neigh_priv_len = sizeof(struct atmarp_entry);
496	dev->hard_header_len = RFC1483LLC_LEN;
497	dev->mtu = RFC1626_MTU;
498	dev->tx_queue_len = 100;	/* "normal" queue (packets) */
499	/* When using a "real" qdisc, the qdisc determines the queue */
500	/* length. tx_queue_len is only used for the default case, */
501	/* without any more elaborate queuing. 100 is a reasonable */
502	/* compromise between decent burst-tolerance and protection */
503	/* against memory hogs. */
504	dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
505}
506
507static int clip_create(int number)
508{
509	struct net_device *dev;
510	struct clip_priv *clip_priv;
511	int error;
512
513	if (number != -1) {
514		for (dev = clip_devs; dev; dev = PRIV(dev)->next)
515			if (PRIV(dev)->number == number)
516				return -EEXIST;
517	} else {
518		number = 0;
519		for (dev = clip_devs; dev; dev = PRIV(dev)->next)
520			if (PRIV(dev)->number >= number)
521				number = PRIV(dev)->number + 1;
522	}
523	dev = alloc_netdev(sizeof(struct clip_priv), "", clip_setup);
524	if (!dev)
525		return -ENOMEM;
526	clip_priv = PRIV(dev);
527	sprintf(dev->name, "atm%d", number);
528	spin_lock_init(&clip_priv->xoff_lock);
529	clip_priv->number = number;
530	error = register_netdev(dev);
531	if (error) {
532		free_netdev(dev);
533		return error;
534	}
535	clip_priv->next = clip_devs;
536	clip_devs = dev;
537	pr_debug("registered (net:%s)\n", dev->name);
538	return number;
539}
540
541static int clip_device_event(struct notifier_block *this, unsigned long event,
542			     void *ptr)
543{
544	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
545
546	if (!net_eq(dev_net(dev), &init_net))
547		return NOTIFY_DONE;
548
549	if (event == NETDEV_UNREGISTER)
550		return NOTIFY_DONE;
551
552	/* ignore non-CLIP devices */
553	if (dev->type != ARPHRD_ATM || dev->netdev_ops != &clip_netdev_ops)
554		return NOTIFY_DONE;
555
556	switch (event) {
557	case NETDEV_UP:
558		pr_debug("NETDEV_UP\n");
559		to_atmarpd(act_up, PRIV(dev)->number, 0);
560		break;
561	case NETDEV_GOING_DOWN:
562		pr_debug("NETDEV_DOWN\n");
563		to_atmarpd(act_down, PRIV(dev)->number, 0);
564		break;
565	case NETDEV_CHANGE:
566	case NETDEV_CHANGEMTU:
567		pr_debug("NETDEV_CHANGE*\n");
568		to_atmarpd(act_change, PRIV(dev)->number, 0);
569		break;
570	}
571	return NOTIFY_DONE;
572}
573
574static int clip_inet_event(struct notifier_block *this, unsigned long event,
575			   void *ifa)
576{
577	struct in_device *in_dev;
578	struct netdev_notifier_info info;
579
580	in_dev = ((struct in_ifaddr *)ifa)->ifa_dev;
581	/*
582	 * Transitions are of the down-change-up type, so it's sufficient to
583	 * handle the change on up.
584	 */
585	if (event != NETDEV_UP)
586		return NOTIFY_DONE;
587	netdev_notifier_info_init(&info, in_dev->dev);
588	return clip_device_event(this, NETDEV_CHANGE, &info);
589}
590
591static struct notifier_block clip_dev_notifier = {
592	.notifier_call = clip_device_event,
593};
594
595
596
597static struct notifier_block clip_inet_notifier = {
598	.notifier_call = clip_inet_event,
599};
600
601
602
603static void atmarpd_close(struct atm_vcc *vcc)
604{
605	pr_debug("\n");
606
607	rtnl_lock();
608	atmarpd = NULL;
609	skb_queue_purge(&sk_atm(vcc)->sk_receive_queue);
610	rtnl_unlock();
611
612	pr_debug("(done)\n");
613	module_put(THIS_MODULE);
614}
615
616static struct atmdev_ops atmarpd_dev_ops = {
617	.close = atmarpd_close
618};
619
620
621static struct atm_dev atmarpd_dev = {
622	.ops =			&atmarpd_dev_ops,
623	.type =			"arpd",
624	.number = 		999,
625	.lock =			__SPIN_LOCK_UNLOCKED(atmarpd_dev.lock)
626};
627
628
629static int atm_init_atmarp(struct atm_vcc *vcc)
630{
631	rtnl_lock();
632	if (atmarpd) {
633		rtnl_unlock();
634		return -EADDRINUSE;
635	}
636
637	mod_timer(&idle_timer, jiffies + CLIP_CHECK_INTERVAL * HZ);
638
639	atmarpd = vcc;
640	set_bit(ATM_VF_META, &vcc->flags);
641	set_bit(ATM_VF_READY, &vcc->flags);
642	    /* allow replies and avoid getting closed if signaling dies */
643	vcc->dev = &atmarpd_dev;
644	vcc_insert_socket(sk_atm(vcc));
645	vcc->push = NULL;
646	vcc->pop = NULL; /* crash */
647	vcc->push_oam = NULL; /* crash */
648	rtnl_unlock();
649	return 0;
650}
651
652static int clip_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
653{
654	struct atm_vcc *vcc = ATM_SD(sock);
655	int err = 0;
656
657	switch (cmd) {
658	case SIOCMKCLIP:
659	case ATMARPD_CTRL:
660	case ATMARP_MKIP:
661	case ATMARP_SETENTRY:
662	case ATMARP_ENCAP:
663		if (!capable(CAP_NET_ADMIN))
664			return -EPERM;
665		break;
666	default:
667		return -ENOIOCTLCMD;
668	}
669
670	switch (cmd) {
671	case SIOCMKCLIP:
672		err = clip_create(arg);
673		break;
674	case ATMARPD_CTRL:
675		err = atm_init_atmarp(vcc);
676		if (!err) {
677			sock->state = SS_CONNECTED;
678			__module_get(THIS_MODULE);
679		}
680		break;
681	case ATMARP_MKIP:
682		err = clip_mkip(vcc, arg);
683		break;
684	case ATMARP_SETENTRY:
685		err = clip_setentry(vcc, (__force __be32)arg);
686		break;
687	case ATMARP_ENCAP:
688		err = clip_encap(vcc, arg);
689		break;
690	}
691	return err;
692}
693
694static struct atm_ioctl clip_ioctl_ops = {
695	.owner = THIS_MODULE,
696	.ioctl = clip_ioctl,
697};
698
699#ifdef CONFIG_PROC_FS
700
701static void svc_addr(struct seq_file *seq, struct sockaddr_atmsvc *addr)
702{
703	static int code[] = { 1, 2, 10, 6, 1, 0 };
704	static int e164[] = { 1, 8, 4, 6, 1, 0 };
705
706	if (*addr->sas_addr.pub) {
707		seq_printf(seq, "%s", addr->sas_addr.pub);
708		if (*addr->sas_addr.prv)
709			seq_putc(seq, '+');
710	} else if (!*addr->sas_addr.prv) {
711		seq_printf(seq, "%s", "(none)");
712		return;
713	}
714	if (*addr->sas_addr.prv) {
715		unsigned char *prv = addr->sas_addr.prv;
716		int *fields;
717		int i, j;
718
719		fields = *prv == ATM_AFI_E164 ? e164 : code;
720		for (i = 0; fields[i]; i++) {
721			for (j = fields[i]; j; j--)
722				seq_printf(seq, "%02X", *prv++);
723			if (fields[i + 1])
724				seq_putc(seq, '.');
725		}
726	}
727}
728
729/* This means the neighbour entry has no attached VCC objects. */
730#define SEQ_NO_VCC_TOKEN	((void *) 2)
731
732static void atmarp_info(struct seq_file *seq, struct neighbour *n,
733			struct atmarp_entry *entry, struct clip_vcc *clip_vcc)
734{
735	struct net_device *dev = n->dev;
736	unsigned long exp;
737	char buf[17];
738	int svc, llc, off;
739
740	svc = ((clip_vcc == SEQ_NO_VCC_TOKEN) ||
741	       (sk_atm(clip_vcc->vcc)->sk_family == AF_ATMSVC));
742
743	llc = ((clip_vcc == SEQ_NO_VCC_TOKEN) || clip_vcc->encap);
744
745	if (clip_vcc == SEQ_NO_VCC_TOKEN)
746		exp = entry->neigh->used;
747	else
748		exp = clip_vcc->last_use;
749
750	exp = (jiffies - exp) / HZ;
751
752	seq_printf(seq, "%-6s%-4s%-4s%5ld ",
753		   dev->name, svc ? "SVC" : "PVC", llc ? "LLC" : "NULL", exp);
754
755	off = scnprintf(buf, sizeof(buf) - 1, "%pI4", n->primary_key);
756	while (off < 16)
757		buf[off++] = ' ';
758	buf[off] = '\0';
759	seq_printf(seq, "%s", buf);
760
761	if (clip_vcc == SEQ_NO_VCC_TOKEN) {
762		if (time_before(jiffies, entry->expires))
763			seq_printf(seq, "(resolving)\n");
764		else
765			seq_printf(seq, "(expired, ref %d)\n",
766				   atomic_read(&entry->neigh->refcnt));
767	} else if (!svc) {
768		seq_printf(seq, "%d.%d.%d\n",
769			   clip_vcc->vcc->dev->number,
770			   clip_vcc->vcc->vpi, clip_vcc->vcc->vci);
771	} else {
772		svc_addr(seq, &clip_vcc->vcc->remote);
773		seq_putc(seq, '\n');
774	}
775}
776
777struct clip_seq_state {
778	/* This member must be first. */
779	struct neigh_seq_state ns;
780
781	/* Local to clip specific iteration. */
782	struct clip_vcc *vcc;
783};
784
785static struct clip_vcc *clip_seq_next_vcc(struct atmarp_entry *e,
786					  struct clip_vcc *curr)
787{
788	if (!curr) {
789		curr = e->vccs;
790		if (!curr)
791			return SEQ_NO_VCC_TOKEN;
792		return curr;
793	}
794	if (curr == SEQ_NO_VCC_TOKEN)
795		return NULL;
796
797	curr = curr->next;
798
799	return curr;
800}
801
802static void *clip_seq_vcc_walk(struct clip_seq_state *state,
803			       struct atmarp_entry *e, loff_t * pos)
804{
805	struct clip_vcc *vcc = state->vcc;
806
807	vcc = clip_seq_next_vcc(e, vcc);
808	if (vcc && pos != NULL) {
809		while (*pos) {
810			vcc = clip_seq_next_vcc(e, vcc);
811			if (!vcc)
812				break;
813			--(*pos);
814		}
815	}
816	state->vcc = vcc;
817
818	return vcc;
819}
820
821static void *clip_seq_sub_iter(struct neigh_seq_state *_state,
822			       struct neighbour *n, loff_t * pos)
823{
824	struct clip_seq_state *state = (struct clip_seq_state *)_state;
825
826	if (n->dev->type != ARPHRD_ATM)
827		return NULL;
828
829	return clip_seq_vcc_walk(state, neighbour_priv(n), pos);
830}
831
832static void *clip_seq_start(struct seq_file *seq, loff_t * pos)
833{
834	struct clip_seq_state *state = seq->private;
835	state->ns.neigh_sub_iter = clip_seq_sub_iter;
836	return neigh_seq_start(seq, pos, &arp_tbl, NEIGH_SEQ_NEIGH_ONLY);
837}
838
839static int clip_seq_show(struct seq_file *seq, void *v)
840{
841	static char atm_arp_banner[] =
842	    "IPitf TypeEncp Idle IP address      ATM address\n";
843
844	if (v == SEQ_START_TOKEN) {
845		seq_puts(seq, atm_arp_banner);
846	} else {
847		struct clip_seq_state *state = seq->private;
848		struct clip_vcc *vcc = state->vcc;
849		struct neighbour *n = v;
850
851		atmarp_info(seq, n, neighbour_priv(n), vcc);
852	}
853	return 0;
854}
855
856static const struct seq_operations arp_seq_ops = {
857	.start	= clip_seq_start,
858	.next	= neigh_seq_next,
859	.stop	= neigh_seq_stop,
860	.show	= clip_seq_show,
861};
862
863static int arp_seq_open(struct inode *inode, struct file *file)
864{
865	return seq_open_net(inode, file, &arp_seq_ops,
866			    sizeof(struct clip_seq_state));
867}
868
869static const struct file_operations arp_seq_fops = {
870	.open		= arp_seq_open,
871	.read		= seq_read,
872	.llseek		= seq_lseek,
873	.release	= seq_release_net,
874	.owner		= THIS_MODULE
875};
876#endif
877
878static void atm_clip_exit_noproc(void);
879
880static int __init atm_clip_init(void)
881{
882	register_atm_ioctl(&clip_ioctl_ops);
883	register_netdevice_notifier(&clip_dev_notifier);
884	register_inetaddr_notifier(&clip_inet_notifier);
885
886	setup_timer(&idle_timer, idle_timer_check, 0);
887
888#ifdef CONFIG_PROC_FS
889	{
890		struct proc_dir_entry *p;
891
892		p = proc_create("arp", S_IRUGO, atm_proc_root, &arp_seq_fops);
893		if (!p) {
894			pr_err("Unable to initialize /proc/net/atm/arp\n");
895			atm_clip_exit_noproc();
896			return -ENOMEM;
897		}
898	}
899#endif
900
901	return 0;
902}
903
904static void atm_clip_exit_noproc(void)
905{
906	struct net_device *dev, *next;
907
908	unregister_inetaddr_notifier(&clip_inet_notifier);
909	unregister_netdevice_notifier(&clip_dev_notifier);
910
911	deregister_atm_ioctl(&clip_ioctl_ops);
912
913	/* First, stop the idle timer, so it stops banging
914	 * on the table.
915	 */
916	del_timer_sync(&idle_timer);
917
918	dev = clip_devs;
919	while (dev) {
920		next = PRIV(dev)->next;
921		unregister_netdev(dev);
922		free_netdev(dev);
923		dev = next;
924	}
925}
926
927static void __exit atm_clip_exit(void)
928{
929	remove_proc_entry("arp", atm_proc_root);
930
931	atm_clip_exit_noproc();
932}
933
934module_init(atm_clip_init);
935module_exit(atm_clip_exit);
936MODULE_AUTHOR("Werner Almesberger");
937MODULE_DESCRIPTION("Classical/IP over ATM interface");
938MODULE_LICENSE("GPL");