1 /* linux/net/ipv4/arp.c 2 * 3 * Version: $Id: arp.c,v 1.99 2001/08/30 22:55:42 davem Exp $ 4 * 5 * Copyright (C) 1994 by Florian La Roche 6 * 7 * This module implements the Address Resolution Protocol ARP (RFC 826), 8 * which is used to convert IP addresses (or in the future maybe other 9 * high-level addresses) into a low-level hardware address (like an Ethernet 10 * address). 11 * 12 * This program is free software; you can redistribute it and/or 13 * modify it under the terms of the GNU General Public License 14 * as published by the Free Software Foundation; either version 15 * 2 of the License, or (at your option) any later version. 16 * 17 * Fixes: 18 * Alan Cox : Removed the Ethernet assumptions in 19 * Florian's code 20 * Alan Cox : Fixed some small errors in the ARP 21 * logic 22 * Alan Cox : Allow >4K in /proc 23 * Alan Cox : Make ARP add its own protocol entry 24 * Ross Martin : Rewrote arp_rcv() and arp_get_info() 25 * Stephen Henson : Add AX25 support to arp_get_info() 26 * Alan Cox : Drop data when a device is downed. 27 * Alan Cox : Use init_timer(). 28 * Alan Cox : Double lock fixes. 29 * Martin Seine : Move the arphdr structure 30 * to if_arp.h for compatibility. 31 * with BSD based programs. 32 * Andrew Tridgell : Added ARP netmask code and 33 * re-arranged proxy handling. 34 * Alan Cox : Changed to use notifiers. 35 * Niibe Yutaka : Reply for this device or proxies only. 36 * Alan Cox : Don't proxy across hardware types! 37 * Jonathan Naylor : Added support for NET/ROM. 38 * Mike Shaver : RFC1122 checks. 39 * Jonathan Naylor : Only lookup the hardware address for 40 * the correct hardware type. 41 * Germano Caronni : Assorted subtle races. 42 * Craig Schlenter : Don't modify permanent entry 43 * during arp_rcv. 44 * Russ Nelson : Tidied up a few bits. 45 * Alexey Kuznetsov: Major changes to caching and behaviour, 46 * eg intelligent arp probing and 47 * generation 48 * of host down events. 49 * Alan Cox : Missing unlock in device events. 50 * Eckes : ARP ioctl control errors. 51 * Alexey Kuznetsov: Arp free fix. 52 * Manuel Rodriguez: Gratuitous ARP. 53 * Jonathan Layes : Added arpd support through kerneld 54 * message queue (960314) 55 * Mike Shaver : /proc/sys/net/ipv4/arp_* support 56 * Mike McLagan : Routing by source 57 * Stuart Cheshire : Metricom and grat arp fixes 58 * *** FOR 2.1 clean this up *** 59 * Lawrence V. Stefani: (08/12/96) Added FDDI support. 60 * Alan Cox : Took the AP1000 nasty FDDI hack and 61 * folded into the mainstream FDDI code. 62 * Ack spit, Linus how did you allow that 63 * one in... 64 * Jes Sorensen : Make FDDI work again in 2.1.x and 65 * clean up the APFDDI & gen. FDDI bits. 66 * Alexey Kuznetsov: new arp state machine; 67 * now it is in net/core/neighbour.c. 68 * Krzysztof Halasa: Added Frame Relay ARP support. 69 * Arnaldo C. Melo : convert /proc/net/arp to seq_file 70 * Shmulik Hen: Split arp_send to arp_create and 71 * arp_xmit so intermediate drivers like 72 * bonding can change the skb before 73 * sending (e.g. insert 8021q tag). 74 * Harald Welte : convert to make use of jenkins hash 75 */ 76 77 #include <linux/module.h> 78 #include <linux/types.h> 79 #include <linux/string.h> 80 #include <linux/kernel.h> 81 #include <linux/capability.h> 82 #include <linux/socket.h> 83 #include <linux/sockios.h> 84 #include <linux/errno.h> 85 #include <linux/in.h> 86 #include <linux/mm.h> 87 #include <linux/inet.h> 88 #include <linux/inetdevice.h> 89 #include <linux/netdevice.h> 90 #include <linux/etherdevice.h> 91 #include <linux/fddidevice.h> 92 #include <linux/if_arp.h> 93 #include <linux/trdevice.h> 94 #include <linux/skbuff.h> 95 #include <linux/proc_fs.h> 96 #include <linux/seq_file.h> 97 #include <linux/stat.h> 98 #include <linux/init.h> 99 #include <linux/net.h> 100 #include <linux/rcupdate.h> 101 #include <linux/jhash.h> 102 #ifdef CONFIG_SYSCTL 103 #include <linux/sysctl.h> 104 #endif 105 106 #include <net/net_namespace.h> 107 #include <net/ip.h> 108 #include <net/icmp.h> 109 #include <net/route.h> 110 #include <net/protocol.h> 111 #include <net/tcp.h> 112 #include <net/sock.h> 113 #include <net/arp.h> 114 #include <net/ax25.h> 115 #include <net/netrom.h> 116 #if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE) 117 #include <net/atmclip.h> 118 struct neigh_table *clip_tbl_hook; 119 #endif 120 121 #include <asm/system.h> 122 #include <asm/uaccess.h> 123 124 #include <linux/netfilter_arp.h> 125 126 /* 127 * Interface to generic neighbour cache. 128 */ 129 static u32 arp_hash(const void *pkey, const struct net_device *dev); 130 static int arp_constructor(struct neighbour *neigh); 131 static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb); 132 static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb); 133 static void parp_redo(struct sk_buff *skb); 134 135 static struct neigh_ops arp_generic_ops = { 136 .family = AF_INET, 137 .solicit = arp_solicit, 138 .error_report = arp_error_report, 139 .output = neigh_resolve_output, 140 .connected_output = neigh_connected_output, 141 .hh_output = dev_queue_xmit, 142 .queue_xmit = dev_queue_xmit, 143 }; 144 145 static struct neigh_ops arp_hh_ops = { 146 .family = AF_INET, 147 .solicit = arp_solicit, 148 .error_report = arp_error_report, 149 .output = neigh_resolve_output, 150 .connected_output = neigh_resolve_output, 151 .hh_output = dev_queue_xmit, 152 .queue_xmit = dev_queue_xmit, 153 }; 154 155 static struct neigh_ops arp_direct_ops = { 156 .family = AF_INET, 157 .output = dev_queue_xmit, 158 .connected_output = dev_queue_xmit, 159 .hh_output = dev_queue_xmit, 160 .queue_xmit = dev_queue_xmit, 161 }; 162 163 struct neigh_ops arp_broken_ops = { 164 .family = AF_INET, 165 .solicit = arp_solicit, 166 .error_report = arp_error_report, 167 .output = neigh_compat_output, 168 .connected_output = neigh_compat_output, 169 .hh_output = dev_queue_xmit, 170 .queue_xmit = dev_queue_xmit, 171 }; 172 173 struct neigh_table arp_tbl = { 174 .family = AF_INET, 175 .entry_size = sizeof(struct neighbour) + 4, 176 .key_len = 4, 177 .hash = arp_hash, 178 .constructor = arp_constructor, 179 .proxy_redo = parp_redo, 180 .id = "arp_cache", 181 .parms = { 182 .tbl = &arp_tbl, 183 .base_reachable_time = 30 * HZ, 184 .retrans_time = 1 * HZ, 185 .gc_staletime = 60 * HZ, 186 .reachable_time = 30 * HZ, 187 .delay_probe_time = 5 * HZ, 188 .queue_len = 3, 189 .ucast_probes = 3, 190 .mcast_probes = 3, 191 .anycast_delay = 1 * HZ, 192 .proxy_delay = (8 * HZ) / 10, 193 .proxy_qlen = 64, 194 .locktime = 1 * HZ, 195 }, 196 .gc_interval = 30 * HZ, 197 .gc_thresh1 = 128, 198 .gc_thresh2 = 512, 199 .gc_thresh3 = 1024, 200 }; 201 202 int arp_mc_map(__be32 addr, u8 *haddr, struct net_device *dev, int dir) 203 { 204 switch (dev->type) { 205 case ARPHRD_ETHER: 206 case ARPHRD_FDDI: 207 case ARPHRD_IEEE802: 208 ip_eth_mc_map(addr, haddr); 209 return 0; 210 case ARPHRD_IEEE802_TR: 211 ip_tr_mc_map(addr, haddr); 212 return 0; 213 case ARPHRD_INFINIBAND: 214 ip_ib_mc_map(addr, dev->broadcast, haddr); 215 return 0; 216 default: 217 if (dir) { 218 memcpy(haddr, dev->broadcast, dev->addr_len); 219 return 0; 220 } 221 } 222 return -EINVAL; 223 } 224 225 226 static u32 arp_hash(const void *pkey, const struct net_device *dev) 227 { 228 return jhash_2words(*(u32 *)pkey, dev->ifindex, arp_tbl.hash_rnd); 229 } 230 231 static int arp_constructor(struct neighbour *neigh) 232 { 233 __be32 addr = *(__be32*)neigh->primary_key; 234 struct net_device *dev = neigh->dev; 235 struct in_device *in_dev; 236 struct neigh_parms *parms; 237 238 rcu_read_lock(); 239 in_dev = __in_dev_get_rcu(dev); 240 if (in_dev == NULL) { 241 rcu_read_unlock(); 242 return -EINVAL; 243 } 244 245 neigh->type = inet_addr_type(&init_net, addr); 246 247 parms = in_dev->arp_parms; 248 __neigh_parms_put(neigh->parms); 249 neigh->parms = neigh_parms_clone(parms); 250 rcu_read_unlock(); 251 252 if (!dev->header_ops) { 253 neigh->nud_state = NUD_NOARP; 254 neigh->ops = &arp_direct_ops; 255 neigh->output = neigh->ops->queue_xmit; 256 } else { 257 /* Good devices (checked by reading texts, but only Ethernet is 258 tested) 259 260 ARPHRD_ETHER: (ethernet, apfddi) 261 ARPHRD_FDDI: (fddi) 262 ARPHRD_IEEE802: (tr) 263 ARPHRD_METRICOM: (strip) 264 ARPHRD_ARCNET: 265 etc. etc. etc. 266 267 ARPHRD_IPDDP will also work, if author repairs it. 268 I did not it, because this driver does not work even 269 in old paradigm. 270 */ 271 272 #if 1 273 /* So... these "amateur" devices are hopeless. 274 The only thing, that I can say now: 275 It is very sad that we need to keep ugly obsolete 276 code to make them happy. 277 278 They should be moved to more reasonable state, now 279 they use rebuild_header INSTEAD OF hard_start_xmit!!! 280 Besides that, they are sort of out of date 281 (a lot of redundant clones/copies, useless in 2.1), 282 I wonder why people believe that they work. 283 */ 284 switch (dev->type) { 285 default: 286 break; 287 case ARPHRD_ROSE: 288 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE) 289 case ARPHRD_AX25: 290 #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE) 291 case ARPHRD_NETROM: 292 #endif 293 neigh->ops = &arp_broken_ops; 294 neigh->output = neigh->ops->output; 295 return 0; 296 #endif 297 ;} 298 #endif 299 if (neigh->type == RTN_MULTICAST) { 300 neigh->nud_state = NUD_NOARP; 301 arp_mc_map(addr, neigh->ha, dev, 1); 302 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) { 303 neigh->nud_state = NUD_NOARP; 304 memcpy(neigh->ha, dev->dev_addr, dev->addr_len); 305 } else if (neigh->type == RTN_BROADCAST || dev->flags&IFF_POINTOPOINT) { 306 neigh->nud_state = NUD_NOARP; 307 memcpy(neigh->ha, dev->broadcast, dev->addr_len); 308 } 309 310 if (dev->header_ops->cache) 311 neigh->ops = &arp_hh_ops; 312 else 313 neigh->ops = &arp_generic_ops; 314 315 if (neigh->nud_state&NUD_VALID) 316 neigh->output = neigh->ops->connected_output; 317 else 318 neigh->output = neigh->ops->output; 319 } 320 return 0; 321 } 322 323 static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb) 324 { 325 dst_link_failure(skb); 326 kfree_skb(skb); 327 } 328 329 static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb) 330 { 331 __be32 saddr = 0; 332 u8 *dst_ha = NULL; 333 struct net_device *dev = neigh->dev; 334 __be32 target = *(__be32*)neigh->primary_key; 335 int probes = atomic_read(&neigh->probes); 336 struct in_device *in_dev = in_dev_get(dev); 337 338 if (!in_dev) 339 return; 340 341 switch (IN_DEV_ARP_ANNOUNCE(in_dev)) { 342 default: 343 case 0: /* By default announce any local IP */ 344 if (skb && inet_addr_type(&init_net, ip_hdr(skb)->saddr) == RTN_LOCAL) 345 saddr = ip_hdr(skb)->saddr; 346 break; 347 case 1: /* Restrict announcements of saddr in same subnet */ 348 if (!skb) 349 break; 350 saddr = ip_hdr(skb)->saddr; 351 if (inet_addr_type(&init_net, saddr) == RTN_LOCAL) { 352 /* saddr should be known to target */ 353 if (inet_addr_onlink(in_dev, target, saddr)) 354 break; 355 } 356 saddr = 0; 357 break; 358 case 2: /* Avoid secondary IPs, get a primary/preferred one */ 359 break; 360 } 361 362 if (in_dev) 363 in_dev_put(in_dev); 364 if (!saddr) 365 saddr = inet_select_addr(dev, target, RT_SCOPE_LINK); 366 367 if ((probes -= neigh->parms->ucast_probes) < 0) { 368 if (!(neigh->nud_state&NUD_VALID)) 369 printk(KERN_DEBUG "trying to ucast probe in NUD_INVALID\n"); 370 dst_ha = neigh->ha; 371 read_lock_bh(&neigh->lock); 372 } else if ((probes -= neigh->parms->app_probes) < 0) { 373 #ifdef CONFIG_ARPD 374 neigh_app_ns(neigh); 375 #endif 376 return; 377 } 378 379 arp_send(ARPOP_REQUEST, ETH_P_ARP, target, dev, saddr, 380 dst_ha, dev->dev_addr, NULL); 381 if (dst_ha) 382 read_unlock_bh(&neigh->lock); 383 } 384 385 static int arp_ignore(struct in_device *in_dev, __be32 sip, __be32 tip) 386 { 387 int scope; 388 389 switch (IN_DEV_ARP_IGNORE(in_dev)) { 390 case 0: /* Reply, the tip is already validated */ 391 return 0; 392 case 1: /* Reply only if tip is configured on the incoming interface */ 393 sip = 0; 394 scope = RT_SCOPE_HOST; 395 break; 396 case 2: /* 397 * Reply only if tip is configured on the incoming interface 398 * and is in same subnet as sip 399 */ 400 scope = RT_SCOPE_HOST; 401 break; 402 case 3: /* Do not reply for scope host addresses */ 403 sip = 0; 404 scope = RT_SCOPE_LINK; 405 break; 406 case 4: /* Reserved */ 407 case 5: 408 case 6: 409 case 7: 410 return 0; 411 case 8: /* Do not reply */ 412 return 1; 413 default: 414 return 0; 415 } 416 return !inet_confirm_addr(in_dev, sip, tip, scope); 417 } 418 419 static int arp_filter(__be32 sip, __be32 tip, struct net_device *dev) 420 { 421 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = sip, 422 .saddr = tip } } }; 423 struct rtable *rt; 424 int flag = 0; 425 /*unsigned long now; */ 426 427 if (ip_route_output_key(&init_net, &rt, &fl) < 0) 428 return 1; 429 if (rt->u.dst.dev != dev) { 430 NET_INC_STATS_BH(LINUX_MIB_ARPFILTER); 431 flag = 1; 432 } 433 ip_rt_put(rt); 434 return flag; 435 } 436 437 /* OBSOLETE FUNCTIONS */ 438 439 /* 440 * Find an arp mapping in the cache. If not found, post a request. 441 * 442 * It is very UGLY routine: it DOES NOT use skb->dst->neighbour, 443 * even if it exists. It is supposed that skb->dev was mangled 444 * by a virtual device (eql, shaper). Nobody but broken devices 445 * is allowed to use this function, it is scheduled to be removed. --ANK 446 */ 447 448 static int arp_set_predefined(int addr_hint, unsigned char * haddr, __be32 paddr, struct net_device * dev) 449 { 450 switch (addr_hint) { 451 case RTN_LOCAL: 452 printk(KERN_DEBUG "ARP: arp called for own IP address\n"); 453 memcpy(haddr, dev->dev_addr, dev->addr_len); 454 return 1; 455 case RTN_MULTICAST: 456 arp_mc_map(paddr, haddr, dev, 1); 457 return 1; 458 case RTN_BROADCAST: 459 memcpy(haddr, dev->broadcast, dev->addr_len); 460 return 1; 461 } 462 return 0; 463 } 464 465 466 int arp_find(unsigned char *haddr, struct sk_buff *skb) 467 { 468 struct net_device *dev = skb->dev; 469 __be32 paddr; 470 struct neighbour *n; 471 472 if (!skb->dst) { 473 printk(KERN_DEBUG "arp_find is called with dst==NULL\n"); 474 kfree_skb(skb); 475 return 1; 476 } 477 478 paddr = ((struct rtable*)skb->dst)->rt_gateway; 479 480 if (arp_set_predefined(inet_addr_type(&init_net, paddr), haddr, paddr, dev)) 481 return 0; 482 483 n = __neigh_lookup(&arp_tbl, &paddr, dev, 1); 484 485 if (n) { 486 n->used = jiffies; 487 if (n->nud_state&NUD_VALID || neigh_event_send(n, skb) == 0) { 488 read_lock_bh(&n->lock); 489 memcpy(haddr, n->ha, dev->addr_len); 490 read_unlock_bh(&n->lock); 491 neigh_release(n); 492 return 0; 493 } 494 neigh_release(n); 495 } else 496 kfree_skb(skb); 497 return 1; 498 } 499 500 /* END OF OBSOLETE FUNCTIONS */ 501 502 int arp_bind_neighbour(struct dst_entry *dst) 503 { 504 struct net_device *dev = dst->dev; 505 struct neighbour *n = dst->neighbour; 506 507 if (dev == NULL) 508 return -EINVAL; 509 if (n == NULL) { 510 __be32 nexthop = ((struct rtable*)dst)->rt_gateway; 511 if (dev->flags&(IFF_LOOPBACK|IFF_POINTOPOINT)) 512 nexthop = 0; 513 n = __neigh_lookup_errno( 514 #if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE) 515 dev->type == ARPHRD_ATM ? clip_tbl_hook : 516 #endif 517 &arp_tbl, &nexthop, dev); 518 if (IS_ERR(n)) 519 return PTR_ERR(n); 520 dst->neighbour = n; 521 } 522 return 0; 523 } 524 525 /* 526 * Check if we can use proxy ARP for this path 527 */ 528 529 static inline int arp_fwd_proxy(struct in_device *in_dev, struct rtable *rt) 530 { 531 struct in_device *out_dev; 532 int imi, omi = -1; 533 534 if (!IN_DEV_PROXY_ARP(in_dev)) 535 return 0; 536 537 if ((imi = IN_DEV_MEDIUM_ID(in_dev)) == 0) 538 return 1; 539 if (imi == -1) 540 return 0; 541 542 /* place to check for proxy_arp for routes */ 543 544 if ((out_dev = in_dev_get(rt->u.dst.dev)) != NULL) { 545 omi = IN_DEV_MEDIUM_ID(out_dev); 546 in_dev_put(out_dev); 547 } 548 return (omi != imi && omi != -1); 549 } 550 551 /* 552 * Interface to link layer: send routine and receive handler. 553 */ 554 555 /* 556 * Create an arp packet. If (dest_hw == NULL), we create a broadcast 557 * message. 558 */ 559 struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip, 560 struct net_device *dev, __be32 src_ip, 561 const unsigned char *dest_hw, 562 const unsigned char *src_hw, 563 const unsigned char *target_hw) 564 { 565 struct sk_buff *skb; 566 struct arphdr *arp; 567 unsigned char *arp_ptr; 568 569 /* 570 * Allocate a buffer 571 */ 572 573 skb = alloc_skb(sizeof(struct arphdr)+ 2*(dev->addr_len+4) 574 + LL_RESERVED_SPACE(dev), GFP_ATOMIC); 575 if (skb == NULL) 576 return NULL; 577 578 skb_reserve(skb, LL_RESERVED_SPACE(dev)); 579 skb_reset_network_header(skb); 580 arp = (struct arphdr *) skb_put(skb,sizeof(struct arphdr) + 2*(dev->addr_len+4)); 581 skb->dev = dev; 582 skb->protocol = htons(ETH_P_ARP); 583 if (src_hw == NULL) 584 src_hw = dev->dev_addr; 585 if (dest_hw == NULL) 586 dest_hw = dev->broadcast; 587 588 /* 589 * Fill the device header for the ARP frame 590 */ 591 if (dev_hard_header(skb, dev, ptype, dest_hw, src_hw, skb->len) < 0) 592 goto out; 593 594 /* 595 * Fill out the arp protocol part. 596 * 597 * The arp hardware type should match the device type, except for FDDI, 598 * which (according to RFC 1390) should always equal 1 (Ethernet). 599 */ 600 /* 601 * Exceptions everywhere. AX.25 uses the AX.25 PID value not the 602 * DIX code for the protocol. Make these device structure fields. 603 */ 604 switch (dev->type) { 605 default: 606 arp->ar_hrd = htons(dev->type); 607 arp->ar_pro = htons(ETH_P_IP); 608 break; 609 610 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE) 611 case ARPHRD_AX25: 612 arp->ar_hrd = htons(ARPHRD_AX25); 613 arp->ar_pro = htons(AX25_P_IP); 614 break; 615 616 #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE) 617 case ARPHRD_NETROM: 618 arp->ar_hrd = htons(ARPHRD_NETROM); 619 arp->ar_pro = htons(AX25_P_IP); 620 break; 621 #endif 622 #endif 623 624 #ifdef CONFIG_FDDI 625 case ARPHRD_FDDI: 626 arp->ar_hrd = htons(ARPHRD_ETHER); 627 arp->ar_pro = htons(ETH_P_IP); 628 break; 629 #endif 630 #ifdef CONFIG_TR 631 case ARPHRD_IEEE802_TR: 632 arp->ar_hrd = htons(ARPHRD_IEEE802); 633 arp->ar_pro = htons(ETH_P_IP); 634 break; 635 #endif 636 } 637 638 arp->ar_hln = dev->addr_len; 639 arp->ar_pln = 4; 640 arp->ar_op = htons(type); 641 642 arp_ptr=(unsigned char *)(arp+1); 643 644 memcpy(arp_ptr, src_hw, dev->addr_len); 645 arp_ptr+=dev->addr_len; 646 memcpy(arp_ptr, &src_ip,4); 647 arp_ptr+=4; 648 if (target_hw != NULL) 649 memcpy(arp_ptr, target_hw, dev->addr_len); 650 else 651 memset(arp_ptr, 0, dev->addr_len); 652 arp_ptr+=dev->addr_len; 653 memcpy(arp_ptr, &dest_ip, 4); 654 655 return skb; 656 657 out: 658 kfree_skb(skb); 659 return NULL; 660 } 661 662 /* 663 * Send an arp packet. 664 */ 665 void arp_xmit(struct sk_buff *skb) 666 { 667 /* Send it off, maybe filter it using firewalling first. */ 668 NF_HOOK(NF_ARP, NF_ARP_OUT, skb, NULL, skb->dev, dev_queue_xmit); 669 } 670 671 /* 672 * Create and send an arp packet. 673 */ 674 void arp_send(int type, int ptype, __be32 dest_ip, 675 struct net_device *dev, __be32 src_ip, 676 const unsigned char *dest_hw, const unsigned char *src_hw, 677 const unsigned char *target_hw) 678 { 679 struct sk_buff *skb; 680 681 /* 682 * No arp on this interface. 683 */ 684 685 if (dev->flags&IFF_NOARP) 686 return; 687 688 skb = arp_create(type, ptype, dest_ip, dev, src_ip, 689 dest_hw, src_hw, target_hw); 690 if (skb == NULL) { 691 return; 692 } 693 694 arp_xmit(skb); 695 } 696 697 /* 698 * Process an arp request. 699 */ 700 701 static int arp_process(struct sk_buff *skb) 702 { 703 struct net_device *dev = skb->dev; 704 struct in_device *in_dev = in_dev_get(dev); 705 struct arphdr *arp; 706 unsigned char *arp_ptr; 707 struct rtable *rt; 708 unsigned char *sha; 709 __be32 sip, tip; 710 u16 dev_type = dev->type; 711 int addr_type; 712 struct neighbour *n; 713 714 /* arp_rcv below verifies the ARP header and verifies the device 715 * is ARP'able. 716 */ 717 718 if (in_dev == NULL) 719 goto out; 720 721 arp = arp_hdr(skb); 722 723 switch (dev_type) { 724 default: 725 if (arp->ar_pro != htons(ETH_P_IP) || 726 htons(dev_type) != arp->ar_hrd) 727 goto out; 728 break; 729 case ARPHRD_ETHER: 730 case ARPHRD_IEEE802_TR: 731 case ARPHRD_FDDI: 732 case ARPHRD_IEEE802: 733 /* 734 * ETHERNET, Token Ring and Fibre Channel (which are IEEE 802 735 * devices, according to RFC 2625) devices will accept ARP 736 * hardware types of either 1 (Ethernet) or 6 (IEEE 802.2). 737 * This is the case also of FDDI, where the RFC 1390 says that 738 * FDDI devices should accept ARP hardware of (1) Ethernet, 739 * however, to be more robust, we'll accept both 1 (Ethernet) 740 * or 6 (IEEE 802.2) 741 */ 742 if ((arp->ar_hrd != htons(ARPHRD_ETHER) && 743 arp->ar_hrd != htons(ARPHRD_IEEE802)) || 744 arp->ar_pro != htons(ETH_P_IP)) 745 goto out; 746 break; 747 case ARPHRD_AX25: 748 if (arp->ar_pro != htons(AX25_P_IP) || 749 arp->ar_hrd != htons(ARPHRD_AX25)) 750 goto out; 751 break; 752 case ARPHRD_NETROM: 753 if (arp->ar_pro != htons(AX25_P_IP) || 754 arp->ar_hrd != htons(ARPHRD_NETROM)) 755 goto out; 756 break; 757 } 758 759 /* Understand only these message types */ 760 761 if (arp->ar_op != htons(ARPOP_REPLY) && 762 arp->ar_op != htons(ARPOP_REQUEST)) 763 goto out; 764 765 /* 766 * Extract fields 767 */ 768 arp_ptr= (unsigned char *)(arp+1); 769 sha = arp_ptr; 770 arp_ptr += dev->addr_len; 771 memcpy(&sip, arp_ptr, 4); 772 arp_ptr += 4; 773 arp_ptr += dev->addr_len; 774 memcpy(&tip, arp_ptr, 4); 775 /* 776 * Check for bad requests for 127.x.x.x and requests for multicast 777 * addresses. If this is one such, delete it. 778 */ 779 if (ipv4_is_loopback(tip) || ipv4_is_multicast(tip)) 780 goto out; 781 782 /* 783 * Special case: We must set Frame Relay source Q.922 address 784 */ 785 if (dev_type == ARPHRD_DLCI) 786 sha = dev->broadcast; 787 788 /* 789 * Process entry. The idea here is we want to send a reply if it is a 790 * request for us or if it is a request for someone else that we hold 791 * a proxy for. We want to add an entry to our cache if it is a reply 792 * to us or if it is a request for our address. 793 * (The assumption for this last is that if someone is requesting our 794 * address, they are probably intending to talk to us, so it saves time 795 * if we cache their address. Their address is also probably not in 796 * our cache, since ours is not in their cache.) 797 * 798 * Putting this another way, we only care about replies if they are to 799 * us, in which case we add them to the cache. For requests, we care 800 * about those for us and those for our proxies. We reply to both, 801 * and in the case of requests for us we add the requester to the arp 802 * cache. 803 */ 804 805 /* Special case: IPv4 duplicate address detection packet (RFC2131) */ 806 if (sip == 0) { 807 if (arp->ar_op == htons(ARPOP_REQUEST) && 808 inet_addr_type(&init_net, tip) == RTN_LOCAL && 809 !arp_ignore(in_dev, sip, tip)) 810 arp_send(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha, 811 dev->dev_addr, sha); 812 goto out; 813 } 814 815 if (arp->ar_op == htons(ARPOP_REQUEST) && 816 ip_route_input(skb, tip, sip, 0, dev) == 0) { 817 818 rt = (struct rtable*)skb->dst; 819 addr_type = rt->rt_type; 820 821 if (addr_type == RTN_LOCAL) { 822 n = neigh_event_ns(&arp_tbl, sha, &sip, dev); 823 if (n) { 824 int dont_send = 0; 825 826 if (!dont_send) 827 dont_send |= arp_ignore(in_dev,sip,tip); 828 if (!dont_send && IN_DEV_ARPFILTER(in_dev)) 829 dont_send |= arp_filter(sip,tip,dev); 830 if (!dont_send) 831 arp_send(ARPOP_REPLY,ETH_P_ARP,sip,dev,tip,sha,dev->dev_addr,sha); 832 833 neigh_release(n); 834 } 835 goto out; 836 } else if (IN_DEV_FORWARD(in_dev)) { 837 if (addr_type == RTN_UNICAST && rt->u.dst.dev != dev && 838 (arp_fwd_proxy(in_dev, rt) || pneigh_lookup(&arp_tbl, &init_net, &tip, dev, 0))) { 839 n = neigh_event_ns(&arp_tbl, sha, &sip, dev); 840 if (n) 841 neigh_release(n); 842 843 if (NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED || 844 skb->pkt_type == PACKET_HOST || 845 in_dev->arp_parms->proxy_delay == 0) { 846 arp_send(ARPOP_REPLY,ETH_P_ARP,sip,dev,tip,sha,dev->dev_addr,sha); 847 } else { 848 pneigh_enqueue(&arp_tbl, in_dev->arp_parms, skb); 849 in_dev_put(in_dev); 850 return 0; 851 } 852 goto out; 853 } 854 } 855 } 856 857 /* Update our ARP tables */ 858 859 n = __neigh_lookup(&arp_tbl, &sip, dev, 0); 860 861 if (IPV4_DEVCONF_ALL(dev->nd_net, ARP_ACCEPT)) { 862 /* Unsolicited ARP is not accepted by default. 863 It is possible, that this option should be enabled for some 864 devices (strip is candidate) 865 */ 866 if (n == NULL && 867 arp->ar_op == htons(ARPOP_REPLY) && 868 inet_addr_type(&init_net, sip) == RTN_UNICAST) 869 n = __neigh_lookup(&arp_tbl, &sip, dev, 1); 870 } 871 872 if (n) { 873 int state = NUD_REACHABLE; 874 int override; 875 876 /* If several different ARP replies follows back-to-back, 877 use the FIRST one. It is possible, if several proxy 878 agents are active. Taking the first reply prevents 879 arp trashing and chooses the fastest router. 880 */ 881 override = time_after(jiffies, n->updated + n->parms->locktime); 882 883 /* Broadcast replies and request packets 884 do not assert neighbour reachability. 885 */ 886 if (arp->ar_op != htons(ARPOP_REPLY) || 887 skb->pkt_type != PACKET_HOST) 888 state = NUD_STALE; 889 neigh_update(n, sha, state, override ? NEIGH_UPDATE_F_OVERRIDE : 0); 890 neigh_release(n); 891 } 892 893 out: 894 if (in_dev) 895 in_dev_put(in_dev); 896 kfree_skb(skb); 897 return 0; 898 } 899 900 static void parp_redo(struct sk_buff *skb) 901 { 902 arp_process(skb); 903 } 904 905 906 /* 907 * Receive an arp request from the device layer. 908 */ 909 910 static int arp_rcv(struct sk_buff *skb, struct net_device *dev, 911 struct packet_type *pt, struct net_device *orig_dev) 912 { 913 struct arphdr *arp; 914 915 if (dev->nd_net != &init_net) 916 goto freeskb; 917 918 /* ARP header, plus 2 device addresses, plus 2 IP addresses. */ 919 if (!pskb_may_pull(skb, (sizeof(struct arphdr) + 920 (2 * dev->addr_len) + 921 (2 * sizeof(u32))))) 922 goto freeskb; 923 924 arp = arp_hdr(skb); 925 if (arp->ar_hln != dev->addr_len || 926 dev->flags & IFF_NOARP || 927 skb->pkt_type == PACKET_OTHERHOST || 928 skb->pkt_type == PACKET_LOOPBACK || 929 arp->ar_pln != 4) 930 goto freeskb; 931 932 if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL) 933 goto out_of_mem; 934 935 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb)); 936 937 return NF_HOOK(NF_ARP, NF_ARP_IN, skb, dev, NULL, arp_process); 938 939 freeskb: 940 kfree_skb(skb); 941 out_of_mem: 942 return 0; 943 } 944 945 /* 946 * User level interface (ioctl) 947 */ 948 949 /* 950 * Set (create) an ARP cache entry. 951 */ 952 953 static int arp_req_set_proxy(struct net *net, struct net_device *dev, int on) 954 { 955 if (dev == NULL) { 956 IPV4_DEVCONF_ALL(net, PROXY_ARP) = on; 957 return 0; 958 } 959 if (__in_dev_get_rtnl(dev)) { 960 IN_DEV_CONF_SET(__in_dev_get_rtnl(dev), PROXY_ARP, on); 961 return 0; 962 } 963 return -ENXIO; 964 } 965 966 static int arp_req_set_public(struct net *net, struct arpreq *r, 967 struct net_device *dev) 968 { 969 __be32 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr; 970 __be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr; 971 972 if (mask && mask != htonl(0xFFFFFFFF)) 973 return -EINVAL; 974 if (!dev && (r->arp_flags & ATF_COM)) { 975 dev = dev_getbyhwaddr(net, r->arp_ha.sa_family, 976 r->arp_ha.sa_data); 977 if (!dev) 978 return -ENODEV; 979 } 980 if (mask) { 981 if (pneigh_lookup(&arp_tbl, net, &ip, dev, 1) == NULL) 982 return -ENOBUFS; 983 return 0; 984 } 985 986 return arp_req_set_proxy(net, dev, 1); 987 } 988 989 static int arp_req_set(struct net *net, struct arpreq *r, 990 struct net_device * dev) 991 { 992 __be32 ip; 993 struct neighbour *neigh; 994 int err; 995 996 if (r->arp_flags & ATF_PUBL) 997 return arp_req_set_public(net, r, dev); 998 999 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr; 1000 if (r->arp_flags & ATF_PERM) 1001 r->arp_flags |= ATF_COM; 1002 if (dev == NULL) { 1003 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = ip, 1004 .tos = RTO_ONLINK } } }; 1005 struct rtable * rt; 1006 if ((err = ip_route_output_key(net, &rt, &fl)) != 0) 1007 return err; 1008 dev = rt->u.dst.dev; 1009 ip_rt_put(rt); 1010 if (!dev) 1011 return -EINVAL; 1012 } 1013 switch (dev->type) { 1014 #ifdef CONFIG_FDDI 1015 case ARPHRD_FDDI: 1016 /* 1017 * According to RFC 1390, FDDI devices should accept ARP 1018 * hardware types of 1 (Ethernet). However, to be more 1019 * robust, we'll accept hardware types of either 1 (Ethernet) 1020 * or 6 (IEEE 802.2). 1021 */ 1022 if (r->arp_ha.sa_family != ARPHRD_FDDI && 1023 r->arp_ha.sa_family != ARPHRD_ETHER && 1024 r->arp_ha.sa_family != ARPHRD_IEEE802) 1025 return -EINVAL; 1026 break; 1027 #endif 1028 default: 1029 if (r->arp_ha.sa_family != dev->type) 1030 return -EINVAL; 1031 break; 1032 } 1033 1034 neigh = __neigh_lookup_errno(&arp_tbl, &ip, dev); 1035 err = PTR_ERR(neigh); 1036 if (!IS_ERR(neigh)) { 1037 unsigned state = NUD_STALE; 1038 if (r->arp_flags & ATF_PERM) 1039 state = NUD_PERMANENT; 1040 err = neigh_update(neigh, (r->arp_flags&ATF_COM) ? 1041 r->arp_ha.sa_data : NULL, state, 1042 NEIGH_UPDATE_F_OVERRIDE| 1043 NEIGH_UPDATE_F_ADMIN); 1044 neigh_release(neigh); 1045 } 1046 return err; 1047 } 1048 1049 static unsigned arp_state_to_flags(struct neighbour *neigh) 1050 { 1051 unsigned flags = 0; 1052 if (neigh->nud_state&NUD_PERMANENT) 1053 flags = ATF_PERM|ATF_COM; 1054 else if (neigh->nud_state&NUD_VALID) 1055 flags = ATF_COM; 1056 return flags; 1057 } 1058 1059 /* 1060 * Get an ARP cache entry. 1061 */ 1062 1063 static int arp_req_get(struct arpreq *r, struct net_device *dev) 1064 { 1065 __be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr; 1066 struct neighbour *neigh; 1067 int err = -ENXIO; 1068 1069 neigh = neigh_lookup(&arp_tbl, &ip, dev); 1070 if (neigh) { 1071 read_lock_bh(&neigh->lock); 1072 memcpy(r->arp_ha.sa_data, neigh->ha, dev->addr_len); 1073 r->arp_flags = arp_state_to_flags(neigh); 1074 read_unlock_bh(&neigh->lock); 1075 r->arp_ha.sa_family = dev->type; 1076 strlcpy(r->arp_dev, dev->name, sizeof(r->arp_dev)); 1077 neigh_release(neigh); 1078 err = 0; 1079 } 1080 return err; 1081 } 1082 1083 static int arp_req_delete_public(struct net *net, struct arpreq *r, 1084 struct net_device *dev) 1085 { 1086 __be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr; 1087 __be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr; 1088 1089 if (mask == htonl(0xFFFFFFFF)) 1090 return pneigh_delete(&arp_tbl, net, &ip, dev); 1091 1092 if (mask) 1093 return -EINVAL; 1094 1095 return arp_req_set_proxy(net, dev, 0); 1096 } 1097 1098 static int arp_req_delete(struct net *net, struct arpreq *r, 1099 struct net_device * dev) 1100 { 1101 int err; 1102 __be32 ip; 1103 struct neighbour *neigh; 1104 1105 if (r->arp_flags & ATF_PUBL) 1106 return arp_req_delete_public(net, r, dev); 1107 1108 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr; 1109 if (dev == NULL) { 1110 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = ip, 1111 .tos = RTO_ONLINK } } }; 1112 struct rtable * rt; 1113 if ((err = ip_route_output_key(net, &rt, &fl)) != 0) 1114 return err; 1115 dev = rt->u.dst.dev; 1116 ip_rt_put(rt); 1117 if (!dev) 1118 return -EINVAL; 1119 } 1120 err = -ENXIO; 1121 neigh = neigh_lookup(&arp_tbl, &ip, dev); 1122 if (neigh) { 1123 if (neigh->nud_state&~NUD_NOARP) 1124 err = neigh_update(neigh, NULL, NUD_FAILED, 1125 NEIGH_UPDATE_F_OVERRIDE| 1126 NEIGH_UPDATE_F_ADMIN); 1127 neigh_release(neigh); 1128 } 1129 return err; 1130 } 1131 1132 /* 1133 * Handle an ARP layer I/O control request. 1134 */ 1135 1136 int arp_ioctl(struct net *net, unsigned int cmd, void __user *arg) 1137 { 1138 int err; 1139 struct arpreq r; 1140 struct net_device *dev = NULL; 1141 1142 switch (cmd) { 1143 case SIOCDARP: 1144 case SIOCSARP: 1145 if (!capable(CAP_NET_ADMIN)) 1146 return -EPERM; 1147 case SIOCGARP: 1148 err = copy_from_user(&r, arg, sizeof(struct arpreq)); 1149 if (err) 1150 return -EFAULT; 1151 break; 1152 default: 1153 return -EINVAL; 1154 } 1155 1156 if (r.arp_pa.sa_family != AF_INET) 1157 return -EPFNOSUPPORT; 1158 1159 if (!(r.arp_flags & ATF_PUBL) && 1160 (r.arp_flags & (ATF_NETMASK|ATF_DONTPUB))) 1161 return -EINVAL; 1162 if (!(r.arp_flags & ATF_NETMASK)) 1163 ((struct sockaddr_in *)&r.arp_netmask)->sin_addr.s_addr = 1164 htonl(0xFFFFFFFFUL); 1165 rtnl_lock(); 1166 if (r.arp_dev[0]) { 1167 err = -ENODEV; 1168 if ((dev = __dev_get_by_name(net, r.arp_dev)) == NULL) 1169 goto out; 1170 1171 /* Mmmm... It is wrong... ARPHRD_NETROM==0 */ 1172 if (!r.arp_ha.sa_family) 1173 r.arp_ha.sa_family = dev->type; 1174 err = -EINVAL; 1175 if ((r.arp_flags & ATF_COM) && r.arp_ha.sa_family != dev->type) 1176 goto out; 1177 } else if (cmd == SIOCGARP) { 1178 err = -ENODEV; 1179 goto out; 1180 } 1181 1182 switch (cmd) { 1183 case SIOCDARP: 1184 err = arp_req_delete(net, &r, dev); 1185 break; 1186 case SIOCSARP: 1187 err = arp_req_set(net, &r, dev); 1188 break; 1189 case SIOCGARP: 1190 err = arp_req_get(&r, dev); 1191 if (!err && copy_to_user(arg, &r, sizeof(r))) 1192 err = -EFAULT; 1193 break; 1194 } 1195 out: 1196 rtnl_unlock(); 1197 return err; 1198 } 1199 1200 static int arp_netdev_event(struct notifier_block *this, unsigned long event, void *ptr) 1201 { 1202 struct net_device *dev = ptr; 1203 1204 if (dev->nd_net != &init_net) 1205 return NOTIFY_DONE; 1206 1207 switch (event) { 1208 case NETDEV_CHANGEADDR: 1209 neigh_changeaddr(&arp_tbl, dev); 1210 rt_cache_flush(0); 1211 break; 1212 default: 1213 break; 1214 } 1215 1216 return NOTIFY_DONE; 1217 } 1218 1219 static struct notifier_block arp_netdev_notifier = { 1220 .notifier_call = arp_netdev_event, 1221 }; 1222 1223 /* Note, that it is not on notifier chain. 1224 It is necessary, that this routine was called after route cache will be 1225 flushed. 1226 */ 1227 void arp_ifdown(struct net_device *dev) 1228 { 1229 neigh_ifdown(&arp_tbl, dev); 1230 } 1231 1232 1233 /* 1234 * Called once on startup. 1235 */ 1236 1237 static struct packet_type arp_packet_type = { 1238 .type = __constant_htons(ETH_P_ARP), 1239 .func = arp_rcv, 1240 }; 1241 1242 static int arp_proc_init(void); 1243 1244 void __init arp_init(void) 1245 { 1246 neigh_table_init(&arp_tbl); 1247 1248 dev_add_pack(&arp_packet_type); 1249 arp_proc_init(); 1250 #ifdef CONFIG_SYSCTL 1251 neigh_sysctl_register(NULL, &arp_tbl.parms, NET_IPV4, 1252 NET_IPV4_NEIGH, "ipv4", NULL, NULL); 1253 #endif 1254 register_netdevice_notifier(&arp_netdev_notifier); 1255 } 1256 1257 #ifdef CONFIG_PROC_FS 1258 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE) 1259 1260 /* ------------------------------------------------------------------------ */ 1261 /* 1262 * ax25 -> ASCII conversion 1263 */ 1264 static char *ax2asc2(ax25_address *a, char *buf) 1265 { 1266 char c, *s; 1267 int n; 1268 1269 for (n = 0, s = buf; n < 6; n++) { 1270 c = (a->ax25_call[n] >> 1) & 0x7F; 1271 1272 if (c != ' ') *s++ = c; 1273 } 1274 1275 *s++ = '-'; 1276 1277 if ((n = ((a->ax25_call[6] >> 1) & 0x0F)) > 9) { 1278 *s++ = '1'; 1279 n -= 10; 1280 } 1281 1282 *s++ = n + '0'; 1283 *s++ = '\0'; 1284 1285 if (*buf == '\0' || *buf == '-') 1286 return "*"; 1287 1288 return buf; 1289 1290 } 1291 #endif /* CONFIG_AX25 */ 1292 1293 #define HBUFFERLEN 30 1294 1295 static void arp_format_neigh_entry(struct seq_file *seq, 1296 struct neighbour *n) 1297 { 1298 char hbuffer[HBUFFERLEN]; 1299 const char hexbuf[] = "0123456789ABCDEF"; 1300 int k, j; 1301 char tbuf[16]; 1302 struct net_device *dev = n->dev; 1303 int hatype = dev->type; 1304 1305 read_lock(&n->lock); 1306 /* Convert hardware address to XX:XX:XX:XX ... form. */ 1307 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE) 1308 if (hatype == ARPHRD_AX25 || hatype == ARPHRD_NETROM) 1309 ax2asc2((ax25_address *)n->ha, hbuffer); 1310 else { 1311 #endif 1312 for (k = 0, j = 0; k < HBUFFERLEN - 3 && j < dev->addr_len; j++) { 1313 hbuffer[k++] = hexbuf[(n->ha[j] >> 4) & 15]; 1314 hbuffer[k++] = hexbuf[n->ha[j] & 15]; 1315 hbuffer[k++] = ':'; 1316 } 1317 hbuffer[--k] = 0; 1318 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE) 1319 } 1320 #endif 1321 sprintf(tbuf, "%u.%u.%u.%u", NIPQUAD(*(u32*)n->primary_key)); 1322 seq_printf(seq, "%-16s 0x%-10x0x%-10x%s * %s\n", 1323 tbuf, hatype, arp_state_to_flags(n), hbuffer, dev->name); 1324 read_unlock(&n->lock); 1325 } 1326 1327 static void arp_format_pneigh_entry(struct seq_file *seq, 1328 struct pneigh_entry *n) 1329 { 1330 struct net_device *dev = n->dev; 1331 int hatype = dev ? dev->type : 0; 1332 char tbuf[16]; 1333 1334 sprintf(tbuf, "%u.%u.%u.%u", NIPQUAD(*(u32*)n->key)); 1335 seq_printf(seq, "%-16s 0x%-10x0x%-10x%s * %s\n", 1336 tbuf, hatype, ATF_PUBL | ATF_PERM, "00:00:00:00:00:00", 1337 dev ? dev->name : "*"); 1338 } 1339 1340 static int arp_seq_show(struct seq_file *seq, void *v) 1341 { 1342 if (v == SEQ_START_TOKEN) { 1343 seq_puts(seq, "IP address HW type Flags " 1344 "HW address Mask Device\n"); 1345 } else { 1346 struct neigh_seq_state *state = seq->private; 1347 1348 if (state->flags & NEIGH_SEQ_IS_PNEIGH) 1349 arp_format_pneigh_entry(seq, v); 1350 else 1351 arp_format_neigh_entry(seq, v); 1352 } 1353 1354 return 0; 1355 } 1356 1357 static void *arp_seq_start(struct seq_file *seq, loff_t *pos) 1358 { 1359 /* Don't want to confuse "arp -a" w/ magic entries, 1360 * so we tell the generic iterator to skip NUD_NOARP. 1361 */ 1362 return neigh_seq_start(seq, pos, &arp_tbl, NEIGH_SEQ_SKIP_NOARP); 1363 } 1364 1365 /* ------------------------------------------------------------------------ */ 1366 1367 static const struct seq_operations arp_seq_ops = { 1368 .start = arp_seq_start, 1369 .next = neigh_seq_next, 1370 .stop = neigh_seq_stop, 1371 .show = arp_seq_show, 1372 }; 1373 1374 static int arp_seq_open(struct inode *inode, struct file *file) 1375 { 1376 return seq_open_net(inode, file, &arp_seq_ops, 1377 sizeof(struct neigh_seq_state)); 1378 } 1379 1380 static const struct file_operations arp_seq_fops = { 1381 .owner = THIS_MODULE, 1382 .open = arp_seq_open, 1383 .read = seq_read, 1384 .llseek = seq_lseek, 1385 .release = seq_release_net, 1386 }; 1387 1388 static int __init arp_proc_init(void) 1389 { 1390 if (!proc_net_fops_create(&init_net, "arp", S_IRUGO, &arp_seq_fops)) 1391 return -ENOMEM; 1392 return 0; 1393 } 1394 1395 #else /* CONFIG_PROC_FS */ 1396 1397 static int __init arp_proc_init(void) 1398 { 1399 return 0; 1400 } 1401 1402 #endif /* CONFIG_PROC_FS */ 1403 1404 EXPORT_SYMBOL(arp_broken_ops); 1405 EXPORT_SYMBOL(arp_find); 1406 EXPORT_SYMBOL(arp_create); 1407 EXPORT_SYMBOL(arp_xmit); 1408 EXPORT_SYMBOL(arp_send); 1409 EXPORT_SYMBOL(arp_tbl); 1410 1411 #if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE) 1412 EXPORT_SYMBOL(clip_tbl_hook); 1413 #endif 1414