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_warn("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_warn("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	netif_keep_dst(dev);
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), "", NET_NAME_UNKNOWN,
524			   clip_setup);
525	if (!dev)
526		return -ENOMEM;
527	clip_priv = PRIV(dev);
528	sprintf(dev->name, "atm%d", number);
529	spin_lock_init(&clip_priv->xoff_lock);
530	clip_priv->number = number;
531	error = register_netdev(dev);
532	if (error) {
533		free_netdev(dev);
534		return error;
535	}
536	clip_priv->next = clip_devs;
537	clip_devs = dev;
538	pr_debug("registered (net:%s)\n", dev->name);
539	return number;
540}
541
542static int clip_device_event(struct notifier_block *this, unsigned long event,
543			     void *ptr)
544{
545	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
546
547	if (!net_eq(dev_net(dev), &init_net))
548		return NOTIFY_DONE;
549
550	if (event == NETDEV_UNREGISTER)
551		return NOTIFY_DONE;
552
553	/* ignore non-CLIP devices */
554	if (dev->type != ARPHRD_ATM || dev->netdev_ops != &clip_netdev_ops)
555		return NOTIFY_DONE;
556
557	switch (event) {
558	case NETDEV_UP:
559		pr_debug("NETDEV_UP\n");
560		to_atmarpd(act_up, PRIV(dev)->number, 0);
561		break;
562	case NETDEV_GOING_DOWN:
563		pr_debug("NETDEV_DOWN\n");
564		to_atmarpd(act_down, PRIV(dev)->number, 0);
565		break;
566	case NETDEV_CHANGE:
567	case NETDEV_CHANGEMTU:
568		pr_debug("NETDEV_CHANGE*\n");
569		to_atmarpd(act_change, PRIV(dev)->number, 0);
570		break;
571	}
572	return NOTIFY_DONE;
573}
574
575static int clip_inet_event(struct notifier_block *this, unsigned long event,
576			   void *ifa)
577{
578	struct in_device *in_dev;
579	struct netdev_notifier_info info;
580
581	in_dev = ((struct in_ifaddr *)ifa)->ifa_dev;
582	/*
583	 * Transitions are of the down-change-up type, so it's sufficient to
584	 * handle the change on up.
585	 */
586	if (event != NETDEV_UP)
587		return NOTIFY_DONE;
588	netdev_notifier_info_init(&info, in_dev->dev);
589	return clip_device_event(this, NETDEV_CHANGE, &info);
590}
591
592static struct notifier_block clip_dev_notifier = {
593	.notifier_call = clip_device_event,
594};
595
596
597
598static struct notifier_block clip_inet_notifier = {
599	.notifier_call = clip_inet_event,
600};
601
602
603
604static void atmarpd_close(struct atm_vcc *vcc)
605{
606	pr_debug("\n");
607
608	rtnl_lock();
609	atmarpd = NULL;
610	skb_queue_purge(&sk_atm(vcc)->sk_receive_queue);
611	rtnl_unlock();
612
613	pr_debug("(done)\n");
614	module_put(THIS_MODULE);
615}
616
617static struct atmdev_ops atmarpd_dev_ops = {
618	.close = atmarpd_close
619};
620
621
622static struct atm_dev atmarpd_dev = {
623	.ops =			&atmarpd_dev_ops,
624	.type =			"arpd",
625	.number = 		999,
626	.lock =			__SPIN_LOCK_UNLOCKED(atmarpd_dev.lock)
627};
628
629
630static int atm_init_atmarp(struct atm_vcc *vcc)
631{
632	rtnl_lock();
633	if (atmarpd) {
634		rtnl_unlock();
635		return -EADDRINUSE;
636	}
637
638	mod_timer(&idle_timer, jiffies + CLIP_CHECK_INTERVAL * HZ);
639
640	atmarpd = vcc;
641	set_bit(ATM_VF_META, &vcc->flags);
642	set_bit(ATM_VF_READY, &vcc->flags);
643	    /* allow replies and avoid getting closed if signaling dies */
644	vcc->dev = &atmarpd_dev;
645	vcc_insert_socket(sk_atm(vcc));
646	vcc->push = NULL;
647	vcc->pop = NULL; /* crash */
648	vcc->push_oam = NULL; /* crash */
649	rtnl_unlock();
650	return 0;
651}
652
653static int clip_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
654{
655	struct atm_vcc *vcc = ATM_SD(sock);
656	int err = 0;
657
658	switch (cmd) {
659	case SIOCMKCLIP:
660	case ATMARPD_CTRL:
661	case ATMARP_MKIP:
662	case ATMARP_SETENTRY:
663	case ATMARP_ENCAP:
664		if (!capable(CAP_NET_ADMIN))
665			return -EPERM;
666		break;
667	default:
668		return -ENOIOCTLCMD;
669	}
670
671	switch (cmd) {
672	case SIOCMKCLIP:
673		err = clip_create(arg);
674		break;
675	case ATMARPD_CTRL:
676		err = atm_init_atmarp(vcc);
677		if (!err) {
678			sock->state = SS_CONNECTED;
679			__module_get(THIS_MODULE);
680		}
681		break;
682	case ATMARP_MKIP:
683		err = clip_mkip(vcc, arg);
684		break;
685	case ATMARP_SETENTRY:
686		err = clip_setentry(vcc, (__force __be32)arg);
687		break;
688	case ATMARP_ENCAP:
689		err = clip_encap(vcc, arg);
690		break;
691	}
692	return err;
693}
694
695static struct atm_ioctl clip_ioctl_ops = {
696	.owner = THIS_MODULE,
697	.ioctl = clip_ioctl,
698};
699
700#ifdef CONFIG_PROC_FS
701
702static void svc_addr(struct seq_file *seq, struct sockaddr_atmsvc *addr)
703{
704	static int code[] = { 1, 2, 10, 6, 1, 0 };
705	static int e164[] = { 1, 8, 4, 6, 1, 0 };
706
707	if (*addr->sas_addr.pub) {
708		seq_printf(seq, "%s", addr->sas_addr.pub);
709		if (*addr->sas_addr.prv)
710			seq_putc(seq, '+');
711	} else if (!*addr->sas_addr.prv) {
712		seq_printf(seq, "%s", "(none)");
713		return;
714	}
715	if (*addr->sas_addr.prv) {
716		unsigned char *prv = addr->sas_addr.prv;
717		int *fields;
718		int i, j;
719
720		fields = *prv == ATM_AFI_E164 ? e164 : code;
721		for (i = 0; fields[i]; i++) {
722			for (j = fields[i]; j; j--)
723				seq_printf(seq, "%02X", *prv++);
724			if (fields[i + 1])
725				seq_putc(seq, '.');
726		}
727	}
728}
729
730/* This means the neighbour entry has no attached VCC objects. */
731#define SEQ_NO_VCC_TOKEN	((void *) 2)
732
733static void atmarp_info(struct seq_file *seq, struct neighbour *n,
734			struct atmarp_entry *entry, struct clip_vcc *clip_vcc)
735{
736	struct net_device *dev = n->dev;
737	unsigned long exp;
738	char buf[17];
739	int svc, llc, off;
740
741	svc = ((clip_vcc == SEQ_NO_VCC_TOKEN) ||
742	       (sk_atm(clip_vcc->vcc)->sk_family == AF_ATMSVC));
743
744	llc = ((clip_vcc == SEQ_NO_VCC_TOKEN) || clip_vcc->encap);
745
746	if (clip_vcc == SEQ_NO_VCC_TOKEN)
747		exp = entry->neigh->used;
748	else
749		exp = clip_vcc->last_use;
750
751	exp = (jiffies - exp) / HZ;
752
753	seq_printf(seq, "%-6s%-4s%-4s%5ld ",
754		   dev->name, svc ? "SVC" : "PVC", llc ? "LLC" : "NULL", exp);
755
756	off = scnprintf(buf, sizeof(buf) - 1, "%pI4", n->primary_key);
757	while (off < 16)
758		buf[off++] = ' ';
759	buf[off] = '\0';
760	seq_printf(seq, "%s", buf);
761
762	if (clip_vcc == SEQ_NO_VCC_TOKEN) {
763		if (time_before(jiffies, entry->expires))
764			seq_printf(seq, "(resolving)\n");
765		else
766			seq_printf(seq, "(expired, ref %d)\n",
767				   atomic_read(&entry->neigh->refcnt));
768	} else if (!svc) {
769		seq_printf(seq, "%d.%d.%d\n",
770			   clip_vcc->vcc->dev->number,
771			   clip_vcc->vcc->vpi, clip_vcc->vcc->vci);
772	} else {
773		svc_addr(seq, &clip_vcc->vcc->remote);
774		seq_putc(seq, '\n');
775	}
776}
777
778struct clip_seq_state {
779	/* This member must be first. */
780	struct neigh_seq_state ns;
781
782	/* Local to clip specific iteration. */
783	struct clip_vcc *vcc;
784};
785
786static struct clip_vcc *clip_seq_next_vcc(struct atmarp_entry *e,
787					  struct clip_vcc *curr)
788{
789	if (!curr) {
790		curr = e->vccs;
791		if (!curr)
792			return SEQ_NO_VCC_TOKEN;
793		return curr;
794	}
795	if (curr == SEQ_NO_VCC_TOKEN)
796		return NULL;
797
798	curr = curr->next;
799
800	return curr;
801}
802
803static void *clip_seq_vcc_walk(struct clip_seq_state *state,
804			       struct atmarp_entry *e, loff_t * pos)
805{
806	struct clip_vcc *vcc = state->vcc;
807
808	vcc = clip_seq_next_vcc(e, vcc);
809	if (vcc && pos != NULL) {
810		while (*pos) {
811			vcc = clip_seq_next_vcc(e, vcc);
812			if (!vcc)
813				break;
814			--(*pos);
815		}
816	}
817	state->vcc = vcc;
818
819	return vcc;
820}
821
822static void *clip_seq_sub_iter(struct neigh_seq_state *_state,
823			       struct neighbour *n, loff_t * pos)
824{
825	struct clip_seq_state *state = (struct clip_seq_state *)_state;
826
827	if (n->dev->type != ARPHRD_ATM)
828		return NULL;
829
830	return clip_seq_vcc_walk(state, neighbour_priv(n), pos);
831}
832
833static void *clip_seq_start(struct seq_file *seq, loff_t * pos)
834{
835	struct clip_seq_state *state = seq->private;
836	state->ns.neigh_sub_iter = clip_seq_sub_iter;
837	return neigh_seq_start(seq, pos, &arp_tbl, NEIGH_SEQ_NEIGH_ONLY);
838}
839
840static int clip_seq_show(struct seq_file *seq, void *v)
841{
842	static char atm_arp_banner[] =
843	    "IPitf TypeEncp Idle IP address      ATM address\n";
844
845	if (v == SEQ_START_TOKEN) {
846		seq_puts(seq, atm_arp_banner);
847	} else {
848		struct clip_seq_state *state = seq->private;
849		struct clip_vcc *vcc = state->vcc;
850		struct neighbour *n = v;
851
852		atmarp_info(seq, n, neighbour_priv(n), vcc);
853	}
854	return 0;
855}
856
857static const struct seq_operations arp_seq_ops = {
858	.start	= clip_seq_start,
859	.next	= neigh_seq_next,
860	.stop	= neigh_seq_stop,
861	.show	= clip_seq_show,
862};
863
864static int arp_seq_open(struct inode *inode, struct file *file)
865{
866	return seq_open_net(inode, file, &arp_seq_ops,
867			    sizeof(struct clip_seq_state));
868}
869
870static const struct file_operations arp_seq_fops = {
871	.open		= arp_seq_open,
872	.read		= seq_read,
873	.llseek		= seq_lseek,
874	.release	= seq_release_net,
875	.owner		= THIS_MODULE
876};
877#endif
878
879static void atm_clip_exit_noproc(void);
880
881static int __init atm_clip_init(void)
882{
883	register_atm_ioctl(&clip_ioctl_ops);
884	register_netdevice_notifier(&clip_dev_notifier);
885	register_inetaddr_notifier(&clip_inet_notifier);
886
887	setup_timer(&idle_timer, idle_timer_check, 0);
888
889#ifdef CONFIG_PROC_FS
890	{
891		struct proc_dir_entry *p;
892
893		p = proc_create("arp", S_IRUGO, atm_proc_root, &arp_seq_fops);
894		if (!p) {
895			pr_err("Unable to initialize /proc/net/atm/arp\n");
896			atm_clip_exit_noproc();
897			return -ENOMEM;
898		}
899	}
900#endif
901
902	return 0;
903}
904
905static void atm_clip_exit_noproc(void)
906{
907	struct net_device *dev, *next;
908
909	unregister_inetaddr_notifier(&clip_inet_notifier);
910	unregister_netdevice_notifier(&clip_dev_notifier);
911
912	deregister_atm_ioctl(&clip_ioctl_ops);
913
914	/* First, stop the idle timer, so it stops banging
915	 * on the table.
916	 */
917	del_timer_sync(&idle_timer);
918
919	dev = clip_devs;
920	while (dev) {
921		next = PRIV(dev)->next;
922		unregister_netdev(dev);
923		free_netdev(dev);
924		dev = next;
925	}
926}
927
928static void __exit atm_clip_exit(void)
929{
930	remove_proc_entry("arp", atm_proc_root);
931
932	atm_clip_exit_noproc();
933}
934
935module_init(atm_clip_init);
936module_exit(atm_clip_exit);
937MODULE_AUTHOR("Werner Almesberger");
938MODULE_DESCRIPTION("Classical/IP over ATM interface");
939MODULE_LICENSE("GPL");
940