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