开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
arp.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：30k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

arp.c：源码内容
  1. /* linux/net/inet/arp.c
  2.  *
  3.  * Version: $Id: arp.c,v 1.99 2001/08/30 22:55:42 davem Exp $
  4.  *
  5.  * Copyright (C) 1994 by Florian  La Roche
  6.  *
  7.  * This module implements the Address Resolution Protocol ARP (RFC 826),
  8.  * which is used to convert IP addresses (or in the future maybe other
  9.  * high-level addresses) into a low-level hardware address (like an Ethernet
  10.  * address).
  11.  *
  12.  * This program is free software; you can redistribute it and/or
  13.  * modify it under the terms of the GNU General Public License
  14.  * as published by the Free Software Foundation; either version
  15.  * 2 of the License, or (at your option) any later version.
  16.  *
  17.  * Fixes:
  18.  * Alan Cox : Removed the Ethernet assumptions in 
  19.  * Florian's code
  20.  * Alan Cox : Fixed some small errors in the ARP 
  21.  * logic
  22.  * Alan Cox : Allow >4K in /proc
  23.  * Alan Cox : Make ARP add its own protocol entry
  24.  * Ross Martin     :       Rewrote arp_rcv() and arp_get_info()
  25.  * Stephen Henson : Add AX25 support to arp_get_info()
  26.  * Alan Cox : Drop data when a device is downed.
  27.  * Alan Cox : Use init_timer().
  28.  * Alan Cox : Double lock fixes.
  29.  * Martin Seine : Move the arphdr structure
  30.  * to if_arp.h for compatibility.
  31.  * with BSD based programs.
  32.  * Andrew Tridgell :       Added ARP netmask code and
  33.  * re-arranged proxy handling.
  34.  * Alan Cox : Changed to use notifiers.
  35.  * Niibe Yutaka : Reply for this device or proxies only.
  36.  * Alan Cox : Don't proxy across hardware types!
  37.  * Jonathan Naylor : Added support for NET/ROM.
  38.  * Mike Shaver     :       RFC1122 checks.
  39.  * Jonathan Naylor : Only lookup the hardware address for
  40.  * the correct hardware type.
  41.  * Germano Caronni : Assorted subtle races.
  42.  * Craig Schlenter : Don't modify permanent entry 
  43.  * during arp_rcv.
  44.  * Russ Nelson : Tidied up a few bits.
  45.  * Alexey Kuznetsov: Major changes to caching and behaviour,
  46.  * eg intelligent arp probing and 
  47.  * generation
  48.  * of host down events.
  49.  * Alan Cox : Missing unlock in device events.
  50.  * Eckes : ARP ioctl control errors.
  51.  * Alexey Kuznetsov: Arp free fix.
  52.  * Manuel Rodriguez: Gratuitous ARP.
  53.  *              Jonathan Layes  :       Added arpd support through kerneld 
  54.  *                                      message queue (960314)
  55.  * Mike Shaver : /proc/sys/net/ipv4/arp_* support
  56.  * Mike McLagan    : Routing by source
  57.  * Stuart Cheshire : Metricom and grat arp fixes
  58.  * *** FOR 2.1 clean this up ***
  59.  * Lawrence V. Stefani: (08/12/96) Added FDDI support.
  60.  * Alan Cox  : Took the AP1000 nasty FDDI hack and
  61.  * folded into the mainstream FDDI code.
  62.  * Ack spit, Linus how did you allow that
  63.  * one in...
  64.  * Jes Sorensen : Make FDDI work again in 2.1.x and
  65.  * clean up the APFDDI & gen. FDDI bits.
  66.  * Alexey Kuznetsov: new arp state machine;
  67.  * now it is in net/core/neighbour.c.
  68.  * Krzysztof Halasa: Added Frame Relay ARP support.
  69.  */
  71. #include <linux/types.h>
  72. #include <linux/string.h>
  73. #include <linux/kernel.h>
  74. #include <linux/sched.h>
  75. #include <linux/config.h>
  76. #include <linux/socket.h>
  77. #include <linux/sockios.h>
  78. #include <linux/errno.h>
  79. #include <linux/in.h>
  80. #include <linux/mm.h>
  81. #include <linux/inet.h>
  82. #include <linux/netdevice.h>
  83. #include <linux/etherdevice.h>
  84. #include <linux/fddidevice.h>
  85. #include <linux/if_arp.h>
  86. #include <linux/trdevice.h>
  87. #include <linux/skbuff.h>
  88. #include <linux/proc_fs.h>
  89. #include <linux/stat.h>
  90. #include <linux/init.h>
  91. #ifdef CONFIG_SYSCTL
  92. #include <linux/sysctl.h>
  93. #endif
  95. #include <net/ip.h>
  96. #include <net/icmp.h>
  97. #include <net/route.h>
  98. #include <net/protocol.h>
  99. #include <net/tcp.h>
  100. #include <net/sock.h>
  101. #include <net/arp.h>
  102. #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  103. #include <net/ax25.h>
  104. #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
  105. #include <net/netrom.h>
  106. #endif
  107. #endif
  108. #ifdef CONFIG_ATM_CLIP
  109. #include <net/atmclip.h>
  110. #endif
  112. #include <asm/system.h>
  113. #include <asm/uaccess.h>
  117. /*
  118.  * Interface to generic neighbour cache.
  119.  */
  120. static u32 arp_hash(const void *pkey, const struct net_device *dev);
  121. static int arp_constructor(struct neighbour *neigh);
  122. static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb);
  123. static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb);
  124. static void parp_redo(struct sk_buff *skb);
  126. static struct neigh_ops arp_generic_ops = {
  127. family: AF_INET,
  128. solicit: arp_solicit,
  129. error_report: arp_error_report,
  130. output: neigh_resolve_output,
  131. connected_output: neigh_connected_output,
  132. hh_output: dev_queue_xmit,
  133. queue_xmit: dev_queue_xmit,
  134. };
  136. static struct neigh_ops arp_hh_ops = {
  137. family: AF_INET,
  138. solicit: arp_solicit,
  139. error_report: arp_error_report,
  140. output: neigh_resolve_output,
  141. connected_output: neigh_resolve_output,
  142. hh_output: dev_queue_xmit,
  143. queue_xmit: dev_queue_xmit,
  144. };
  146. static struct neigh_ops arp_direct_ops = {
  147. family: AF_INET,
  148. output: dev_queue_xmit,
  149. connected_output: dev_queue_xmit,
  150. hh_output: dev_queue_xmit,
  151. queue_xmit: dev_queue_xmit,
  152. };
  154. struct neigh_ops arp_broken_ops = {
  155. family: AF_INET,
  156. solicit: arp_solicit,
  157. error_report: arp_error_report,
  158. output: neigh_compat_output,
  159. connected_output: neigh_compat_output,
  160. hh_output: dev_queue_xmit,
  161. queue_xmit: dev_queue_xmit,
  162. };
  164. struct neigh_table arp_tbl = {
  165. family: AF_INET,
  166. entry_size: sizeof(struct neighbour) + 4,
  167. key_len: 4,
  168. hash: arp_hash,
  169. constructor: arp_constructor,
  170. proxy_redo: parp_redo,
  171. id: "arp_cache",
  172. parms: {
  173. tbl: &arp_tbl,
  174. base_reachable_time: 30 * HZ,
  175. retrans_time: 1 * HZ,
  176. gc_staletime: 60 * HZ,
  177. reachable_time: 30 * HZ,
  178. delay_probe_time: 5 * HZ,
  179. queue_len: 3,
  180. ucast_probes: 3,
  181. mcast_probes: 3,
  182. anycast_delay: 1 * HZ,
  183. proxy_delay: (8 * HZ) / 10,
  184. proxy_qlen: 64,
  185. locktime: 1 * HZ,
  186. },
  187. gc_interval: 30 * HZ,
  188. gc_thresh1: 128,
  189. gc_thresh2: 512,
  190. gc_thresh3: 1024,
  191. };
  193. int arp_mc_map(u32 addr, u8 *haddr, struct net_device *dev, int dir)
  194. {
  195. switch (dev->type) {
  196. case ARPHRD_ETHER:
  197. case ARPHRD_FDDI:
  198. case ARPHRD_IEEE802:
  199. ip_eth_mc_map(addr, haddr);
  200. return 0; 
  201. case ARPHRD_IEEE802_TR:
  202. ip_tr_mc_map(addr, haddr);
  203. return 0;
  204. default:
  205. if (dir) {
  206. memcpy(haddr, dev->broadcast, dev->addr_len);
  207. return 0;
  208. }
  209. }
  210. return -EINVAL;
  211. }
  214. static u32 arp_hash(const void *pkey, const struct net_device *dev)
  215. {
  216. u32 hash_val;
  218. hash_val = *(u32*)pkey;
  219. hash_val ^= (hash_val>>16);
  220. hash_val ^= hash_val>>8;
  221. hash_val ^= hash_val>>3;
  222. hash_val = (hash_val^dev->ifindex)&NEIGH_HASHMASK;
  224. return hash_val;
  225. }
  227. static int arp_constructor(struct neighbour *neigh)
  228. {
  229. u32 addr = *(u32*)neigh->primary_key;
  230. struct net_device *dev = neigh->dev;
  231. struct in_device *in_dev = in_dev_get(dev);
  233. if (in_dev == NULL)
  234. return -EINVAL;
  236. neigh->type = inet_addr_type(addr);
  237. if (in_dev->arp_parms)
  238. neigh->parms = in_dev->arp_parms;
  240. in_dev_put(in_dev);
  242. if (dev->hard_header == NULL) {
  243. neigh->nud_state = NUD_NOARP;
  244. neigh->ops = &arp_direct_ops;
  245. neigh->output = neigh->ops->queue_xmit;
  246. } else {
  247. /* Good devices (checked by reading texts, but only Ethernet is
  248.    tested)
  250.    ARPHRD_ETHER: (ethernet, apfddi)
  251.    ARPHRD_FDDI: (fddi)
  252.    ARPHRD_IEEE802: (tr)
  253.    ARPHRD_METRICOM: (strip)
  254.    ARPHRD_ARCNET:
  255.    etc. etc. etc.
  257.    ARPHRD_IPDDP will also work, if author repairs it.
  258.    I did not it, because this driver does not work even
  259.    in old paradigm.
  260.  */
  262. #if 1
  263. /* So... these "amateur" devices are hopeless.
  264.    The only thing, that I can say now:
  265.    It is very sad that we need to keep ugly obsolete
  266.    code to make them happy.
  268.    They should be moved to more reasonable state, now
  269.    they use rebuild_header INSTEAD OF hard_start_xmit!!!
  270.    Besides that, they are sort of out of date
  271.    (a lot of redundant clones/copies, useless in 2.1),
  272.    I wonder why people believe that they work.
  273.  */
  274. switch (dev->type) {
  275. default:
  276. break;
  277. case ARPHRD_ROSE:
  278. #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  279. case ARPHRD_AX25:
  280. #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
  281. case ARPHRD_NETROM:
  282. #endif
  283. neigh->ops = &arp_broken_ops;
  284. neigh->output = neigh->ops->output;
  285. return 0;
  286. #endif
  287. ;}
  288. #endif
  289. if (neigh->type == RTN_MULTICAST) {
  290. neigh->nud_state = NUD_NOARP;
  291. arp_mc_map(addr, neigh->ha, dev, 1);
  292. } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
  293. neigh->nud_state = NUD_NOARP;
  294. memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
  295. } else if (neigh->type == RTN_BROADCAST || dev->flags&IFF_POINTOPOINT) {
  296. neigh->nud_state = NUD_NOARP;
  297. memcpy(neigh->ha, dev->broadcast, dev->addr_len);
  298. }
  299. if (dev->hard_header_cache)
  300. neigh->ops = &arp_hh_ops;
  301. else
  302. neigh->ops = &arp_generic_ops;
  303. if (neigh->nud_state&NUD_VALID)
  304. neigh->output = neigh->ops->connected_output;
  305. else
  306. neigh->output = neigh->ops->output;
  307. }
  308. return 0;
  309. }
  311. static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb)
  312. {
  313. dst_link_failure(skb);
  314. kfree_skb(skb);
  315. }
  317. static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb)
  318. {
  319. u32 saddr;
  320. u8  *dst_ha = NULL;
  321. struct net_device *dev = neigh->dev;
  322. u32 target = *(u32*)neigh->primary_key;
  323. int probes = atomic_read(&neigh->probes);
  325. if (skb && inet_addr_type(skb->nh.iph->saddr) == RTN_LOCAL)
  326. saddr = skb->nh.iph->saddr;
  327. else
  328. saddr = inet_select_addr(dev, target, RT_SCOPE_LINK);
  330. if ((probes -= neigh->parms->ucast_probes) < 0) {
  331. if (!(neigh->nud_state&NUD_VALID))
  332. printk(KERN_DEBUG "trying to ucast probe in NUD_INVALIDn");
  333. dst_ha = neigh->ha;
  334. read_lock_bh(&neigh->lock);
  335. } else if ((probes -= neigh->parms->app_probes) < 0) {
  336. #ifdef CONFIG_ARPD
  337. neigh_app_ns(neigh);
  338. #endif
  339. return;
  340. }
  342. arp_send(ARPOP_REQUEST, ETH_P_ARP, target, dev, saddr,
  343.  dst_ha, dev->dev_addr, NULL);
  344. if (dst_ha)
  345. read_unlock_bh(&neigh->lock);
  346. }
  348. static int arp_filter(__u32 sip, __u32 tip, struct net_device *dev)
  349. {
  350. struct rtable *rt;
  351. int flag = 0; 
  352. /*unsigned long now; */
  354. if (ip_route_output(&rt, sip, tip, 0, 0) < 0) 
  355. return 1;
  356. if (rt->u.dst.dev != dev) { 
  357. NET_INC_STATS_BH(ArpFilter);
  358. flag = 1;
  359. } 
  360. ip_rt_put(rt); 
  361. return flag; 
  362. } 
  364. /* OBSOLETE FUNCTIONS */
  366. /*
  367.  * Find an arp mapping in the cache. If not found, post a request.
  368.  *
  369.  * It is very UGLY routine: it DOES NOT use skb->dst->neighbour,
  370.  * even if it exists. It is supposed that skb->dev was mangled
  371.  * by a virtual device (eql, shaper). Nobody but broken devices
  372.  * is allowed to use this function, it is scheduled to be removed. --ANK
  373.  */
  375. static int arp_set_predefined(int addr_hint, unsigned char * haddr, u32 paddr, struct net_device * dev)
  376. {
  377. switch (addr_hint) {
  378. case RTN_LOCAL:
  379. printk(KERN_DEBUG "ARP: arp called for own IP addressn");
  380. memcpy(haddr, dev->dev_addr, dev->addr_len);
  381. return 1;
  382. case RTN_MULTICAST:
  383. arp_mc_map(paddr, haddr, dev, 1);
  384. return 1;
  385. case RTN_BROADCAST:
  386. memcpy(haddr, dev->broadcast, dev->addr_len);
  387. return 1;
  388. }
  389. return 0;
  390. }
  393. int arp_find(unsigned char *haddr, struct sk_buff *skb)
  394. {
  395. struct net_device *dev = skb->dev;
  396. u32 paddr;
  397. struct neighbour *n;
  399. if (!skb->dst) {
  400. printk(KERN_DEBUG "arp_find is called with dst==NULLn");
  401. kfree_skb(skb);
  402. return 1;
  403. }
  405. paddr = ((struct rtable*)skb->dst)->rt_gateway;
  407. if (arp_set_predefined(inet_addr_type(paddr), haddr, paddr, dev))
  408. return 0;
  410. n = __neigh_lookup(&arp_tbl, &paddr, dev, 1);
  412. if (n) {
  413. n->used = jiffies;
  414. if (n->nud_state&NUD_VALID || neigh_event_send(n, skb) == 0) {
  415. read_lock_bh(&n->lock);
  416.   memcpy(haddr, n->ha, dev->addr_len);
  417. read_unlock_bh(&n->lock);
  418. neigh_release(n);
  419. return 0;
  420. }
  421. neigh_release(n);
  422. } else
  423. kfree_skb(skb);
  424. return 1;
  425. }
  427. /* END OF OBSOLETE FUNCTIONS */
  429. int arp_bind_neighbour(struct dst_entry *dst)
  430. {
  431. struct net_device *dev = dst->dev;
  432. struct neighbour *n = dst->neighbour;
  434. if (dev == NULL)
  435. return -EINVAL;
  436. if (n == NULL) {
  437. u32 nexthop = ((struct rtable*)dst)->rt_gateway;
  438. if (dev->flags&(IFF_LOOPBACK|IFF_POINTOPOINT))
  439. nexthop = 0;
  440. n = __neigh_lookup_errno(
  441. #ifdef CONFIG_ATM_CLIP
  442.     dev->type == ARPHRD_ATM ? &clip_tbl :
  443. #endif
  444.     &arp_tbl, &nexthop, dev);
  445. if (IS_ERR(n))
  446. return PTR_ERR(n);
  447. dst->neighbour = n;
  448. }
  449. return 0;
  450. }
  452. /*
  453.  * Interface to link layer: send routine and receive handler.
  454.  */
  456. /*
  457.  * Create and send an arp packet. If (dest_hw == NULL), we create a broadcast
  458.  * message.
  459.  */
  461. void arp_send(int type, int ptype, u32 dest_ip, 
  462.       struct net_device *dev, u32 src_ip, 
  463.       unsigned char *dest_hw, unsigned char *src_hw,
  464.       unsigned char *target_hw)
  465. {
  466. struct sk_buff *skb;
  467. struct arphdr *arp;
  468. unsigned char *arp_ptr;
  470. /*
  471.  * No arp on this interface.
  472.  */
  474. if (dev->flags&IFF_NOARP)
  475. return;
  477. /*
  478.  * Allocate a buffer
  479.  */
  481. skb = alloc_skb(sizeof(struct arphdr)+ 2*(dev->addr_len+4)
  482. + dev->hard_header_len + 15, GFP_ATOMIC);
  483. if (skb == NULL)
  484. return;
  486. skb_reserve(skb, (dev->hard_header_len+15)&~15);
  487. skb->nh.raw = skb->data;
  488. arp = (struct arphdr *) skb_put(skb,sizeof(struct arphdr) + 2*(dev->addr_len+4));
  489. skb->dev = dev;
  490. skb->protocol = __constant_htons (ETH_P_ARP);
  491. if (src_hw == NULL)
  492. src_hw = dev->dev_addr;
  493. if (dest_hw == NULL)
  494. dest_hw = dev->broadcast;
  496. /*
  497.  * Fill the device header for the ARP frame
  498.  */
  499. if (dev->hard_header &&
  500.     dev->hard_header(skb,dev,ptype,dest_hw,src_hw,skb->len) < 0)
  501. goto out;
  503. /*
  504.  * Fill out the arp protocol part.
  505.  *
  506.  * The arp hardware type should match the device type, except for FDDI,
  507.  * which (according to RFC 1390) should always equal 1 (Ethernet).
  508.  */
  509. /*
  510.  * Exceptions everywhere. AX.25 uses the AX.25 PID value not the
  511.  * DIX code for the protocol. Make these device structure fields.
  512.  */
  513. switch (dev->type) {
  514. default:
  515. arp->ar_hrd = htons(dev->type);
  516. arp->ar_pro = __constant_htons(ETH_P_IP);
  517. break;
  519. #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  520. case ARPHRD_AX25:
  521. arp->ar_hrd = __constant_htons(ARPHRD_AX25);
  522. arp->ar_pro = __constant_htons(AX25_P_IP);
  523. break;
  525. #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
  526. case ARPHRD_NETROM:
  527. arp->ar_hrd = __constant_htons(ARPHRD_NETROM);
  528. arp->ar_pro = __constant_htons(AX25_P_IP);
  529. break;
  530. #endif
  531. #endif
  533. #ifdef CONFIG_FDDI
  534. case ARPHRD_FDDI:
  535. arp->ar_hrd = __constant_htons(ARPHRD_ETHER);
  536. arp->ar_pro = __constant_htons(ETH_P_IP);
  537. break;
  538. #endif
  539. #ifdef CONFIG_TR
  540. case ARPHRD_IEEE802_TR:
  541. arp->ar_hrd = __constant_htons(ARPHRD_IEEE802);
  542. arp->ar_pro = __constant_htons(ETH_P_IP);
  543. break;
  544. #endif
  545. }
  547. arp->ar_hln = dev->addr_len;
  548. arp->ar_pln = 4;
  549. arp->ar_op = htons(type);
  551. arp_ptr=(unsigned char *)(arp+1);
  553. memcpy(arp_ptr, src_hw, dev->addr_len);
  554. arp_ptr+=dev->addr_len;
  555. memcpy(arp_ptr, &src_ip,4);
  556. arp_ptr+=4;
  557. if (target_hw != NULL)
  558. memcpy(arp_ptr, target_hw, dev->addr_len);
  559. else
  560. memset(arp_ptr, 0, dev->addr_len);
  561. arp_ptr+=dev->addr_len;
  562. memcpy(arp_ptr, &dest_ip, 4);
  564. dev_queue_xmit(skb);
  565. return;
  567. out:
  568. kfree_skb(skb);
  569. }
  571. static void parp_redo(struct sk_buff *skb)
  572. {
  573. arp_rcv(skb, skb->dev, NULL);
  574. }
  576. /*
  577.  * Receive an arp request by the device layer.
  578.  */
  580. int arp_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt)
  581. {
  582. struct arphdr *arp = skb->nh.arph;
  583. unsigned char *arp_ptr= (unsigned char *)(arp+1);
  584. struct rtable *rt;
  585. unsigned char *sha, *tha;
  586. u32 sip, tip;
  587. u16 dev_type = dev->type;
  588. int addr_type;
  589. struct in_device *in_dev = in_dev_get(dev);
  590. struct neighbour *n;
  592. /*
  593.  * The hardware length of the packet should match the hardware length
  594.  * of the device.  Similarly, the hardware types should match.  The
  595.  * device should be ARP-able.  Also, if pln is not 4, then the lookup
  596.  * is not from an IP number.  We can't currently handle this, so toss
  597.  * it. 
  598.  */  
  599. if (in_dev == NULL ||
  600.     arp->ar_hln != dev->addr_len    || 
  601.     dev->flags & IFF_NOARP ||
  602.     skb->pkt_type == PACKET_OTHERHOST ||
  603.     skb->pkt_type == PACKET_LOOPBACK ||
  604.     arp->ar_pln != 4)
  605. goto out;
  607. if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
  608. goto out_of_mem;
  610. if (skb_is_nonlinear(skb)) {
  611. if (skb_linearize(skb, GFP_ATOMIC) != 0)
  612. goto freeskb;
  613. arp = skb->nh.arph;
  614. arp_ptr= (unsigned char *)(arp+1);
  615. }
  617. switch (dev_type) {
  618. default:
  619. if (arp->ar_pro != __constant_htons(ETH_P_IP))
  620. goto out;
  621. if (htons(dev_type) != arp->ar_hrd)
  622. goto out;
  623. break;
  624. #ifdef CONFIG_NET_ETHERNET
  625. case ARPHRD_ETHER:
  626. /*
  627.  * ETHERNET devices will accept ARP hardware types of either
  628.  * 1 (Ethernet) or 6 (IEEE 802.2).
  629.  */
  630. if (arp->ar_hrd != __constant_htons(ARPHRD_ETHER) &&
  631.     arp->ar_hrd != __constant_htons(ARPHRD_IEEE802))
  632. goto out;
  633. if (arp->ar_pro != __constant_htons(ETH_P_IP))
  634. goto out;
  635. break;
  636. #endif
  637. #ifdef CONFIG_TR
  638. case ARPHRD_IEEE802_TR:
  639. /*
  640.  * Token ring devices will accept ARP hardware types of either
  641.  * 1 (Ethernet) or 6 (IEEE 802.2).
  642.  */
  643. if (arp->ar_hrd != __constant_htons(ARPHRD_ETHER) &&
  644.     arp->ar_hrd != __constant_htons(ARPHRD_IEEE802))
  645. goto out;
  646. if (arp->ar_pro != __constant_htons(ETH_P_IP))
  647. goto out;
  648. break;
  649. #endif
  650. #ifdef CONFIG_FDDI
  651. case ARPHRD_FDDI:
  652. /*
  653.  * According to RFC 1390, FDDI devices should accept ARP hardware types
  654.  * of 1 (Ethernet).  However, to be more robust, we'll accept hardware
  655.  * types of either 1 (Ethernet) or 6 (IEEE 802.2).
  656.  */
  657. if (arp->ar_hrd != __constant_htons(ARPHRD_ETHER) &&
  658.     arp->ar_hrd != __constant_htons(ARPHRD_IEEE802))
  659. goto out;
  660. if (arp->ar_pro != __constant_htons(ETH_P_IP))
  661. goto out;
  662. break;
  663. #endif
  664. #ifdef CONFIG_NET_FC
  665. case ARPHRD_IEEE802:
  666. /*
  667.  * According to RFC 2625, Fibre Channel devices (which are IEEE
  668.  * 802 devices) should accept ARP hardware types of 6 (IEEE 802)
  669.  * and 1 (Ethernet).
  670.  */
  671. if (arp->ar_hrd != __constant_htons(ARPHRD_ETHER) &&
  672.     arp->ar_hrd != __constant_htons(ARPHRD_IEEE802))
  673. goto out;
  674. if (arp->ar_pro != __constant_htons(ETH_P_IP))
  675. goto out;
  676. break;
  677. #endif
  678. #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  679. case ARPHRD_AX25:
  680. if (arp->ar_pro != __constant_htons(AX25_P_IP))
  681. goto out;
  682. if (arp->ar_hrd != __constant_htons(ARPHRD_AX25))
  683. goto out;
  684. break;
  685. #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
  686. case ARPHRD_NETROM:
  687. if (arp->ar_pro != __constant_htons(AX25_P_IP))
  688. goto out;
  689. if (arp->ar_hrd != __constant_htons(ARPHRD_NETROM))
  690. goto out;
  691. break;
  692. #endif
  693. #endif
  694. }
  696. /* Understand only these message types */
  698. if (arp->ar_op != __constant_htons(ARPOP_REPLY) &&
  699.     arp->ar_op != __constant_htons(ARPOP_REQUEST))
  700. goto out;
  702. /*
  703.  * Extract fields
  704.  */
  705. sha=arp_ptr;
  706. arp_ptr += dev->addr_len;
  707. memcpy(&sip, arp_ptr, 4);
  708. arp_ptr += 4;
  709. tha=arp_ptr;
  710. arp_ptr += dev->addr_len;
  711. memcpy(&tip, arp_ptr, 4);
  712. /* 
  713.  * Check for bad requests for 127.x.x.x and requests for multicast
  714.  * addresses.  If this is one such, delete it.
  715.  */
  716. if (LOOPBACK(tip) || MULTICAST(tip))
  717. goto out;
  719. /*
  720.  *     Special case: We must set Frame Relay source Q.922 address
  721.  */
  722. if (dev_type == ARPHRD_DLCI)
  723. sha = dev->broadcast;
  725. /*
  726.  *  Process entry.  The idea here is we want to send a reply if it is a
  727.  *  request for us or if it is a request for someone else that we hold
  728.  *  a proxy for.  We want to add an entry to our cache if it is a reply
  729.  *  to us or if it is a request for our address.  
  730.  *  (The assumption for this last is that if someone is requesting our 
  731.  *  address, they are probably intending to talk to us, so it saves time 
  732.  *  if we cache their address.  Their address is also probably not in 
  733.  *  our cache, since ours is not in their cache.)
  734.  * 
  735.  *  Putting this another way, we only care about replies if they are to
  736.  *  us, in which case we add them to the cache.  For requests, we care
  737.  *  about those for us and those for our proxies.  We reply to both,
  738.  *  and in the case of requests for us we add the requester to the arp 
  739.  *  cache.
  740.  */
  742. /* Special case: IPv4 duplicate address detection packet (RFC2131) */
  743. if (sip == 0) {
  744. if (arp->ar_op == __constant_htons(ARPOP_REQUEST) &&
  745.     inet_addr_type(tip) == RTN_LOCAL)
  746. arp_send(ARPOP_REPLY,ETH_P_ARP,tip,dev,tip,sha,dev->dev_addr,dev->dev_addr);
  747. goto out;
  748. }
  750. if (arp->ar_op == __constant_htons(ARPOP_REQUEST) &&
  751.     ip_route_input(skb, tip, sip, 0, dev) == 0) {
  753. rt = (struct rtable*)skb->dst;
  754. addr_type = rt->rt_type;
  756. if (addr_type == RTN_LOCAL) {
  757. n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
  758. if (n) {
  759. int dont_send = 0;
  760. if (IN_DEV_ARPFILTER(in_dev))
  761. dont_send |= arp_filter(sip,tip,dev); 
  762. if (!dont_send)
  763. arp_send(ARPOP_REPLY,ETH_P_ARP,sip,dev,tip,sha,dev->dev_addr,sha);
  765. neigh_release(n);
  766. }
  767. goto out;
  768. } else if (IN_DEV_FORWARD(in_dev)) {
  769. if ((rt->rt_flags&RTCF_DNAT) ||
  770.     (addr_type == RTN_UNICAST  && rt->u.dst.dev != dev &&
  771.      (IN_DEV_PROXY_ARP(in_dev) || pneigh_lookup(&arp_tbl, &tip, dev, 0)))) {
  772. n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
  773. if (n)
  774. neigh_release(n);
  776. if (skb->stamp.tv_sec == 0 ||
  777.     skb->pkt_type == PACKET_HOST ||
  778.     in_dev->arp_parms->proxy_delay == 0) {
  779. arp_send(ARPOP_REPLY,ETH_P_ARP,sip,dev,tip,sha,dev->dev_addr,sha);
  780. } else {
  781. pneigh_enqueue(&arp_tbl, in_dev->arp_parms, skb);
  782. in_dev_put(in_dev);
  783. return 0;
  784. }
  785. goto out;
  786. }
  787. }
  788. }
  790. /* Update our ARP tables */
  792. n = __neigh_lookup(&arp_tbl, &sip, dev, 0);
  794. #ifdef CONFIG_IP_ACCEPT_UNSOLICITED_ARP
  795. /* Unsolicited ARP is not accepted by default.
  796.    It is possible, that this option should be enabled for some
  797.    devices (strip is candidate)
  798.  */
  799. if (n == NULL &&
  800.     arp->ar_op == __constant_htons(ARPOP_REPLY) &&
  801.     inet_addr_type(sip) == RTN_UNICAST)
  802. n = __neigh_lookup(&arp_tbl, &sip, dev, -1);
  803. #endif
  805. if (n) {
  806. int state = NUD_REACHABLE;
  807. int override = 0;
  809. /* If several different ARP replies follows back-to-back,
  810.    use the FIRST one. It is possible, if several proxy
  811.    agents are active. Taking the first reply prevents
  812.    arp trashing and chooses the fastest router.
  813.  */
  814. if (jiffies - n->updated >= n->parms->locktime)
  815. override = 1;
  817. /* Broadcast replies and request packets
  818.    do not assert neighbour reachability.
  819.  */
  820. if (arp->ar_op != __constant_htons(ARPOP_REPLY) ||
  821.     skb->pkt_type != PACKET_HOST)
  822. state = NUD_STALE;
  823. neigh_update(n, sha, state, override, 1);
  824. neigh_release(n);
  825. }
  827. out:
  828. if (in_dev)
  829. in_dev_put(in_dev);
  830. freeskb:
  831. kfree_skb(skb);
  832. out_of_mem:
  833. return 0;
  834. }
  838. /*
  839.  * User level interface (ioctl, /proc)
  840.  */
  842. /*
  843.  * Set (create) an ARP cache entry.
  844.  */
  846. int arp_req_set(struct arpreq *r, struct net_device * dev)
  847. {
  848. u32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
  849. struct neighbour *neigh;
  850. int err;
  852. if (r->arp_flags&ATF_PUBL) {
  853. u32 mask = ((struct sockaddr_in *) &r->arp_netmask)->sin_addr.s_addr;
  854. if (mask && mask != 0xFFFFFFFF)
  855. return -EINVAL;
  856. if (!dev && (r->arp_flags & ATF_COM)) {
  857. dev = dev_getbyhwaddr(r->arp_ha.sa_family, r->arp_ha.sa_data);
  858. if (!dev)
  859. return -ENODEV;
  860. }
  861. if (mask) {
  862. if (pneigh_lookup(&arp_tbl, &ip, dev, 1) == NULL)
  863. return -ENOBUFS;
  864. return 0;
  865. }
  866. if (dev == NULL) {
  867. ipv4_devconf.proxy_arp = 1;
  868. return 0;
  869. }
  870. if (__in_dev_get(dev)) {
  871. __in_dev_get(dev)->cnf.proxy_arp = 1;
  872. return 0;
  873. }
  874. return -ENXIO;
  875. }
  877. if (r->arp_flags & ATF_PERM)
  878. r->arp_flags |= ATF_COM;
  879. if (dev == NULL) {
  880. struct rtable * rt;
  881. if ((err = ip_route_output(&rt, ip, 0, RTO_ONLINK, 0)) != 0)
  882. return err;
  883. dev = rt->u.dst.dev;
  884. ip_rt_put(rt);
  885. if (!dev)
  886. return -EINVAL;
  887. }
  888. if (r->arp_ha.sa_family != dev->type)
  889. return -EINVAL;
  891. neigh = __neigh_lookup_errno(&arp_tbl, &ip, dev);
  892. err = PTR_ERR(neigh);
  893. if (!IS_ERR(neigh)) {
  894. unsigned state = NUD_STALE;
  895. if (r->arp_flags & ATF_PERM)
  896. state = NUD_PERMANENT;
  897. err = neigh_update(neigh, (r->arp_flags&ATF_COM) ?
  898.    r->arp_ha.sa_data : NULL, state, 1, 0);
  899. neigh_release(neigh);
  900. }
  901. return err;
  902. }
  904. static unsigned arp_state_to_flags(struct neighbour *neigh)
  905. {
  906. unsigned flags = 0;
  907. if (neigh->nud_state&NUD_PERMANENT)
  908. flags = ATF_PERM|ATF_COM;
  909. else if (neigh->nud_state&NUD_VALID)
  910. flags = ATF_COM;
  911. return flags;
  912. }
  914. /*
  915.  * Get an ARP cache entry.
  916.  */
  918. static int arp_req_get(struct arpreq *r, struct net_device *dev)
  919. {
  920. u32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
  921. struct neighbour *neigh;
  922. int err = -ENXIO;
  924. neigh = neigh_lookup(&arp_tbl, &ip, dev);
  925. if (neigh) {
  926. read_lock_bh(&neigh->lock);
  927. memcpy(r->arp_ha.sa_data, neigh->ha, dev->addr_len);
  928. r->arp_flags = arp_state_to_flags(neigh);
  929. read_unlock_bh(&neigh->lock);
  930. r->arp_ha.sa_family = dev->type;
  931. strncpy(r->arp_dev, dev->name, sizeof(r->arp_dev));
  932. neigh_release(neigh);
  933. err = 0;
  934. }
  935. return err;
  936. }
  938. int arp_req_delete(struct arpreq *r, struct net_device * dev)
  939. {
  940. int err;
  941. u32 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
  942. struct neighbour *neigh;
  944. if (r->arp_flags & ATF_PUBL) {
  945. u32 mask = ((struct sockaddr_in *) &r->arp_netmask)->sin_addr.s_addr;
  946. if (mask == 0xFFFFFFFF)
  947. return pneigh_delete(&arp_tbl, &ip, dev);
  948. if (mask == 0) {
  949. if (dev == NULL) {
  950. ipv4_devconf.proxy_arp = 0;
  951. return 0;
  952. }
  953. if (__in_dev_get(dev)) {
  954. __in_dev_get(dev)->cnf.proxy_arp = 0;
  955. return 0;
  956. }
  957. return -ENXIO;
  958. }
  959. return -EINVAL;
  960. }
  962. if (dev == NULL) {
  963. struct rtable * rt;
  964. if ((err = ip_route_output(&rt, ip, 0, RTO_ONLINK, 0)) != 0)
  965. return err;
  966. dev = rt->u.dst.dev;
  967. ip_rt_put(rt);
  968. if (!dev)
  969. return -EINVAL;
  970. }
  971. err = -ENXIO;
  972. neigh = neigh_lookup(&arp_tbl, &ip, dev);
  973. if (neigh) {
  974. if (neigh->nud_state&~NUD_NOARP)
  975. err = neigh_update(neigh, NULL, NUD_FAILED, 1, 0);
  976. neigh_release(neigh);
  977. }
  978. return err;
  979. }
  981. /*
  982.  * Handle an ARP layer I/O control request.
  983.  */
  985. int arp_ioctl(unsigned int cmd, void *arg)
  986. {
  987. int err;
  988. struct arpreq r;
  989. struct net_device * dev = NULL;
  991. switch(cmd) {
  992. case SIOCDARP:
  993. case SIOCSARP:
  994. if (!capable(CAP_NET_ADMIN))
  995. return -EPERM;
  996. case SIOCGARP:
  997. err = copy_from_user(&r, arg, sizeof(struct arpreq));
  998. if (err)
  999. return -EFAULT;
  1000. break;
  1001. default:
  1002. return -EINVAL;
  1003. }
  1005. if (r.arp_pa.sa_family != AF_INET)
  1006. return -EPFNOSUPPORT;
  1008. if (!(r.arp_flags & ATF_PUBL) &&
  1009.     (r.arp_flags & (ATF_NETMASK|ATF_DONTPUB)))
  1010. return -EINVAL;
  1011. if (!(r.arp_flags & ATF_NETMASK))
  1012. ((struct sockaddr_in *)&r.arp_netmask)->sin_addr.s_addr=__constant_htonl(0xFFFFFFFFUL);
  1014. rtnl_lock();
  1015. if (r.arp_dev[0]) {
  1016. err = -ENODEV;
  1017. if ((dev = __dev_get_by_name(r.arp_dev)) == NULL)
  1018. goto out;
  1020. /* Mmmm... It is wrong... ARPHRD_NETROM==0 */
  1021. if (!r.arp_ha.sa_family)
  1022. r.arp_ha.sa_family = dev->type;
  1023. err = -EINVAL;
  1024. if ((r.arp_flags & ATF_COM) && r.arp_ha.sa_family != dev->type)
  1025. goto out;
  1026. } else if (cmd == SIOCGARP) {
  1027. err = -ENODEV;
  1028. goto out;
  1029. }
  1031. switch(cmd) {
  1032. case SIOCDARP:
  1033.         err = arp_req_delete(&r, dev);
  1034. break;
  1035. case SIOCSARP:
  1036. err = arp_req_set(&r, dev);
  1037. break;
  1038. case SIOCGARP:
  1039. err = arp_req_get(&r, dev);
  1040. if (!err && copy_to_user(arg, &r, sizeof(r)))
  1041. err = -EFAULT;
  1042. break;
  1043. }
  1044. out:
  1045. rtnl_unlock();
  1046. return err;
  1047. }
  1049. /*
  1050.  * Write the contents of the ARP cache to a PROCfs file.
  1051.  */
  1052. #ifndef CONFIG_PROC_FS
  1053. static int arp_get_info(char *buffer, char **start, off_t offset, int length) { return 0; }
  1054. #else
  1055. #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  1056. static char *ax2asc2(ax25_address *a, char *buf);
  1057. #endif
  1058. #define HBUFFERLEN 30
  1060. static int arp_get_info(char *buffer, char **start, off_t offset, int length)
  1061. {
  1062. int len=0;
  1063. off_t pos=0;
  1064. int size;
  1065. char hbuffer[HBUFFERLEN];
  1066. int i,j,k;
  1067. const char hexbuf[] =  "0123456789ABCDEF";
  1069. size = sprintf(buffer,"IP address       HW type     Flags       HW address            Mask     Devicen");
  1071. pos+=size;
  1072. len+=size;
  1074. for(i=0; i<=NEIGH_HASHMASK; i++) {
  1075. struct neighbour *n;
  1076. read_lock_bh(&arp_tbl.lock);
  1077. for (n=arp_tbl.hash_buckets[i]; n; n=n->next) {
  1078. struct net_device *dev = n->dev;
  1079. int hatype = dev->type;
  1081. /* Do not confuse users "arp -a" with magic entries */
  1082. if (!(n->nud_state&~NUD_NOARP))
  1083. continue;
  1085. read_lock(&n->lock);
  1087. /*
  1088.  * Convert hardware address to XX:XX:XX:XX ... form.
  1089.  */
  1090. #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  1091. if (hatype == ARPHRD_AX25 || hatype == ARPHRD_NETROM)
  1092. ax2asc2((ax25_address *)n->ha, hbuffer);
  1093. else {
  1094. #endif
  1095. for (k=0,j=0;k<HBUFFERLEN-3 && j<dev->addr_len;j++) {
  1096. hbuffer[k++]=hexbuf[(n->ha[j]>>4)&15 ];
  1097. hbuffer[k++]=hexbuf[n->ha[j]&15     ];
  1098. hbuffer[k++]=':';
  1099. }
  1100. hbuffer[--k]=0;
  1102. #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  1103. }
  1104. #endif
  1106. {
  1107. char tbuf[16];
  1108. sprintf(tbuf, "%u.%u.%u.%u", NIPQUAD(*(u32*)n->primary_key));
  1109. size = sprintf(buffer+len, "%-16s 0x%-10x0x%-10x%s"
  1110. "     *        %sn",
  1111. tbuf,
  1112. hatype,
  1113. arp_state_to_flags(n), 
  1114. hbuffer,
  1115. dev->name);
  1116. }
  1118. read_unlock(&n->lock);
  1120. len += size;
  1121. pos += size;
  1122.   
  1123. if (pos <= offset)
  1124. len=0;
  1125. if (pos >= offset+length) {
  1126. read_unlock_bh(&arp_tbl.lock);
  1127.   goto done;
  1128. }
  1129. }
  1130. read_unlock_bh(&arp_tbl.lock);
  1131. }
  1133. for (i=0; i<=PNEIGH_HASHMASK; i++) {
  1134. struct pneigh_entry *n;
  1135. for (n=arp_tbl.phash_buckets[i]; n; n=n->next) {
  1136. struct net_device *dev = n->dev;
  1137. int hatype = dev ? dev->type : 0;
  1139. {
  1140. char tbuf[16];
  1141. sprintf(tbuf, "%u.%u.%u.%u", NIPQUAD(*(u32*)n->key));
  1142. size = sprintf(buffer+len, "%-16s 0x%-10x0x%-10x%s"
  1143. "     *        %sn",
  1144. tbuf,
  1145. hatype,
  1146.   ATF_PUBL|ATF_PERM,
  1147. "00:00:00:00:00:00",
  1148. dev ? dev->name : "*");
  1149. }
  1151. len += size;
  1152. pos += size;
  1153.   
  1154. if (pos <= offset)
  1155. len=0;
  1156. if (pos >= offset+length)
  1157. goto done;
  1158. }
  1159. }
  1161. done:
  1162.   
  1163. *start = buffer+len-(pos-offset); /* Start of wanted data */
  1164. len = pos-offset; /* Start slop */
  1165. if (len>length)
  1166. len = length; /* Ending slop */
  1167. if (len<0)
  1168. len = 0;
  1169. return len;
  1170. }
  1171. #endif
  1173. /* Note, that it is not on notifier chain.
  1174.    It is necessary, that this routine was called after route cache will be
  1175.    flushed.
  1176.  */
  1177. void arp_ifdown(struct net_device *dev)
  1178. {
  1179. neigh_ifdown(&arp_tbl, dev);
  1180. }
  1183. /*
  1184.  * Called once on startup.
  1185.  */
  1187. static struct packet_type arp_packet_type = {
  1188. type: __constant_htons(ETH_P_ARP),
  1189. func: arp_rcv,
  1190. data: (void*) 1, /* understand shared skbs */
  1191. };
  1193. void __init arp_init (void)
  1194. {
  1195. neigh_table_init(&arp_tbl);
  1197. dev_add_pack(&arp_packet_type);
  1199. proc_net_create ("arp", 0, arp_get_info);
  1201. #ifdef CONFIG_SYSCTL
  1202. neigh_sysctl_register(NULL, &arp_tbl.parms, NET_IPV4, NET_IPV4_NEIGH, "ipv4");
  1203. #endif
  1204. }
  1207. #ifdef CONFIG_PROC_FS
  1208. #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  1210. /*
  1211.  * ax25 -> ASCII conversion
  1212.  */
  1213. char *ax2asc2(ax25_address *a, char *buf)
  1214. {
  1215. char c, *s;
  1216. int n;
  1218. for (n = 0, s = buf; n < 6; n++) {
  1219. c = (a->ax25_call[n] >> 1) & 0x7F;
  1221. if (c != ' ') *s++ = c;
  1222. }
  1224. *s++ = '-';
  1226. if ((n = ((a->ax25_call[6] >> 1) & 0x0F)) > 9) {
  1227. *s++ = '1';
  1228. n -= 10;
  1229. }
  1231. *s++ = n + '0';
  1232. *s++ = '';
  1234. if (*buf == '' || *buf == '-')
  1235.    return "*";
  1237. return buf;
  1239. }
  1241. #endif
  1242. #endif