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 struct rtable *rt; 332 __be32 *daddr; 333 int old; 334 unsigned long flags; 335 336 pr_debug("(skb %p)\n", skb); 337 if (!dst) { 338 pr_err("skb_dst(skb) == NULL\n"); 339 dev_kfree_skb(skb); 340 dev->stats.tx_dropped++; 341 return NETDEV_TX_OK; 342 } 343 rt = (struct rtable *) dst; 344 if (rt->rt_gateway) 345 daddr = &rt->rt_gateway; 346 else 347 daddr = &ip_hdr(skb)->daddr; 348 n = dst_neigh_lookup(dst, daddr); 349 if (!n) { 350 pr_err("NO NEIGHBOUR !\n"); 351 dev_kfree_skb(skb); 352 dev->stats.tx_dropped++; 353 return NETDEV_TX_OK; 354 } 355 entry = neighbour_priv(n); 356 if (!entry->vccs) { 357 if (time_after(jiffies, entry->expires)) { 358 /* should be resolved */ 359 entry->expires = jiffies + ATMARP_RETRY_DELAY * HZ; 360 to_atmarpd(act_need, PRIV(dev)->number, *((__be32 *)n->primary_key)); 361 } 362 if (entry->neigh->arp_queue.qlen < ATMARP_MAX_UNRES_PACKETS) 363 skb_queue_tail(&entry->neigh->arp_queue, skb); 364 else { 365 dev_kfree_skb(skb); 366 dev->stats.tx_dropped++; 367 } 368 goto out_release_neigh; 369 } 370 pr_debug("neigh %p, vccs %p\n", entry, entry->vccs); 371 ATM_SKB(skb)->vcc = vcc = entry->vccs->vcc; 372 pr_debug("using neighbour %p, vcc %p\n", n, vcc); 373 if (entry->vccs->encap) { 374 void *here; 375 376 here = skb_push(skb, RFC1483LLC_LEN); 377 memcpy(here, llc_oui, sizeof(llc_oui)); 378 ((__be16 *) here)[3] = skb->protocol; 379 } 380 atomic_add(skb->truesize, &sk_atm(vcc)->sk_wmem_alloc); 381 ATM_SKB(skb)->atm_options = vcc->atm_options; 382 entry->vccs->last_use = jiffies; 383 pr_debug("atm_skb(%p)->vcc(%p)->dev(%p)\n", skb, vcc, vcc->dev); 384 old = xchg(&entry->vccs->xoff, 1); /* assume XOFF ... */ 385 if (old) { 386 pr_warning("XOFF->XOFF transition\n"); 387 goto out_release_neigh; 388 } 389 dev->stats.tx_packets++; 390 dev->stats.tx_bytes += skb->len; 391 vcc->send(vcc, skb); 392 if (atm_may_send(vcc, 0)) { 393 entry->vccs->xoff = 0; 394 goto out_release_neigh; 395 } 396 spin_lock_irqsave(&clip_priv->xoff_lock, flags); 397 netif_stop_queue(dev); /* XOFF -> throttle immediately */ 398 barrier(); 399 if (!entry->vccs->xoff) 400 netif_start_queue(dev); 401 /* Oh, we just raced with clip_pop. netif_start_queue should be 402 good enough, because nothing should really be asleep because 403 of the brief netif_stop_queue. If this isn't true or if it 404 changes, use netif_wake_queue instead. */ 405 spin_unlock_irqrestore(&clip_priv->xoff_lock, flags); 406 out_release_neigh: 407 neigh_release(n); 408 return NETDEV_TX_OK; 409 } 410 411 static int clip_mkip(struct atm_vcc *vcc, int timeout) 412 { 413 struct clip_vcc *clip_vcc; 414 415 if (!vcc->push) 416 return -EBADFD; 417 clip_vcc = kmalloc(sizeof(struct clip_vcc), GFP_KERNEL); 418 if (!clip_vcc) 419 return -ENOMEM; 420 pr_debug("%p vcc %p\n", clip_vcc, vcc); 421 clip_vcc->vcc = vcc; 422 vcc->user_back = clip_vcc; 423 set_bit(ATM_VF_IS_CLIP, &vcc->flags); 424 clip_vcc->entry = NULL; 425 clip_vcc->xoff = 0; 426 clip_vcc->encap = 1; 427 clip_vcc->last_use = jiffies; 428 clip_vcc->idle_timeout = timeout * HZ; 429 clip_vcc->old_push = vcc->push; 430 clip_vcc->old_pop = vcc->pop; 431 vcc->push = clip_push; 432 vcc->pop = clip_pop; 433 434 /* re-process everything received between connection setup and MKIP */ 435 vcc_process_recv_queue(vcc); 436 437 return 0; 438 } 439 440 static int clip_setentry(struct atm_vcc *vcc, __be32 ip) 441 { 442 struct neighbour *neigh; 443 struct atmarp_entry *entry; 444 int error; 445 struct clip_vcc *clip_vcc; 446 struct rtable *rt; 447 448 if (vcc->push != clip_push) { 449 pr_warning("non-CLIP VCC\n"); 450 return -EBADF; 451 } 452 clip_vcc = CLIP_VCC(vcc); 453 if (!ip) { 454 if (!clip_vcc->entry) { 455 pr_err("hiding hidden ATMARP entry\n"); 456 return 0; 457 } 458 pr_debug("remove\n"); 459 unlink_clip_vcc(clip_vcc); 460 return 0; 461 } 462 rt = ip_route_output(&init_net, ip, 0, 1, 0); 463 if (IS_ERR(rt)) 464 return PTR_ERR(rt); 465 neigh = __neigh_lookup(&arp_tbl, &ip, rt->dst.dev, 1); 466 ip_rt_put(rt); 467 if (!neigh) 468 return -ENOMEM; 469 entry = neighbour_priv(neigh); 470 if (entry != clip_vcc->entry) { 471 if (!clip_vcc->entry) 472 pr_debug("add\n"); 473 else { 474 pr_debug("update\n"); 475 unlink_clip_vcc(clip_vcc); 476 } 477 link_vcc(clip_vcc, entry); 478 } 479 error = neigh_update(neigh, llc_oui, NUD_PERMANENT, 480 NEIGH_UPDATE_F_OVERRIDE | NEIGH_UPDATE_F_ADMIN); 481 neigh_release(neigh); 482 return error; 483 } 484 485 static const struct net_device_ops clip_netdev_ops = { 486 .ndo_start_xmit = clip_start_xmit, 487 .ndo_neigh_construct = clip_constructor, 488 }; 489 490 static void clip_setup(struct net_device *dev) 491 { 492 dev->netdev_ops = &clip_netdev_ops; 493 dev->type = ARPHRD_ATM; 494 dev->neigh_priv_len = sizeof(struct atmarp_entry); 495 dev->hard_header_len = RFC1483LLC_LEN; 496 dev->mtu = RFC1626_MTU; 497 dev->tx_queue_len = 100; /* "normal" queue (packets) */ 498 /* When using a "real" qdisc, the qdisc determines the queue */ 499 /* length. tx_queue_len is only used for the default case, */ 500 /* without any more elaborate queuing. 100 is a reasonable */ 501 /* compromise between decent burst-tolerance and protection */ 502 /* against memory hogs. */ 503 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE; 504 } 505 506 static int clip_create(int number) 507 { 508 struct net_device *dev; 509 struct clip_priv *clip_priv; 510 int error; 511 512 if (number != -1) { 513 for (dev = clip_devs; dev; dev = PRIV(dev)->next) 514 if (PRIV(dev)->number == number) 515 return -EEXIST; 516 } else { 517 number = 0; 518 for (dev = clip_devs; dev; dev = PRIV(dev)->next) 519 if (PRIV(dev)->number >= number) 520 number = PRIV(dev)->number + 1; 521 } 522 dev = alloc_netdev(sizeof(struct clip_priv), "", clip_setup); 523 if (!dev) 524 return -ENOMEM; 525 clip_priv = PRIV(dev); 526 sprintf(dev->name, "atm%d", number); 527 spin_lock_init(&clip_priv->xoff_lock); 528 clip_priv->number = number; 529 error = register_netdev(dev); 530 if (error) { 531 free_netdev(dev); 532 return error; 533 } 534 clip_priv->next = clip_devs; 535 clip_devs = dev; 536 pr_debug("registered (net:%s)\n", dev->name); 537 return number; 538 } 539 540 static int clip_device_event(struct notifier_block *this, unsigned long event, 541 void *arg) 542 { 543 struct net_device *dev = arg; 544 545 if (!net_eq(dev_net(dev), &init_net)) 546 return NOTIFY_DONE; 547 548 if (event == NETDEV_UNREGISTER) 549 return NOTIFY_DONE; 550 551 /* ignore non-CLIP devices */ 552 if (dev->type != ARPHRD_ATM || dev->netdev_ops != &clip_netdev_ops) 553 return NOTIFY_DONE; 554 555 switch (event) { 556 case NETDEV_UP: 557 pr_debug("NETDEV_UP\n"); 558 to_atmarpd(act_up, PRIV(dev)->number, 0); 559 break; 560 case NETDEV_GOING_DOWN: 561 pr_debug("NETDEV_DOWN\n"); 562 to_atmarpd(act_down, PRIV(dev)->number, 0); 563 break; 564 case NETDEV_CHANGE: 565 case NETDEV_CHANGEMTU: 566 pr_debug("NETDEV_CHANGE*\n"); 567 to_atmarpd(act_change, PRIV(dev)->number, 0); 568 break; 569 } 570 return NOTIFY_DONE; 571 } 572 573 static int clip_inet_event(struct notifier_block *this, unsigned long event, 574 void *ifa) 575 { 576 struct in_device *in_dev; 577 578 in_dev = ((struct in_ifaddr *)ifa)->ifa_dev; 579 /* 580 * Transitions are of the down-change-up type, so it's sufficient to 581 * handle the change on up. 582 */ 583 if (event != NETDEV_UP) 584 return NOTIFY_DONE; 585 return clip_device_event(this, NETDEV_CHANGE, in_dev->dev); 586 } 587 588 static struct notifier_block clip_dev_notifier = { 589 .notifier_call = clip_device_event, 590 }; 591 592 593 594 static struct notifier_block clip_inet_notifier = { 595 .notifier_call = clip_inet_event, 596 }; 597 598 599 600 static void atmarpd_close(struct atm_vcc *vcc) 601 { 602 pr_debug("\n"); 603 604 rtnl_lock(); 605 atmarpd = NULL; 606 skb_queue_purge(&sk_atm(vcc)->sk_receive_queue); 607 rtnl_unlock(); 608 609 pr_debug("(done)\n"); 610 module_put(THIS_MODULE); 611 } 612 613 static struct atmdev_ops atmarpd_dev_ops = { 614 .close = atmarpd_close 615 }; 616 617 618 static struct atm_dev atmarpd_dev = { 619 .ops = &atmarpd_dev_ops, 620 .type = "arpd", 621 .number = 999, 622 .lock = __SPIN_LOCK_UNLOCKED(atmarpd_dev.lock) 623 }; 624 625 626 static int atm_init_atmarp(struct atm_vcc *vcc) 627 { 628 rtnl_lock(); 629 if (atmarpd) { 630 rtnl_unlock(); 631 return -EADDRINUSE; 632 } 633 634 mod_timer(&idle_timer, jiffies + CLIP_CHECK_INTERVAL * HZ); 635 636 atmarpd = vcc; 637 set_bit(ATM_VF_META, &vcc->flags); 638 set_bit(ATM_VF_READY, &vcc->flags); 639 /* allow replies and avoid getting closed if signaling dies */ 640 vcc->dev = &atmarpd_dev; 641 vcc_insert_socket(sk_atm(vcc)); 642 vcc->push = NULL; 643 vcc->pop = NULL; /* crash */ 644 vcc->push_oam = NULL; /* crash */ 645 rtnl_unlock(); 646 return 0; 647 } 648 649 static int clip_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 650 { 651 struct atm_vcc *vcc = ATM_SD(sock); 652 int err = 0; 653 654 switch (cmd) { 655 case SIOCMKCLIP: 656 case ATMARPD_CTRL: 657 case ATMARP_MKIP: 658 case ATMARP_SETENTRY: 659 case ATMARP_ENCAP: 660 if (!capable(CAP_NET_ADMIN)) 661 return -EPERM; 662 break; 663 default: 664 return -ENOIOCTLCMD; 665 } 666 667 switch (cmd) { 668 case SIOCMKCLIP: 669 err = clip_create(arg); 670 break; 671 case ATMARPD_CTRL: 672 err = atm_init_atmarp(vcc); 673 if (!err) { 674 sock->state = SS_CONNECTED; 675 __module_get(THIS_MODULE); 676 } 677 break; 678 case ATMARP_MKIP: 679 err = clip_mkip(vcc, arg); 680 break; 681 case ATMARP_SETENTRY: 682 err = clip_setentry(vcc, (__force __be32)arg); 683 break; 684 case ATMARP_ENCAP: 685 err = clip_encap(vcc, arg); 686 break; 687 } 688 return err; 689 } 690 691 static struct atm_ioctl clip_ioctl_ops = { 692 .owner = THIS_MODULE, 693 .ioctl = clip_ioctl, 694 }; 695 696 #ifdef CONFIG_PROC_FS 697 698 static void svc_addr(struct seq_file *seq, struct sockaddr_atmsvc *addr) 699 { 700 static int code[] = { 1, 2, 10, 6, 1, 0 }; 701 static int e164[] = { 1, 8, 4, 6, 1, 0 }; 702 703 if (*addr->sas_addr.pub) { 704 seq_printf(seq, "%s", addr->sas_addr.pub); 705 if (*addr->sas_addr.prv) 706 seq_putc(seq, '+'); 707 } else if (!*addr->sas_addr.prv) { 708 seq_printf(seq, "%s", "(none)"); 709 return; 710 } 711 if (*addr->sas_addr.prv) { 712 unsigned char *prv = addr->sas_addr.prv; 713 int *fields; 714 int i, j; 715 716 fields = *prv == ATM_AFI_E164 ? e164 : code; 717 for (i = 0; fields[i]; i++) { 718 for (j = fields[i]; j; j--) 719 seq_printf(seq, "%02X", *prv++); 720 if (fields[i + 1]) 721 seq_putc(seq, '.'); 722 } 723 } 724 } 725 726 /* This means the neighbour entry has no attached VCC objects. */ 727 #define SEQ_NO_VCC_TOKEN ((void *) 2) 728 729 static void atmarp_info(struct seq_file *seq, struct neighbour *n, 730 struct atmarp_entry *entry, struct clip_vcc *clip_vcc) 731 { 732 struct net_device *dev = n->dev; 733 unsigned long exp; 734 char buf[17]; 735 int svc, llc, off; 736 737 svc = ((clip_vcc == SEQ_NO_VCC_TOKEN) || 738 (sk_atm(clip_vcc->vcc)->sk_family == AF_ATMSVC)); 739 740 llc = ((clip_vcc == SEQ_NO_VCC_TOKEN) || clip_vcc->encap); 741 742 if (clip_vcc == SEQ_NO_VCC_TOKEN) 743 exp = entry->neigh->used; 744 else 745 exp = clip_vcc->last_use; 746 747 exp = (jiffies - exp) / HZ; 748 749 seq_printf(seq, "%-6s%-4s%-4s%5ld ", 750 dev->name, svc ? "SVC" : "PVC", llc ? "LLC" : "NULL", exp); 751 752 off = scnprintf(buf, sizeof(buf) - 1, "%pI4", n->primary_key); 753 while (off < 16) 754 buf[off++] = ' '; 755 buf[off] = '\0'; 756 seq_printf(seq, "%s", buf); 757 758 if (clip_vcc == SEQ_NO_VCC_TOKEN) { 759 if (time_before(jiffies, entry->expires)) 760 seq_printf(seq, "(resolving)\n"); 761 else 762 seq_printf(seq, "(expired, ref %d)\n", 763 atomic_read(&entry->neigh->refcnt)); 764 } else if (!svc) { 765 seq_printf(seq, "%d.%d.%d\n", 766 clip_vcc->vcc->dev->number, 767 clip_vcc->vcc->vpi, clip_vcc->vcc->vci); 768 } else { 769 svc_addr(seq, &clip_vcc->vcc->remote); 770 seq_putc(seq, '\n'); 771 } 772 } 773 774 struct clip_seq_state { 775 /* This member must be first. */ 776 struct neigh_seq_state ns; 777 778 /* Local to clip specific iteration. */ 779 struct clip_vcc *vcc; 780 }; 781 782 static struct clip_vcc *clip_seq_next_vcc(struct atmarp_entry *e, 783 struct clip_vcc *curr) 784 { 785 if (!curr) { 786 curr = e->vccs; 787 if (!curr) 788 return SEQ_NO_VCC_TOKEN; 789 return curr; 790 } 791 if (curr == SEQ_NO_VCC_TOKEN) 792 return NULL; 793 794 curr = curr->next; 795 796 return curr; 797 } 798 799 static void *clip_seq_vcc_walk(struct clip_seq_state *state, 800 struct atmarp_entry *e, loff_t * pos) 801 { 802 struct clip_vcc *vcc = state->vcc; 803 804 vcc = clip_seq_next_vcc(e, vcc); 805 if (vcc && pos != NULL) { 806 while (*pos) { 807 vcc = clip_seq_next_vcc(e, vcc); 808 if (!vcc) 809 break; 810 --(*pos); 811 } 812 } 813 state->vcc = vcc; 814 815 return vcc; 816 } 817 818 static void *clip_seq_sub_iter(struct neigh_seq_state *_state, 819 struct neighbour *n, loff_t * pos) 820 { 821 struct clip_seq_state *state = (struct clip_seq_state *)_state; 822 823 if (n->dev->type != ARPHRD_ATM) 824 return NULL; 825 826 return clip_seq_vcc_walk(state, neighbour_priv(n), pos); 827 } 828 829 static void *clip_seq_start(struct seq_file *seq, loff_t * pos) 830 { 831 struct clip_seq_state *state = seq->private; 832 state->ns.neigh_sub_iter = clip_seq_sub_iter; 833 return neigh_seq_start(seq, pos, &arp_tbl, NEIGH_SEQ_NEIGH_ONLY); 834 } 835 836 static int clip_seq_show(struct seq_file *seq, void *v) 837 { 838 static char atm_arp_banner[] = 839 "IPitf TypeEncp Idle IP address ATM address\n"; 840 841 if (v == SEQ_START_TOKEN) { 842 seq_puts(seq, atm_arp_banner); 843 } else { 844 struct clip_seq_state *state = seq->private; 845 struct clip_vcc *vcc = state->vcc; 846 struct neighbour *n = v; 847 848 atmarp_info(seq, n, neighbour_priv(n), vcc); 849 } 850 return 0; 851 } 852 853 static const struct seq_operations arp_seq_ops = { 854 .start = clip_seq_start, 855 .next = neigh_seq_next, 856 .stop = neigh_seq_stop, 857 .show = clip_seq_show, 858 }; 859 860 static int arp_seq_open(struct inode *inode, struct file *file) 861 { 862 return seq_open_net(inode, file, &arp_seq_ops, 863 sizeof(struct clip_seq_state)); 864 } 865 866 static const struct file_operations arp_seq_fops = { 867 .open = arp_seq_open, 868 .read = seq_read, 869 .llseek = seq_lseek, 870 .release = seq_release_net, 871 .owner = THIS_MODULE 872 }; 873 #endif 874 875 static void atm_clip_exit_noproc(void); 876 877 static int __init atm_clip_init(void) 878 { 879 register_atm_ioctl(&clip_ioctl_ops); 880 register_netdevice_notifier(&clip_dev_notifier); 881 register_inetaddr_notifier(&clip_inet_notifier); 882 883 setup_timer(&idle_timer, idle_timer_check, 0); 884 885 #ifdef CONFIG_PROC_FS 886 { 887 struct proc_dir_entry *p; 888 889 p = proc_create("arp", S_IRUGO, atm_proc_root, &arp_seq_fops); 890 if (!p) { 891 pr_err("Unable to initialize /proc/net/atm/arp\n"); 892 atm_clip_exit_noproc(); 893 return -ENOMEM; 894 } 895 } 896 #endif 897 898 return 0; 899 } 900 901 static void atm_clip_exit_noproc(void) 902 { 903 struct net_device *dev, *next; 904 905 unregister_inetaddr_notifier(&clip_inet_notifier); 906 unregister_netdevice_notifier(&clip_dev_notifier); 907 908 deregister_atm_ioctl(&clip_ioctl_ops); 909 910 /* First, stop the idle timer, so it stops banging 911 * on the table. 912 */ 913 del_timer_sync(&idle_timer); 914 915 dev = clip_devs; 916 while (dev) { 917 next = PRIV(dev)->next; 918 unregister_netdev(dev); 919 free_netdev(dev); 920 dev = next; 921 } 922 } 923 924 static void __exit atm_clip_exit(void) 925 { 926 remove_proc_entry("arp", atm_proc_root); 927 928 atm_clip_exit_noproc(); 929 } 930 931 module_init(atm_clip_init); 932 module_exit(atm_clip_exit); 933 MODULE_AUTHOR("Werner Almesberger"); 934 MODULE_DESCRIPTION("Classical/IP over ATM interface"); 935 MODULE_LICENSE("GPL"); 936