clip.c 24.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/* net/atm/clip.c - RFC1577 Classical IP over ATM */

/* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */

#include <linux/string.h>
#include <linux/errno.h>
#include <linux/kernel.h> /* for UINT_MAX */
#include <linux/module.h>
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/wait.h>
#include <linux/timer.h>
#include <linux/if_arp.h> /* for some manifest constants */
#include <linux/notifier.h>
#include <linux/atm.h>
#include <linux/atmdev.h>
#include <linux/atmclip.h>
#include <linux/atmarp.h>
20
#include <linux/capability.h>
L
Linus Torvalds 已提交
21 22 23 24 25
#include <linux/ip.h> /* for net/route.h */
#include <linux/in.h> /* for struct sockaddr_in */
#include <linux/if.h> /* for IFF_UP */
#include <linux/inetdevice.h>
#include <linux/bitops.h>
R
Randy Dunlap 已提交
26
#include <linux/poison.h>
L
Linus Torvalds 已提交
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/rcupdate.h>
#include <linux/jhash.h>
#include <net/route.h> /* for struct rtable and routing */
#include <net/icmp.h> /* icmp_send */
#include <asm/param.h> /* for HZ */
#include <asm/byteorder.h> /* for htons etc. */
#include <asm/system.h> /* save/restore_flags */
#include <asm/uaccess.h>
#include <asm/atomic.h>

#include "common.h"
#include "resources.h"
#include <net/atmclip.h>

static struct net_device *clip_devs;
static struct atm_vcc *atmarpd;
static struct neigh_table clip_tbl;
static struct timer_list idle_timer;

A
Al Viro 已提交
48
static int to_atmarpd(enum atmarp_ctrl_type type, int itf, __be32 ip)
L
Linus Torvalds 已提交
49 50 51 52 53
{
	struct sock *sk;
	struct atmarp_ctrl *ctrl;
	struct sk_buff *skb;

54
	pr_debug("to_atmarpd(%d)\n", type);
55 56
	if (!atmarpd)
		return -EUNATCH;
L
Linus Torvalds 已提交
57
	skb = alloc_skb(sizeof(struct atmarp_ctrl),GFP_ATOMIC);
58 59
	if (!skb)
		return -ENOMEM;
L
Linus Torvalds 已提交
60 61 62 63
	ctrl = (struct atmarp_ctrl *) skb_put(skb,sizeof(struct atmarp_ctrl));
	ctrl->type = type;
	ctrl->itf_num = itf;
	ctrl->ip = ip;
64
	atm_force_charge(atmarpd, skb->truesize);
L
Linus Torvalds 已提交
65 66 67 68 69 70 71

	sk = sk_atm(atmarpd);
	skb_queue_tail(&sk->sk_receive_queue, skb);
	sk->sk_data_ready(sk, skb->len);
	return 0;
}

72
static void link_vcc(struct clip_vcc *clip_vcc, struct atmarp_entry *entry)
L
Linus Torvalds 已提交
73
{
74
	pr_debug("link_vcc %p to entry %p (neigh %p)\n", clip_vcc, entry,
75
		entry->neigh);
L
Linus Torvalds 已提交
76
	clip_vcc->entry = entry;
77
	clip_vcc->xoff = 0;	/* @@@ may overrun buffer by one packet */
L
Linus Torvalds 已提交
78 79 80 81 82 83 84 85 86 87 88
	clip_vcc->next = entry->vccs;
	entry->vccs = clip_vcc;
	entry->neigh->used = jiffies;
}

static void unlink_clip_vcc(struct clip_vcc *clip_vcc)
{
	struct atmarp_entry *entry = clip_vcc->entry;
	struct clip_vcc **walk;

	if (!entry) {
89
		printk(KERN_CRIT "!clip_vcc->entry (clip_vcc %p)\n", clip_vcc);
L
Linus Torvalds 已提交
90 91
		return;
	}
H
Herbert Xu 已提交
92
	netif_tx_lock_bh(entry->neigh->dev);	/* block clip_start_xmit() */
L
Linus Torvalds 已提交
93 94 95 96 97
	entry->neigh->used = jiffies;
	for (walk = &entry->vccs; *walk; walk = &(*walk)->next)
		if (*walk == clip_vcc) {
			int error;

98
			*walk = clip_vcc->next;	/* atomic */
L
Linus Torvalds 已提交
99 100 101 102 103
			clip_vcc->entry = NULL;
			if (clip_vcc->xoff)
				netif_wake_queue(entry->neigh->dev);
			if (entry->vccs)
				goto out;
104 105
			entry->expires = jiffies - 1;
			/* force resolution or expiration */
L
Linus Torvalds 已提交
106 107 108 109
			error = neigh_update(entry->neigh, NULL, NUD_NONE,
					     NEIGH_UPDATE_F_ADMIN);
			if (error)
				printk(KERN_CRIT "unlink_clip_vcc: "
110
				       "neigh_update failed with %d\n", error);
L
Linus Torvalds 已提交
111 112 113
			goto out;
		}
	printk(KERN_CRIT "ATMARP: unlink_clip_vcc failed (entry %p, vcc "
114 115
	       "0x%p)\n", entry, clip_vcc);
      out:
H
Herbert Xu 已提交
116
	netif_tx_unlock_bh(entry->neigh->dev);
L
Linus Torvalds 已提交
117 118 119 120 121 122 123 124 125 126 127 128
}

/* The neighbour entry n->lock is held. */
static int neigh_check_cb(struct neighbour *n)
{
	struct atmarp_entry *entry = NEIGH2ENTRY(n);
	struct clip_vcc *cv;

	for (cv = entry->vccs; cv; cv = cv->next) {
		unsigned long exp = cv->last_use + cv->idle_timeout;

		if (cv->idle_timeout && time_after(jiffies, exp)) {
129
			pr_debug("releasing vcc %p->%p of entry %p\n",
L
Linus Torvalds 已提交
130 131 132 133 134 135 136 137 138 139 140
				cv, cv->vcc, entry);
			vcc_release_async(cv->vcc, -ETIMEDOUT);
		}
	}

	if (entry->vccs || time_before(jiffies, entry->expires))
		return 0;

	if (atomic_read(&n->refcnt) > 1) {
		struct sk_buff *skb;

141
		pr_debug("destruction postponed with ref %d\n",
L
Linus Torvalds 已提交
142 143
			atomic_read(&n->refcnt));

144
		while ((skb = skb_dequeue(&n->arp_queue)) != NULL)
L
Linus Torvalds 已提交
145 146 147 148 149
			dev_kfree_skb(skb);

		return 0;
	}

150
	pr_debug("expired neigh %p\n", n);
L
Linus Torvalds 已提交
151 152 153 154 155 156 157
	return 1;
}

static void idle_timer_check(unsigned long dummy)
{
	write_lock(&clip_tbl.lock);
	__neigh_for_each_release(&clip_tbl, neigh_check_cb);
158
	mod_timer(&idle_timer, jiffies + CLIP_CHECK_INTERVAL * HZ);
L
Linus Torvalds 已提交
159 160 161 162 163 164 165
	write_unlock(&clip_tbl.lock);
}

static int clip_arp_rcv(struct sk_buff *skb)
{
	struct atm_vcc *vcc;

166
	pr_debug("clip_arp_rcv\n");
L
Linus Torvalds 已提交
167
	vcc = ATM_SKB(skb)->vcc;
168
	if (!vcc || !atm_charge(vcc, skb->truesize)) {
L
Linus Torvalds 已提交
169 170 171
		dev_kfree_skb_any(skb);
		return 0;
	}
172 173
	pr_debug("pushing to %p\n", vcc);
	pr_debug("using %p\n", CLIP_VCC(vcc)->old_push);
174
	CLIP_VCC(vcc)->old_push(vcc, skb);
L
Linus Torvalds 已提交
175 176 177 178 179 180 181 182 183
	return 0;
}

static const unsigned char llc_oui[] = {
	0xaa,	/* DSAP: non-ISO */
	0xaa,	/* SSAP: non-ISO */
	0x03,	/* Ctrl: Unnumbered Information Command PDU */
	0x00,	/* OUI: EtherType */
	0x00,
184 185
	0x00
};
L
Linus Torvalds 已提交
186

187
static void clip_push(struct atm_vcc *vcc, struct sk_buff *skb)
L
Linus Torvalds 已提交
188 189 190
{
	struct clip_vcc *clip_vcc = CLIP_VCC(vcc);

191
	pr_debug("clip push\n");
L
Linus Torvalds 已提交
192
	if (!skb) {
193
		pr_debug("removing VCC %p\n", clip_vcc);
194 195 196
		if (clip_vcc->entry)
			unlink_clip_vcc(clip_vcc);
		clip_vcc->old_push(vcc, NULL);	/* pass on the bad news */
L
Linus Torvalds 已提交
197 198 199
		kfree(clip_vcc);
		return;
	}
200
	atm_return(vcc, skb->truesize);
L
Linus Torvalds 已提交
201
	skb->dev = clip_vcc->entry ? clip_vcc->entry->neigh->dev : clip_devs;
202
	/* clip_vcc->entry == NULL if we don't have an IP address yet */
L
Linus Torvalds 已提交
203 204 205 206 207
	if (!skb->dev) {
		dev_kfree_skb_any(skb);
		return;
	}
	ATM_SKB(skb)->vcc = vcc;
208
	skb_reset_mac_header(skb);
209 210 211 212
	if (!clip_vcc->encap
	    || skb->len < RFC1483LLC_LEN
	    || memcmp(skb->data, llc_oui, sizeof (llc_oui)))
		skb->protocol = htons(ETH_P_IP);
L
Linus Torvalds 已提交
213
	else {
A
Al Viro 已提交
214
		skb->protocol = ((__be16 *) skb->data)[3];
215
		skb_pull(skb, RFC1483LLC_LEN);
L
Linus Torvalds 已提交
216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
		if (skb->protocol == htons(ETH_P_ARP)) {
			PRIV(skb->dev)->stats.rx_packets++;
			PRIV(skb->dev)->stats.rx_bytes += skb->len;
			clip_arp_rcv(skb);
			return;
		}
	}
	clip_vcc->last_use = jiffies;
	PRIV(skb->dev)->stats.rx_packets++;
	PRIV(skb->dev)->stats.rx_bytes += skb->len;
	memset(ATM_SKB(skb), 0, sizeof(struct atm_skb_data));
	netif_rx(skb);
}

/*
 * Note: these spinlocks _must_not_ block on non-SMP. The only goal is that
 * clip_pop is atomic with respect to the critical section in clip_start_xmit.
 */

235
static void clip_pop(struct atm_vcc *vcc, struct sk_buff *skb)
L
Linus Torvalds 已提交
236 237 238 239 240 241
{
	struct clip_vcc *clip_vcc = CLIP_VCC(vcc);
	struct net_device *dev = skb->dev;
	int old;
	unsigned long flags;

242
	pr_debug("clip_pop(vcc %p)\n", vcc);
243
	clip_vcc->old_pop(vcc, skb);
L
Linus Torvalds 已提交
244
	/* skb->dev == NULL in outbound ARP packets */
245 246 247 248 249 250 251
	if (!dev)
		return;
	spin_lock_irqsave(&PRIV(dev)->xoff_lock, flags);
	if (atm_may_send(vcc, 0)) {
		old = xchg(&clip_vcc->xoff, 0);
		if (old)
			netif_wake_queue(dev);
L
Linus Torvalds 已提交
252
	}
253
	spin_unlock_irqrestore(&PRIV(dev)->xoff_lock, flags);
L
Linus Torvalds 已提交
254 255
}

256
static void clip_neigh_solicit(struct neighbour *neigh, struct sk_buff *skb)
L
Linus Torvalds 已提交
257
{
258
	pr_debug("clip_neigh_solicit (neigh %p, skb %p)\n", neigh, skb);
259
	to_atmarpd(act_need, PRIV(neigh->dev)->number, NEIGH2ENTRY(neigh)->ip);
L
Linus Torvalds 已提交
260 261
}

262
static void clip_neigh_error(struct neighbour *neigh, struct sk_buff *skb)
L
Linus Torvalds 已提交
263 264
{
#ifndef CONFIG_ATM_CLIP_NO_ICMP
265
	icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
L
Linus Torvalds 已提交
266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
#endif
	kfree_skb(skb);
}

static struct neigh_ops clip_neigh_ops = {
	.family =		AF_INET,
	.solicit =		clip_neigh_solicit,
	.error_report =		clip_neigh_error,
	.output =		dev_queue_xmit,
	.connected_output =	dev_queue_xmit,
	.hh_output =		dev_queue_xmit,
	.queue_xmit =		dev_queue_xmit,
};

static int clip_constructor(struct neighbour *neigh)
{
	struct atmarp_entry *entry = NEIGH2ENTRY(neigh);
	struct net_device *dev = neigh->dev;
	struct in_device *in_dev;
	struct neigh_parms *parms;

287
	pr_debug("clip_constructor (neigh %p, entry %p)\n", neigh, entry);
288
	neigh->type = inet_addr_type(&init_net, entry->ip);
289 290
	if (neigh->type != RTN_UNICAST)
		return -EINVAL;
L
Linus Torvalds 已提交
291 292

	rcu_read_lock();
293
	in_dev = __in_dev_get_rcu(dev);
L
Linus Torvalds 已提交
294 295 296 297 298 299 300 301 302 303 304 305 306 307 308
	if (!in_dev) {
		rcu_read_unlock();
		return -EINVAL;
	}

	parms = in_dev->arp_parms;
	__neigh_parms_put(neigh->parms);
	neigh->parms = neigh_parms_clone(parms);
	rcu_read_unlock();

	neigh->ops = &clip_neigh_ops;
	neigh->output = neigh->nud_state & NUD_VALID ?
	    neigh->ops->connected_output : neigh->ops->output;
	entry->neigh = neigh;
	entry->vccs = NULL;
309
	entry->expires = jiffies - 1;
L
Linus Torvalds 已提交
310 311 312 313 314
	return 0;
}

static u32 clip_hash(const void *pkey, const struct net_device *dev)
{
315
	return jhash_2words(*(u32 *) pkey, dev->ifindex, clip_tbl.hash_rnd);
L
Linus Torvalds 已提交
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356
}

static struct neigh_table clip_tbl = {
	.family 	= AF_INET,
	.entry_size 	= sizeof(struct neighbour)+sizeof(struct atmarp_entry),
	.key_len 	= 4,
	.hash 		= clip_hash,
	.constructor 	= clip_constructor,
	.id 		= "clip_arp_cache",

	/* parameters are copied from ARP ... */
	.parms = {
		.tbl 			= &clip_tbl,
		.base_reachable_time 	= 30 * HZ,
		.retrans_time 		= 1 * HZ,
		.gc_staletime 		= 60 * HZ,
		.reachable_time 	= 30 * HZ,
		.delay_probe_time 	= 5 * HZ,
		.queue_len 		= 3,
		.ucast_probes 		= 3,
		.mcast_probes 		= 3,
		.anycast_delay 		= 1 * HZ,
		.proxy_delay 		= (8 * HZ) / 10,
		.proxy_qlen 		= 64,
		.locktime 		= 1 * HZ,
	},
	.gc_interval 	= 30 * HZ,
	.gc_thresh1 	= 128,
	.gc_thresh2 	= 512,
	.gc_thresh3 	= 1024,
};

/* @@@ copy bh locking from arp.c -- need to bh-enable atm code before */

/*
 * We play with the resolve flag: 0 and 1 have the usual meaning, but -1 means
 * to allocate the neighbour entry but not to ask atmarpd for resolution. Also,
 * don't increment the usage count. This is used to create entries in
 * clip_setentry.
 */

357
static int clip_encap(struct atm_vcc *vcc, int mode)
L
Linus Torvalds 已提交
358 359 360 361 362
{
	CLIP_VCC(vcc)->encap = mode;
	return 0;
}

363
static int clip_start_xmit(struct sk_buff *skb, struct net_device *dev)
L
Linus Torvalds 已提交
364 365 366 367 368 369 370
{
	struct clip_priv *clip_priv = PRIV(dev);
	struct atmarp_entry *entry;
	struct atm_vcc *vcc;
	int old;
	unsigned long flags;

371
	pr_debug("clip_start_xmit (skb %p)\n", skb);
L
Linus Torvalds 已提交
372 373 374 375 376 377 378 379
	if (!skb->dst) {
		printk(KERN_ERR "clip_start_xmit: skb->dst == NULL\n");
		dev_kfree_skb(skb);
		clip_priv->stats.tx_dropped++;
		return 0;
	}
	if (!skb->dst->neighbour) {
#if 0
380
		skb->dst->neighbour = clip_find_neighbour(skb->dst, 1);
L
Linus Torvalds 已提交
381
		if (!skb->dst->neighbour) {
382
			dev_kfree_skb(skb);	/* lost that one */
L
Linus Torvalds 已提交
383 384 385 386 387 388 389 390 391 392 393 394 395
			clip_priv->stats.tx_dropped++;
			return 0;
		}
#endif
		printk(KERN_ERR "clip_start_xmit: NO NEIGHBOUR !\n");
		dev_kfree_skb(skb);
		clip_priv->stats.tx_dropped++;
		return 0;
	}
	entry = NEIGH2ENTRY(skb->dst->neighbour);
	if (!entry->vccs) {
		if (time_after(jiffies, entry->expires)) {
			/* should be resolved */
396 397
			entry->expires = jiffies + ATMARP_RETRY_DELAY * HZ;
			to_atmarpd(act_need, PRIV(dev)->number, entry->ip);
L
Linus Torvalds 已提交
398 399
		}
		if (entry->neigh->arp_queue.qlen < ATMARP_MAX_UNRES_PACKETS)
400
			skb_queue_tail(&entry->neigh->arp_queue, skb);
L
Linus Torvalds 已提交
401 402 403 404 405 406
		else {
			dev_kfree_skb(skb);
			clip_priv->stats.tx_dropped++;
		}
		return 0;
	}
407
	pr_debug("neigh %p, vccs %p\n", entry, entry->vccs);
L
Linus Torvalds 已提交
408
	ATM_SKB(skb)->vcc = vcc = entry->vccs->vcc;
409
	pr_debug("using neighbour %p, vcc %p\n", skb->dst->neighbour, vcc);
L
Linus Torvalds 已提交
410 411 412
	if (entry->vccs->encap) {
		void *here;

413 414
		here = skb_push(skb, RFC1483LLC_LEN);
		memcpy(here, llc_oui, sizeof(llc_oui));
A
Al Viro 已提交
415
		((__be16 *) here)[3] = skb->protocol;
L
Linus Torvalds 已提交
416 417 418 419
	}
	atomic_add(skb->truesize, &sk_atm(vcc)->sk_wmem_alloc);
	ATM_SKB(skb)->atm_options = vcc->atm_options;
	entry->vccs->last_use = jiffies;
420
	pr_debug("atm_skb(%p)->vcc(%p)->dev(%p)\n", skb, vcc, vcc->dev);
421
	old = xchg(&entry->vccs->xoff, 1);	/* assume XOFF ... */
L
Linus Torvalds 已提交
422 423 424 425 426 427
	if (old) {
		printk(KERN_WARNING "clip_start_xmit: XOFF->XOFF transition\n");
		return 0;
	}
	clip_priv->stats.tx_packets++;
	clip_priv->stats.tx_bytes += skb->len;
428
	vcc->send(vcc, skb);
429
	if (atm_may_send(vcc, 0)) {
L
Linus Torvalds 已提交
430 431 432
		entry->vccs->xoff = 0;
		return 0;
	}
433 434
	spin_lock_irqsave(&clip_priv->xoff_lock, flags);
	netif_stop_queue(dev);	/* XOFF -> throttle immediately */
L
Linus Torvalds 已提交
435 436 437
	barrier();
	if (!entry->vccs->xoff)
		netif_start_queue(dev);
438 439 440 441 442
	/* Oh, we just raced with clip_pop. netif_start_queue should be
	   good enough, because nothing should really be asleep because
	   of the brief netif_stop_queue. If this isn't true or if it
	   changes, use netif_wake_queue instead. */
	spin_unlock_irqrestore(&clip_priv->xoff_lock, flags);
L
Linus Torvalds 已提交
443 444 445 446 447 448 449 450
	return 0;
}

static struct net_device_stats *clip_get_stats(struct net_device *dev)
{
	return &PRIV(dev)->stats;
}

451
static int clip_mkip(struct atm_vcc *vcc, int timeout)
L
Linus Torvalds 已提交
452 453 454
{
	struct clip_vcc *clip_vcc;
	struct sk_buff *skb;
D
David S. Miller 已提交
455 456
	struct sk_buff_head *rq;
	unsigned long flags;
L
Linus Torvalds 已提交
457

458 459 460 461 462
	if (!vcc->push)
		return -EBADFD;
	clip_vcc = kmalloc(sizeof(struct clip_vcc), GFP_KERNEL);
	if (!clip_vcc)
		return -ENOMEM;
463
	pr_debug("mkip clip_vcc %p vcc %p\n", clip_vcc, vcc);
L
Linus Torvalds 已提交
464 465 466 467 468 469 470
	clip_vcc->vcc = vcc;
	vcc->user_back = clip_vcc;
	set_bit(ATM_VF_IS_CLIP, &vcc->flags);
	clip_vcc->entry = NULL;
	clip_vcc->xoff = 0;
	clip_vcc->encap = 1;
	clip_vcc->last_use = jiffies;
471
	clip_vcc->idle_timeout = timeout * HZ;
L
Linus Torvalds 已提交
472 473 474 475
	clip_vcc->old_push = vcc->push;
	clip_vcc->old_pop = vcc->pop;
	vcc->push = clip_push;
	vcc->pop = clip_pop;
D
David S. Miller 已提交
476 477 478 479 480 481 482 483 484 485 486 487 488 489 490

	rq = &sk_atm(vcc)->sk_receive_queue;

	spin_lock_irqsave(&rq->lock, flags);
	if (skb_queue_empty(rq)) {
		skb = NULL;
	} else {
		/* NULL terminate the list.  */
		rq->prev->next = NULL;
		skb = rq->next;
	}
	rq->prev = rq->next = (struct sk_buff *)rq;
	rq->qlen = 0;
	spin_unlock_irqrestore(&rq->lock, flags);

L
Linus Torvalds 已提交
491
	/* re-process everything received between connection setup and MKIP */
D
David S. Miller 已提交
492 493 494 495
	while (skb) {
		struct sk_buff *next = skb->next;

		skb->next = skb->prev = NULL;
L
Linus Torvalds 已提交
496
		if (!clip_devs) {
497
			atm_return(vcc, skb->truesize);
L
Linus Torvalds 已提交
498
			kfree_skb(skb);
499
		} else {
L
Linus Torvalds 已提交
500 501
			unsigned int len = skb->len;

502
			skb_get(skb);
503
			clip_push(vcc, skb);
L
Linus Torvalds 已提交
504 505
			PRIV(skb->dev)->stats.rx_packets--;
			PRIV(skb->dev)->stats.rx_bytes -= len;
506
			kfree_skb(skb);
L
Linus Torvalds 已提交
507
		}
D
David S. Miller 已提交
508 509 510

		skb = next;
	}
L
Linus Torvalds 已提交
511 512 513
	return 0;
}

A
Al Viro 已提交
514
static int clip_setentry(struct atm_vcc *vcc, __be32 ip)
L
Linus Torvalds 已提交
515 516 517 518 519
{
	struct neighbour *neigh;
	struct atmarp_entry *entry;
	int error;
	struct clip_vcc *clip_vcc;
520
	struct flowi fl = { .nl_u = { .ip4_u = { .daddr = ip, .tos = 1}} };
L
Linus Torvalds 已提交
521 522 523 524 525 526 527 528 529 530 531 532
	struct rtable *rt;

	if (vcc->push != clip_push) {
		printk(KERN_WARNING "clip_setentry: non-CLIP VCC\n");
		return -EBADF;
	}
	clip_vcc = CLIP_VCC(vcc);
	if (!ip) {
		if (!clip_vcc->entry) {
			printk(KERN_ERR "hiding hidden ATMARP entry\n");
			return 0;
		}
533
		pr_debug("setentry: remove\n");
L
Linus Torvalds 已提交
534 535 536
		unlink_clip_vcc(clip_vcc);
		return 0;
	}
537 538 539 540
	error = ip_route_output_key(&rt, &fl);
	if (error)
		return error;
	neigh = __neigh_lookup(&clip_tbl, &ip, rt->u.dst.dev, 1);
L
Linus Torvalds 已提交
541 542 543 544 545
	ip_rt_put(rt);
	if (!neigh)
		return -ENOMEM;
	entry = NEIGH2ENTRY(neigh);
	if (entry != clip_vcc->entry) {
546
		if (!clip_vcc->entry)
547
			pr_debug("setentry: add\n");
L
Linus Torvalds 已提交
548
		else {
549
			pr_debug("setentry: update\n");
L
Linus Torvalds 已提交
550 551
			unlink_clip_vcc(clip_vcc);
		}
552
		link_vcc(clip_vcc, entry);
L
Linus Torvalds 已提交
553
	}
554 555
	error = neigh_update(neigh, llc_oui, NUD_PERMANENT,
			     NEIGH_UPDATE_F_OVERRIDE | NEIGH_UPDATE_F_ADMIN);
L
Linus Torvalds 已提交
556 557 558 559 560 561 562 563 564 565 566 567
	neigh_release(neigh);
	return error;
}

static void clip_setup(struct net_device *dev)
{
	dev->hard_start_xmit = clip_start_xmit;
	/* sg_xmit ... */
	dev->get_stats = clip_get_stats;
	dev->type = ARPHRD_ATM;
	dev->hard_header_len = RFC1483LLC_LEN;
	dev->mtu = RFC1626_MTU;
568 569 570 571 572 573
	dev->tx_queue_len = 100;	/* "normal" queue (packets) */
	/* When using a "real" qdisc, the qdisc determines the queue */
	/* length. tx_queue_len is only used for the default case, */
	/* without any more elaborate queuing. 100 is a reasonable */
	/* compromise between decent burst-tolerance and protection */
	/* against memory hogs. */
L
Linus Torvalds 已提交
574 575 576 577 578 579 580 581 582 583
}

static int clip_create(int number)
{
	struct net_device *dev;
	struct clip_priv *clip_priv;
	int error;

	if (number != -1) {
		for (dev = clip_devs; dev; dev = PRIV(dev)->next)
584 585 586
			if (PRIV(dev)->number == number)
				return -EEXIST;
	} else {
L
Linus Torvalds 已提交
587 588 589
		number = 0;
		for (dev = clip_devs; dev; dev = PRIV(dev)->next)
			if (PRIV(dev)->number >= number)
590
				number = PRIV(dev)->number + 1;
L
Linus Torvalds 已提交
591 592 593 594 595
	}
	dev = alloc_netdev(sizeof(struct clip_priv), "", clip_setup);
	if (!dev)
		return -ENOMEM;
	clip_priv = PRIV(dev);
596
	sprintf(dev->name, "atm%d", number);
L
Linus Torvalds 已提交
597 598 599 600 601 602 603 604 605
	spin_lock_init(&clip_priv->xoff_lock);
	clip_priv->number = number;
	error = register_netdev(dev);
	if (error) {
		free_netdev(dev);
		return error;
	}
	clip_priv->next = clip_devs;
	clip_devs = dev;
606
	pr_debug("registered (net:%s)\n", dev->name);
L
Linus Torvalds 已提交
607 608 609
	return number;
}

610
static int clip_device_event(struct notifier_block *this, unsigned long event,
611
			     void *arg)
L
Linus Torvalds 已提交
612
{
613 614
	struct net_device *dev = arg;

615 616 617
	if (dev->nd_net != &init_net)
		return NOTIFY_DONE;

618 619 620 621 622
	if (event == NETDEV_UNREGISTER) {
		neigh_ifdown(&clip_tbl, dev);
		return NOTIFY_DONE;
	}

L
Linus Torvalds 已提交
623
	/* ignore non-CLIP devices */
624
	if (dev->type != ARPHRD_ATM || dev->hard_start_xmit != clip_start_xmit)
L
Linus Torvalds 已提交
625
		return NOTIFY_DONE;
626

L
Linus Torvalds 已提交
627
	switch (event) {
628
	case NETDEV_UP:
629
		pr_debug("clip_device_event NETDEV_UP\n");
630
		to_atmarpd(act_up, PRIV(dev)->number, 0);
631 632
		break;
	case NETDEV_GOING_DOWN:
633
		pr_debug("clip_device_event NETDEV_DOWN\n");
634
		to_atmarpd(act_down, PRIV(dev)->number, 0);
635 636 637
		break;
	case NETDEV_CHANGE:
	case NETDEV_CHANGEMTU:
638
		pr_debug("clip_device_event NETDEV_CHANGE*\n");
639
		to_atmarpd(act_change, PRIV(dev)->number, 0);
640
		break;
L
Linus Torvalds 已提交
641 642 643 644
	}
	return NOTIFY_DONE;
}

645 646
static int clip_inet_event(struct notifier_block *this, unsigned long event,
			   void *ifa)
L
Linus Torvalds 已提交
647 648 649
{
	struct in_device *in_dev;

650
	in_dev = ((struct in_ifaddr *)ifa)->ifa_dev;
L
Linus Torvalds 已提交
651 652 653 654 655 656 657 658
	if (!in_dev || !in_dev->dev) {
		printk(KERN_WARNING "clip_inet_event: no device\n");
		return NOTIFY_DONE;
	}
	/*
	 * Transitions are of the down-change-up type, so it's sufficient to
	 * handle the change on up.
	 */
659 660 661
	if (event != NETDEV_UP)
		return NOTIFY_DONE;
	return clip_device_event(this, NETDEV_CHANGE, in_dev->dev);
L
Linus Torvalds 已提交
662 663 664 665
}


static struct notifier_block clip_dev_notifier = {
666
	.notifier_call = clip_device_event,
L
Linus Torvalds 已提交
667 668 669 670 671
};



static struct notifier_block clip_inet_notifier = {
672
	.notifier_call = clip_inet_event,
L
Linus Torvalds 已提交
673 674 675 676 677 678
};



static void atmarpd_close(struct atm_vcc *vcc)
{
679
	pr_debug("atmarpd_close\n");
680 681 682

	rtnl_lock();
	atmarpd = NULL;
L
Linus Torvalds 已提交
683
	skb_queue_purge(&sk_atm(vcc)->sk_receive_queue);
684 685
	rtnl_unlock();

686
	pr_debug("(done)\n");
L
Linus Torvalds 已提交
687 688 689 690 691 692 693 694 695 696 697 698 699
	module_put(THIS_MODULE);
}


static struct atmdev_ops atmarpd_dev_ops = {
	.close = atmarpd_close
};


static struct atm_dev atmarpd_dev = {
	.ops =			&atmarpd_dev_ops,
	.type =			"arpd",
	.number = 		999,
700
	.lock =			__SPIN_LOCK_UNLOCKED(atmarpd_dev.lock)
L
Linus Torvalds 已提交
701 702 703 704 705
};


static int atm_init_atmarp(struct atm_vcc *vcc)
{
706 707 708 709 710 711
	rtnl_lock();
	if (atmarpd) {
		rtnl_unlock();
		return -EADDRINUSE;
	}

S
Stephen Hemminger 已提交
712 713
	mod_timer(&idle_timer, jiffies+CLIP_CHECK_INTERVAL*HZ);

L
Linus Torvalds 已提交
714 715 716 717 718 719 720 721 722
	atmarpd = vcc;
	set_bit(ATM_VF_META,&vcc->flags);
	set_bit(ATM_VF_READY,&vcc->flags);
	    /* allow replies and avoid getting closed if signaling dies */
	vcc->dev = &atmarpd_dev;
	vcc_insert_socket(sk_atm(vcc));
	vcc->push = NULL;
	vcc->pop = NULL; /* crash */
	vcc->push_oam = NULL; /* crash */
723
	rtnl_unlock();
L
Linus Torvalds 已提交
724 725 726 727 728 729 730 731 732
	return 0;
}

static int clip_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{
	struct atm_vcc *vcc = ATM_SD(sock);
	int err = 0;

	switch (cmd) {
733 734 735 736 737 738 739 740 741 742
	case SIOCMKCLIP:
	case ATMARPD_CTRL:
	case ATMARP_MKIP:
	case ATMARP_SETENTRY:
	case ATMARP_ENCAP:
		if (!capable(CAP_NET_ADMIN))
			return -EPERM;
		break;
	default:
		return -ENOIOCTLCMD;
L
Linus Torvalds 已提交
743 744 745
	}

	switch (cmd) {
746 747 748 749 750 751 752 753 754 755 756 757 758 759
	case SIOCMKCLIP:
		err = clip_create(arg);
		break;
	case ATMARPD_CTRL:
		err = atm_init_atmarp(vcc);
		if (!err) {
			sock->state = SS_CONNECTED;
			__module_get(THIS_MODULE);
		}
		break;
	case ATMARP_MKIP:
		err = clip_mkip(vcc, arg);
		break;
	case ATMARP_SETENTRY:
A
Al Viro 已提交
760
		err = clip_setentry(vcc, (__force __be32)arg);
761 762 763 764
		break;
	case ATMARP_ENCAP:
		err = clip_encap(vcc, arg);
		break;
L
Linus Torvalds 已提交
765 766 767 768 769
	}
	return err;
}

static struct atm_ioctl clip_ioctl_ops = {
770 771
	.owner = THIS_MODULE,
	.ioctl = clip_ioctl,
L
Linus Torvalds 已提交
772 773 774 775 776 777
};

#ifdef CONFIG_PROC_FS

static void svc_addr(struct seq_file *seq, struct sockaddr_atmsvc *addr)
{
778 779
	static int code[] = { 1, 2, 10, 6, 1, 0 };
	static int e164[] = { 1, 8, 4, 6, 1, 0 };
L
Linus Torvalds 已提交
780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797

	if (*addr->sas_addr.pub) {
		seq_printf(seq, "%s", addr->sas_addr.pub);
		if (*addr->sas_addr.prv)
			seq_putc(seq, '+');
	} else if (!*addr->sas_addr.prv) {
		seq_printf(seq, "%s", "(none)");
		return;
	}
	if (*addr->sas_addr.prv) {
		unsigned char *prv = addr->sas_addr.prv;
		int *fields;
		int i, j;

		fields = *prv == ATM_AFI_E164 ? e164 : code;
		for (i = 0; fields[i]; i++) {
			for (j = fields[i]; j; j--)
				seq_printf(seq, "%02X", *prv++);
798
			if (fields[i + 1])
L
Linus Torvalds 已提交
799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816
				seq_putc(seq, '.');
		}
	}
}

/* This means the neighbour entry has no attached VCC objects. */
#define SEQ_NO_VCC_TOKEN	((void *) 2)

static void atmarp_info(struct seq_file *seq, struct net_device *dev,
			struct atmarp_entry *entry, struct clip_vcc *clip_vcc)
{
	unsigned long exp;
	char buf[17];
	int svc, llc, off;

	svc = ((clip_vcc == SEQ_NO_VCC_TOKEN) ||
	       (sk_atm(clip_vcc->vcc)->sk_family == AF_ATMSVC));

817
	llc = ((clip_vcc == SEQ_NO_VCC_TOKEN) || clip_vcc->encap);
L
Linus Torvalds 已提交
818 819 820 821 822 823 824 825 826

	if (clip_vcc == SEQ_NO_VCC_TOKEN)
		exp = entry->neigh->used;
	else
		exp = clip_vcc->last_use;

	exp = (jiffies - exp) / HZ;

	seq_printf(seq, "%-6s%-4s%-4s%5ld ",
827
		   dev->name, svc ? "SVC" : "PVC", llc ? "LLC" : "NULL", exp);
L
Linus Torvalds 已提交
828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844

	off = scnprintf(buf, sizeof(buf) - 1, "%d.%d.%d.%d",
			NIPQUAD(entry->ip));
	while (off < 16)
		buf[off++] = ' ';
	buf[off] = '\0';
	seq_printf(seq, "%s", buf);

	if (clip_vcc == SEQ_NO_VCC_TOKEN) {
		if (time_before(jiffies, entry->expires))
			seq_printf(seq, "(resolving)\n");
		else
			seq_printf(seq, "(expired, ref %d)\n",
				   atomic_read(&entry->neigh->refcnt));
	} else if (!svc) {
		seq_printf(seq, "%d.%d.%d\n",
			   clip_vcc->vcc->dev->number,
845
			   clip_vcc->vcc->vpi, clip_vcc->vcc->vci);
L
Linus Torvalds 已提交
846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877
	} else {
		svc_addr(seq, &clip_vcc->vcc->remote);
		seq_putc(seq, '\n');
	}
}

struct clip_seq_state {
	/* This member must be first. */
	struct neigh_seq_state ns;

	/* Local to clip specific iteration. */
	struct clip_vcc *vcc;
};

static struct clip_vcc *clip_seq_next_vcc(struct atmarp_entry *e,
					  struct clip_vcc *curr)
{
	if (!curr) {
		curr = e->vccs;
		if (!curr)
			return SEQ_NO_VCC_TOKEN;
		return curr;
	}
	if (curr == SEQ_NO_VCC_TOKEN)
		return NULL;

	curr = curr->next;

	return curr;
}

static void *clip_seq_vcc_walk(struct clip_seq_state *state,
878
			       struct atmarp_entry *e, loff_t * pos)
L
Linus Torvalds 已提交
879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894
{
	struct clip_vcc *vcc = state->vcc;

	vcc = clip_seq_next_vcc(e, vcc);
	if (vcc && pos != NULL) {
		while (*pos) {
			vcc = clip_seq_next_vcc(e, vcc);
			if (!vcc)
				break;
			--(*pos);
		}
	}
	state->vcc = vcc;

	return vcc;
}
895

L
Linus Torvalds 已提交
896
static void *clip_seq_sub_iter(struct neigh_seq_state *_state,
897
			       struct neighbour *n, loff_t * pos)
L
Linus Torvalds 已提交
898
{
899
	struct clip_seq_state *state = (struct clip_seq_state *)_state;
L
Linus Torvalds 已提交
900 901 902 903

	return clip_seq_vcc_walk(state, NEIGH2ENTRY(n), pos);
}

904
static void *clip_seq_start(struct seq_file *seq, loff_t * pos)
L
Linus Torvalds 已提交
905
{
906 907
	struct clip_seq_state *state = seq->private;
	state->ns.neigh_sub_iter = clip_seq_sub_iter;
L
Linus Torvalds 已提交
908 909 910 911 912
	return neigh_seq_start(seq, pos, &clip_tbl, NEIGH_SEQ_NEIGH_ONLY);
}

static int clip_seq_show(struct seq_file *seq, void *v)
{
913 914
	static char atm_arp_banner[] =
	    "IPitf TypeEncp Idle IP address      ATM address\n";
L
Linus Torvalds 已提交
915 916 917 918 919 920 921 922 923 924

	if (v == SEQ_START_TOKEN) {
		seq_puts(seq, atm_arp_banner);
	} else {
		struct clip_seq_state *state = seq->private;
		struct neighbour *n = v;
		struct clip_vcc *vcc = state->vcc;

		atmarp_info(seq, n->dev, NEIGH2ENTRY(n), vcc);
	}
925
	return 0;
L
Linus Torvalds 已提交
926 927
}

928
static const struct seq_operations arp_seq_ops = {
L
Linus Torvalds 已提交
929 930 931 932 933 934 935 936
	.start	= clip_seq_start,
	.next	= neigh_seq_next,
	.stop	= neigh_seq_stop,
	.show	= clip_seq_show,
};

static int arp_seq_open(struct inode *inode, struct file *file)
{
937 938
	return seq_open_net(inode, file, &arp_seq_ops,
			    sizeof(struct clip_seq_state));
939 940
}

941
static const struct file_operations arp_seq_fops = {
L
Linus Torvalds 已提交
942 943 944
	.open		= arp_seq_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
945
	.release	= seq_release_net,
L
Linus Torvalds 已提交
946 947 948 949 950 951
	.owner		= THIS_MODULE
};
#endif

static int __init atm_clip_init(void)
{
952
	neigh_table_init_no_netlink(&clip_tbl);
L
Linus Torvalds 已提交
953 954 955

	clip_tbl_hook = &clip_tbl;
	register_atm_ioctl(&clip_ioctl_ops);
956 957
	register_netdevice_notifier(&clip_dev_notifier);
	register_inetaddr_notifier(&clip_inet_notifier);
L
Linus Torvalds 已提交
958

S
Stephen Hemminger 已提交
959 960
	setup_timer(&idle_timer, idle_timer_check, 0);

961 962 963 964 965 966 967 968 969
#ifdef CONFIG_PROC_FS
	{
		struct proc_dir_entry *p;

		p = create_proc_entry("arp", S_IRUGO, atm_proc_root);
		if (p)
			p->proc_fops = &arp_seq_fops;
	}
#endif
L
Linus Torvalds 已提交
970 971 972 973 974 975 976 977 978 979

	return 0;
}

static void __exit atm_clip_exit(void)
{
	struct net_device *dev, *next;

	remove_proc_entry("arp", atm_proc_root);

980 981 982
	unregister_inetaddr_notifier(&clip_inet_notifier);
	unregister_netdevice_notifier(&clip_dev_notifier);

L
Linus Torvalds 已提交
983 984 985 986 987
	deregister_atm_ioctl(&clip_ioctl_ops);

	/* First, stop the idle timer, so it stops banging
	 * on the table.
	 */
S
Stephen Hemminger 已提交
988
	del_timer_sync(&idle_timer);
L
Linus Torvalds 已提交
989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011

	/* Next, purge the table, so that the device
	 * unregister loop below does not hang due to
	 * device references remaining in the table.
	 */
	neigh_ifdown(&clip_tbl, NULL);

	dev = clip_devs;
	while (dev) {
		next = PRIV(dev)->next;
		unregister_netdev(dev);
		free_netdev(dev);
		dev = next;
	}

	/* Now it is safe to fully shutdown whole table. */
	neigh_table_clear(&clip_tbl);

	clip_tbl_hook = NULL;
}

module_init(atm_clip_init);
module_exit(atm_clip_exit);
S
Stephen Hemminger 已提交
1012 1013
MODULE_AUTHOR("Werner Almesberger");
MODULE_DESCRIPTION("Classical/IP over ATM interface");
L
Linus Torvalds 已提交
1014
MODULE_LICENSE("GPL");