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