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