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