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