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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
arp_tables.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：32k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

arp_tables.c：源码内容
  1. /*
  2.  * Packet matching code for ARP packets.
  3.  *
  4.  * Based heavily, if not almost entirely, upon ip_tables.c framework.
  5.  *
  6.  * Some ARP specific bits are:
  7.  *
  8.  * Copyright (C) 2002 David S. Miller (davem@redhat.com)
  9.  *
  10.  */
  12. #include <linux/config.h>
  13. #include <linux/kernel.h>
  14. #include <linux/skbuff.h>
  15. #include <linux/netdevice.h>
  16. #include <linux/if_arp.h>
  17. #include <linux/kmod.h>
  18. #include <linux/vmalloc.h>
  19. #include <linux/proc_fs.h>
  20. #include <linux/module.h>
  21. #include <linux/init.h>
  23. #include <asm/uaccess.h>
  24. #include <asm/semaphore.h>
  26. #include <linux/netfilter_arp/arp_tables.h>
  28. /*#define DEBUG_ARP_TABLES*/
  29. /*#define DEBUG_ARP_TABLES_USER*/
  31. #ifdef DEBUG_ARP_TABLES
  32. #define dprintf(format, args...)  printk(format , ## args)
  33. #else
  34. #define dprintf(format, args...)
  35. #endif
  37. #ifdef DEBUG_ARP_TABLES_USER
  38. #define duprintf(format, args...) printk(format , ## args)
  39. #else
  40. #define duprintf(format, args...)
  41. #endif
  43. #ifdef CONFIG_NETFILTER_DEBUG
  44. #define ARP_NF_ASSERT(x)
  45. do {
  46. if (!(x))
  47. printk("ARP_NF_ASSERT: %s:%s:%un",
  48.        __FUNCTION__, __FILE__, __LINE__);
  49. } while(0)
  50. #else
  51. #define ARP_NF_ASSERT(x)
  52. #endif
  53. #define SMP_ALIGN(x) (((x) + SMP_CACHE_BYTES-1) & ~(SMP_CACHE_BYTES-1))
  55. static DECLARE_MUTEX(arpt_mutex);
  57. #define ASSERT_READ_LOCK(x) ARP_NF_ASSERT(down_trylock(&arpt_mutex) != 0)
  58. #define ASSERT_WRITE_LOCK(x) ARP_NF_ASSERT(down_trylock(&arpt_mutex) != 0)
  59. #include <linux/netfilter_ipv4/lockhelp.h>
  60. #include <linux/netfilter_ipv4/listhelp.h>
  62. struct arpt_table_info {
  63. unsigned int size;
  64. unsigned int number;
  65. unsigned int initial_entries;
  66. unsigned int hook_entry[NF_ARP_NUMHOOKS];
  67. unsigned int underflow[NF_ARP_NUMHOOKS];
  68. char entries[0] __attribute__((aligned(SMP_CACHE_BYTES)));
  69. };
  71. static LIST_HEAD(arpt_target);
  72. static LIST_HEAD(arpt_tables);
  73. #define ADD_COUNTER(c,b,p) do { (c).bcnt += (b); (c).pcnt += (p); } while(0)
  75. #ifdef CONFIG_SMP
  76. #define TABLE_OFFSET(t,p) (SMP_ALIGN((t)->size)*(p))
  77. #else
  78. #define TABLE_OFFSET(t,p) 0
  79. #endif
  81. static inline int arp_devaddr_compare(const struct arpt_devaddr_info *ap,
  82.       char *hdr_addr, int len)
  83. {
  84. int i, ret;
  86. if (len > ARPT_DEV_ADDR_LEN_MAX)
  87. len = ARPT_DEV_ADDR_LEN_MAX;
  89. ret = 0;
  90. for (i = 0; i < len; i++)
  91. ret |= (hdr_addr[i] ^ ap->addr[i]) & ap->mask[i];
  93. return (ret != 0);
  94. }
  96. /* Returns whether packet matches rule or not. */
  97. static inline int arp_packet_match(const struct arphdr *arphdr,
  98.    struct net_device *dev,
  99.    const char *indev,
  100.    const char *outdev,
  101.    const struct arpt_arp *arpinfo)
  102. {
  103. char *arpptr = (char *)(arphdr + 1);
  104. char *src_devaddr, *tgt_devaddr;
  105. u32 *src_ipaddr, *tgt_ipaddr;
  106. int i, ret;
  108. #define FWINV(bool,invflg) ((bool) ^ !!(arpinfo->invflags & invflg))
  110. if (FWINV((arphdr->ar_op & arpinfo->arpop_mask) != arpinfo->arpop,
  111.   ARPT_INV_ARPOP)) {
  112. dprintf("ARP operation field mismatch.n");
  113. dprintf("ar_op: %04x info->arpop: %04x info->arpop_mask: %04xn",
  114. arphdr->ar_op, arpinfo->arpop, arpinfo->arpop_mask);
  115. return 0;
  116. }
  118. if (FWINV((arphdr->ar_hrd & arpinfo->arhrd_mask) != arpinfo->arhrd,
  119.   ARPT_INV_ARPHRD)) {
  120. dprintf("ARP hardware address format mismatch.n");
  121. dprintf("ar_hrd: %04x info->arhrd: %04x info->arhrd_mask: %04xn",
  122. arphdr->ar_hrd, arpinfo->arhrd, arpinfo->arhrd_mask);
  123. return 0;
  124. }
  126. if (FWINV((arphdr->ar_pro & arpinfo->arpro_mask) != arpinfo->arpro,
  127.   ARPT_INV_ARPPRO)) {
  128. dprintf("ARP protocol address format mismatch.n");
  129. dprintf("ar_pro: %04x info->arpro: %04x info->arpro_mask: %04xn",
  130. arphdr->ar_pro, arpinfo->arpro, arpinfo->arpro_mask);
  131. return 0;
  132. }
  134. if (FWINV((arphdr->ar_hln & arpinfo->arhln_mask) != arpinfo->arhln,
  135.   ARPT_INV_ARPHLN)) {
  136. dprintf("ARP hardware address length mismatch.n");
  137. dprintf("ar_hln: %02x info->arhln: %02x info->arhln_mask: %02xn",
  138. arphdr->ar_hln, arpinfo->arhln, arpinfo->arhln_mask);
  139. }
  141. src_devaddr = arpptr;
  142. arpptr += dev->addr_len;
  143. src_ipaddr = (u32 *) arpptr;
  144. arpptr += sizeof(u32);
  145. tgt_devaddr = arpptr;
  146. arpptr += dev->addr_len;
  147. tgt_ipaddr = (u32 *) arpptr;
  149. if (FWINV(arp_devaddr_compare(&arpinfo->src_devaddr, src_devaddr, dev->addr_len),
  150.   ARPT_INV_SRCDEVADDR) ||
  151.     FWINV(arp_devaddr_compare(&arpinfo->tgt_devaddr, tgt_devaddr, dev->addr_len),
  152.   ARPT_INV_TGTDEVADDR)) {
  153. dprintf("Source or target device address mismatch.n");
  155. return 0;
  156. }
  158. if (FWINV(((*src_ipaddr) & arpinfo->smsk.s_addr) != arpinfo->src.s_addr,
  159.   ARPT_INV_SRCIP) ||
  160.     FWINV((((*tgt_ipaddr) & arpinfo->tmsk.s_addr) != arpinfo->tgt.s_addr),
  161.   ARPT_INV_TGTIP)) {
  162. dprintf("Source or target IP address mismatch.n");
  164. dprintf("SRC: %u.%u.%u.%u. Mask: %u.%u.%u.%u. Target: %u.%u.%u.%u.%sn",
  165. NIPQUAD(*src_ipaddr),
  166. NIPQUAD(arpinfo->smsk.s_addr),
  167. NIPQUAD(arpinfo->src.s_addr),
  168. arpinfo->invflags & ARPT_INV_SRCIP ? " (INV)" : "");
  169. dprintf("TGT: %u.%u.%u.%u Mask: %u.%u.%u.%u Target: %u.%u.%u.%u.%sn",
  170. NIPQUAD(*tgt_ipaddr),
  171. NIPQUAD(arpinfo->tmsk.s_addr),
  172. NIPQUAD(arpinfo->tgt.s_addr),
  173. arpinfo->invflags & ARPT_INV_TGTIP ? " (INV)" : "");
  174. return 0;
  175. }
  177. /* Look for ifname matches; this should unroll nicely. */
  178. for (i = 0, ret = 0; i < IFNAMSIZ/sizeof(unsigned long); i++) {
  179. ret |= (((const unsigned long *)indev)[i]
  180. ^ ((const unsigned long *)arpinfo->iniface)[i])
  181. & ((const unsigned long *)arpinfo->iniface_mask)[i];
  182. }
  184. if (FWINV(ret != 0, ARPT_INV_VIA_IN)) {
  185. dprintf("VIA in mismatch (%s vs %s).%sn",
  186. indev, arpinfo->iniface,
  187. arpinfo->invflags&ARPT_INV_VIA_IN ?" (INV)":"");
  188. return 0;
  189. }
  191. for (i = 0, ret = 0; i < IFNAMSIZ/sizeof(unsigned long); i++) {
  192. ret |= (((const unsigned long *)outdev)[i]
  193. ^ ((const unsigned long *)arpinfo->outiface)[i])
  194. & ((const unsigned long *)arpinfo->outiface_mask)[i];
  195. }
  197. if (FWINV(ret != 0, ARPT_INV_VIA_OUT)) {
  198. dprintf("VIA out mismatch (%s vs %s).%sn",
  199. outdev, arpinfo->outiface,
  200. arpinfo->invflags&ARPT_INV_VIA_OUT ?" (INV)":"");
  201. return 0;
  202. }
  204. return 1;
  205. }
  207. static inline int arp_checkentry(const struct arpt_arp *arp)
  208. {
  209. if (arp->flags & ~ARPT_F_MASK) {
  210. duprintf("Unknown flag bits set: %08Xn",
  211.  arp->flags & ~ARPT_F_MASK);
  212. return 0;
  213. }
  214. if (arp->invflags & ~ARPT_INV_MASK) {
  215. duprintf("Unknown invflag bits set: %08Xn",
  216.  arp->invflags & ~ARPT_INV_MASK);
  217. return 0;
  218. }
  220. return 1;
  221. }
  223. static unsigned int arpt_error(struct sk_buff **pskb,
  224.        unsigned int hooknum,
  225.        const struct net_device *in,
  226.        const struct net_device *out,
  227.        const void *targinfo,
  228.        void *userinfo)
  229. {
  230. if (net_ratelimit())
  231. printk("arp_tables: error: '%s'n", (char *)targinfo);
  233. return NF_DROP;
  234. }
  236. static inline struct arpt_entry *get_entry(void *base, unsigned int offset)
  237. {
  238. return (struct arpt_entry *)(base + offset);
  239. }
  241. unsigned int arpt_do_table(struct sk_buff **pskb,
  242.    unsigned int hook,
  243.    const struct net_device *in,
  244.    const struct net_device *out,
  245.    struct arpt_table *table,
  246.    void *userdata)
  247. {
  248. static const char nulldevname[IFNAMSIZ] = { 0 };
  249. unsigned int verdict = NF_DROP;
  250. struct arphdr *arp = (*pskb)->nh.arph;
  251. int hotdrop = 0;
  252. struct arpt_entry *e, *back;
  253. const char *indev, *outdev;
  254. void *table_base;
  256. indev = in ? in->name : nulldevname;
  257. outdev = out ? out->name : nulldevname;
  259. read_lock_bh(&table->lock);
  260. table_base = (void *)table->private->entries
  261. + TABLE_OFFSET(table->private,
  262.        cpu_number_map(smp_processor_id()));
  263. e = get_entry(table_base, table->private->hook_entry[hook]);
  264. back = get_entry(table_base, table->private->underflow[hook]);
  266. do {
  267. if (arp_packet_match(arp, (*pskb)->dev, indev, outdev, &e->arp)) {
  268. struct arpt_entry_target *t;
  269. int hdr_len;
  271. hdr_len = sizeof(*arp) + (2 * sizeof(struct in_addr)) +
  272. (2 * (*pskb)->dev->addr_len);
  273. ADD_COUNTER(e->counters, hdr_len, 1);
  275. t = arpt_get_target(e);
  277. /* Standard target? */
  278. if (!t->u.kernel.target->target) {
  279. int v;
  281. v = ((struct arpt_standard_target *)t)->verdict;
  282. if (v < 0) {
  283. /* Pop from stack? */
  284. if (v != ARPT_RETURN) {
  285. verdict = (unsigned)(-v) - 1;
  286. break;
  287. }
  288. e = back;
  289. back = get_entry(table_base,
  290.  back->comefrom);
  291. continue;
  292. }
  293. if (table_base + v
  294.     != (void *)e + e->next_offset) {
  295. /* Save old back ptr in next entry */
  296. struct arpt_entry *next
  297. = (void *)e + e->next_offset;
  298. next->comefrom =
  299. (void *)back - table_base;
  301. /* set back pointer to next entry */
  302. back = next;
  303. }
  305. e = get_entry(table_base, v);
  306. } else {
  307. /* Targets which reenter must return
  308.  * abs. verdicts
  309.  */
  310. verdict = t->u.kernel.target->target(pskb,
  311.      hook,
  312.      in, out,
  313.      t->data,
  314.      userdata);
  316. /* Target might have changed stuff. */
  317. arp = (*pskb)->nh.arph;
  319. if (verdict == ARPT_CONTINUE)
  320. e = (void *)e + e->next_offset;
  321. else
  322. /* Verdict */
  323. break;
  324. }
  325. } else {
  326. e = (void *)e + e->next_offset;
  327. }
  328. } while (!hotdrop);
  329. read_unlock_bh(&table->lock);
  331. if (hotdrop)
  332. return NF_DROP;
  333. else
  334. return verdict;
  335. }
  337. static inline void *find_inlist_lock_noload(struct list_head *head,
  338.     const char *name,
  339.     int *error,
  340.     struct semaphore *mutex)
  341. {
  342. void *ret;
  344. *error = down_interruptible(mutex);
  345. if (*error != 0)
  346. return NULL;
  348. ret = list_named_find(head, name);
  349. if (!ret) {
  350. *error = -ENOENT;
  351. up(mutex);
  352. }
  353. return ret;
  354. }
  356. #ifndef CONFIG_KMOD
  357. #define find_inlist_lock(h,n,p,e,m) find_inlist_lock_noload((h),(n),(e),(m))
  358. #else
  359. static void *
  360. find_inlist_lock(struct list_head *head,
  361.  const char *name,
  362.  const char *prefix,
  363.  int *error,
  364.  struct semaphore *mutex)
  365. {
  366. void *ret;
  368. ret = find_inlist_lock_noload(head, name, error, mutex);
  369. if (!ret) {
  370. char modulename[ARPT_FUNCTION_MAXNAMELEN + strlen(prefix) + 1];
  371. strcpy(modulename, prefix);
  372. strcat(modulename, name);
  373. duprintf("find_inlist: loading `%s'.n", modulename);
  374. request_module(modulename);
  375. ret = find_inlist_lock_noload(head, name, error, mutex);
  376. }
  378. return ret;
  379. }
  380. #endif
  382. static inline struct arpt_table *find_table_lock(const char *name, int *error, struct semaphore *mutex)
  383. {
  384. return find_inlist_lock(&arpt_tables, name, "arptable_", error, mutex);
  385. }
  387. static inline struct arpt_target *find_target_lock(const char *name, int *error, struct semaphore *mutex)
  388. {
  389. return find_inlist_lock(&arpt_target, name, "arpt_", error, mutex);
  390. }
  392. /* All zeroes == unconditional rule. */
  393. static inline int unconditional(const struct arpt_arp *arp)
  394. {
  395. unsigned int i;
  397. for (i = 0; i < sizeof(*arp)/sizeof(__u32); i++)
  398. if (((__u32 *)arp)[i])
  399. return 0;
  401. return 1;
  402. }
  404. /* Figures out from what hook each rule can be called: returns 0 if
  405.  * there are loops.  Puts hook bitmask in comefrom.
  406.  */
  407. static int mark_source_chains(struct arpt_table_info *newinfo, unsigned int valid_hooks)
  408. {
  409. unsigned int hook;
  411. /* No recursion; use packet counter to save back ptrs (reset
  412.  * to 0 as we leave), and comefrom to save source hook bitmask.
  413.  */
  414. for (hook = 0; hook < NF_ARP_NUMHOOKS; hook++) {
  415. unsigned int pos = newinfo->hook_entry[hook];
  416. struct arpt_entry *e
  417. = (struct arpt_entry *)(newinfo->entries + pos);
  419. if (!(valid_hooks & (1 << hook)))
  420. continue;
  422. /* Set initial back pointer. */
  423. e->counters.pcnt = pos;
  425. for (;;) {
  426. struct arpt_standard_target *t
  427. = (void *)arpt_get_target(e);
  429. if (e->comefrom & (1 << NF_ARP_NUMHOOKS)) {
  430. printk("arptables: loop hook %u pos %u %08X.n",
  431.        hook, pos, e->comefrom);
  432. return 0;
  433. }
  434. e->comefrom
  435. |= ((1 << hook) | (1 << NF_ARP_NUMHOOKS));
  437. /* Unconditional return/END. */
  438. if (e->target_offset == sizeof(struct arpt_entry)
  439.     && (strcmp(t->target.u.user.name,
  440.        ARPT_STANDARD_TARGET) == 0)
  441.     && t->verdict < 0
  442.     && unconditional(&e->arp)) {
  443. unsigned int oldpos, size;
  445. /* Return: backtrack through the last
  446.  * big jump.
  447.  */
  448. do {
  449. e->comefrom ^= (1<<NF_ARP_NUMHOOKS);
  450. oldpos = pos;
  451. pos = e->counters.pcnt;
  452. e->counters.pcnt = 0;
  454. /* We're at the start. */
  455. if (pos == oldpos)
  456. goto next;
  458. e = (struct arpt_entry *)
  459. (newinfo->entries + pos);
  460. } while (oldpos == pos + e->next_offset);
  462. /* Move along one */
  463. size = e->next_offset;
  464. e = (struct arpt_entry *)
  465. (newinfo->entries + pos + size);
  466. e->counters.pcnt = pos;
  467. pos += size;
  468. } else {
  469. int newpos = t->verdict;
  471. if (strcmp(t->target.u.user.name,
  472.    ARPT_STANDARD_TARGET) == 0
  473.     && newpos >= 0) {
  474. /* This a jump; chase it. */
  475. duprintf("Jump rule %u -> %un",
  476.  pos, newpos);
  477. } else {
  478. /* ... this is a fallthru */
  479. newpos = pos + e->next_offset;
  480. }
  481. e = (struct arpt_entry *)
  482. (newinfo->entries + newpos);
  483. e->counters.pcnt = pos;
  484. pos = newpos;
  485. }
  486. }
  487. next:
  488. duprintf("Finished chain %un", hook);
  489. }
  490. return 1;
  491. }
  493. static inline int standard_check(const struct arpt_entry_target *t,
  494.  unsigned int max_offset)
  495. {
  496. struct arpt_standard_target *targ = (void *)t;
  498. /* Check standard info. */
  499. if (t->u.target_size
  500.     != ARPT_ALIGN(sizeof(struct arpt_standard_target))) {
  501. duprintf("arpt_standard_check: target size %u != %Zun",
  502.  t->u.target_size,
  503.  ARPT_ALIGN(sizeof(struct arpt_standard_target)));
  504. return 0;
  505. }
  507. if (targ->verdict >= 0
  508.     && targ->verdict > max_offset - sizeof(struct arpt_entry)) {
  509. duprintf("arpt_standard_check: bad verdict (%i)n",
  510.  targ->verdict);
  511. return 0;
  512. }
  514. if (targ->verdict < -NF_MAX_VERDICT - 1) {
  515. duprintf("arpt_standard_check: bad negative verdict (%i)n",
  516.  targ->verdict);
  517. return 0;
  518. }
  519. return 1;
  520. }
  522. static struct arpt_target arpt_standard_target;
  524. static inline int check_entry(struct arpt_entry *e, const char *name, unsigned int size,
  525.       unsigned int *i)
  526. {
  527. struct arpt_entry_target *t;
  528. struct arpt_target *target;
  529. int ret;
  531. if (!arp_checkentry(&e->arp)) {
  532. duprintf("arp_tables: arp check failed %p %s.n", e, name);
  533. return -EINVAL;
  534. }
  536. t = arpt_get_target(e);
  537. target = find_target_lock(t->u.user.name, &ret, &arpt_mutex);
  538. if (!target) {
  539. duprintf("check_entry: `%s' not foundn", t->u.user.name);
  540. goto out;
  541. }
  542. if (target->me)
  543. __MOD_INC_USE_COUNT(target->me);
  544. t->u.kernel.target = target;
  545. up(&arpt_mutex);
  547. if (t->u.kernel.target == &arpt_standard_target) {
  548. if (!standard_check(t, size)) {
  549. ret = -EINVAL;
  550. goto out;
  551. }
  552. } else if (t->u.kernel.target->checkentry
  553.    && !t->u.kernel.target->checkentry(name, e, t->data,
  554.       t->u.target_size
  555.       - sizeof(*t),
  556.       e->comefrom)) {
  557. if (t->u.kernel.target->me)
  558. __MOD_DEC_USE_COUNT(t->u.kernel.target->me);
  559. duprintf("arp_tables: check failed for `%s'.n",
  560.  t->u.kernel.target->name);
  561. ret = -EINVAL;
  562. goto out;
  563. }
  565. (*i)++;
  566. return 0;
  568. out:
  569. return ret;
  570. }
  572. static inline int check_entry_size_and_hooks(struct arpt_entry *e,
  573.      struct arpt_table_info *newinfo,
  574.      unsigned char *base,
  575.      unsigned char *limit,
  576.      const unsigned int *hook_entries,
  577.      const unsigned int *underflows,
  578.      unsigned int *i)
  579. {
  580. unsigned int h;
  582. if ((unsigned long)e % __alignof__(struct arpt_entry) != 0
  583.     || (unsigned char *)e + sizeof(struct arpt_entry) >= limit) {
  584. duprintf("Bad offset %pn", e);
  585. return -EINVAL;
  586. }
  588. if (e->next_offset
  589.     < sizeof(struct arpt_entry) + sizeof(struct arpt_entry_target)) {
  590. duprintf("checking: element %p size %un",
  591.  e, e->next_offset);
  592. return -EINVAL;
  593. }
  595. /* Check hooks & underflows */
  596. for (h = 0; h < NF_ARP_NUMHOOKS; h++) {
  597. if ((unsigned char *)e - base == hook_entries[h])
  598. newinfo->hook_entry[h] = hook_entries[h];
  599. if ((unsigned char *)e - base == underflows[h])
  600. newinfo->underflow[h] = underflows[h];
  601. }
  603. /* FIXME: underflows must be unconditional, standard verdicts
  604.            < 0 (not ARPT_RETURN). --RR */
  606. /* Clear counters and comefrom */
  607. e->counters = ((struct arpt_counters) { 0, 0 });
  608. e->comefrom = 0;
  610. (*i)++;
  611. return 0;
  612. }
  614. static inline int cleanup_entry(struct arpt_entry *e, unsigned int *i)
  615. {
  616. struct arpt_entry_target *t;
  618. if (i && (*i)-- == 0)
  619. return 1;
  621. t = arpt_get_target(e);
  622. if (t->u.kernel.target->destroy)
  623. t->u.kernel.target->destroy(t->data,
  624.     t->u.target_size - sizeof(*t));
  625. if (t->u.kernel.target->me)
  626. __MOD_DEC_USE_COUNT(t->u.kernel.target->me);
  628. return 0;
  629. }
  631. /* Checks and translates the user-supplied table segment (held in
  632.  * newinfo).
  633.  */
  634. static int translate_table(const char *name,
  635.    unsigned int valid_hooks,
  636.    struct arpt_table_info *newinfo,
  637.    unsigned int size,
  638.    unsigned int number,
  639.    const unsigned int *hook_entries,
  640.    const unsigned int *underflows)
  641. {
  642. unsigned int i;
  643. int ret;
  645. newinfo->size = size;
  646. newinfo->number = number;
  648. /* Init all hooks to impossible value. */
  649. for (i = 0; i < NF_ARP_NUMHOOKS; i++) {
  650. newinfo->hook_entry[i] = 0xFFFFFFFF;
  651. newinfo->underflow[i] = 0xFFFFFFFF;
  652. }
  654. duprintf("translate_table: size %un", newinfo->size);
  655. i = 0;
  657. /* Walk through entries, checking offsets. */
  658. ret = ARPT_ENTRY_ITERATE(newinfo->entries, newinfo->size,
  659.  check_entry_size_and_hooks,
  660.  newinfo,
  661.  newinfo->entries,
  662.  newinfo->entries + size,
  663.  hook_entries, underflows, &i);
  664. duprintf("translate_table: ARPT_ENTRY_ITERATE gives %dn", ret);
  665. if (ret != 0)
  666. return ret;
  668. if (i != number) {
  669. duprintf("translate_table: %u not %u entriesn",
  670.  i, number);
  671. return -EINVAL;
  672. }
  674. /* Check hooks all assigned */
  675. for (i = 0; i < NF_ARP_NUMHOOKS; i++) {
  676. /* Only hooks which are valid */
  677. if (!(valid_hooks & (1 << i)))
  678. continue;
  679. if (newinfo->hook_entry[i] == 0xFFFFFFFF) {
  680. duprintf("Invalid hook entry %u %un",
  681.  i, hook_entries[i]);
  682. return -EINVAL;
  683. }
  684. if (newinfo->underflow[i] == 0xFFFFFFFF) {
  685. duprintf("Invalid underflow %u %un",
  686.  i, underflows[i]);
  687. return -EINVAL;
  688. }
  689. }
  691. if (!mark_source_chains(newinfo, valid_hooks)) {
  692. duprintf("Looping hookn");
  693. return -ELOOP;
  694. }
  696. /* Finally, each sanity check must pass */
  697. i = 0;
  698. ret = ARPT_ENTRY_ITERATE(newinfo->entries, newinfo->size,
  699.  check_entry, name, size, &i);
  701. if (ret != 0) {
  702. ARPT_ENTRY_ITERATE(newinfo->entries, newinfo->size,
  703.    cleanup_entry, &i);
  704. return ret;
  705. }
  707. /* And one copy for every other CPU */
  708. for (i = 1; i < smp_num_cpus; i++) {
  709. memcpy(newinfo->entries + SMP_ALIGN(newinfo->size)*i,
  710.        newinfo->entries,
  711.        SMP_ALIGN(newinfo->size));
  712. }
  714. return ret;
  715. }
  717. static struct arpt_table_info *replace_table(struct arpt_table *table,
  718.      unsigned int num_counters,
  719.      struct arpt_table_info *newinfo,
  720.      int *error)
  721. {
  722. struct arpt_table_info *oldinfo;
  724. /* Do the substitution. */
  725. write_lock_bh(&table->lock);
  726. /* Check inside lock: is the old number correct? */
  727. if (num_counters != table->private->number) {
  728. duprintf("num_counters != table->private->number (%u/%u)n",
  729.  num_counters, table->private->number);
  730. write_unlock_bh(&table->lock);
  731. *error = -EAGAIN;
  732. return NULL;
  733. }
  734. oldinfo = table->private;
  735. table->private = newinfo;
  736. newinfo->initial_entries = oldinfo->initial_entries;
  737. write_unlock_bh(&table->lock);
  739. return oldinfo;
  740. }
  742. /* Gets counters. */
  743. static inline int add_entry_to_counter(const struct arpt_entry *e,
  744.        struct arpt_counters total[],
  745.        unsigned int *i)
  746. {
  747. ADD_COUNTER(total[*i], e->counters.bcnt, e->counters.pcnt);
  749. (*i)++;
  750. return 0;
  751. }
  753. static void get_counters(const struct arpt_table_info *t,
  754.  struct arpt_counters counters[])
  755. {
  756. unsigned int cpu;
  757. unsigned int i;
  759. for (cpu = 0; cpu < smp_num_cpus; cpu++) {
  760. i = 0;
  761. ARPT_ENTRY_ITERATE(t->entries + TABLE_OFFSET(t, cpu),
  762.    t->size,
  763.    add_entry_to_counter,
  764.    counters,
  765.    &i);
  766. }
  767. }
  769. static int copy_entries_to_user(unsigned int total_size,
  770. struct arpt_table *table,
  771. void *userptr)
  772. {
  773. unsigned int off, num, countersize;
  774. struct arpt_entry *e;
  775. struct arpt_counters *counters;
  776. int ret = 0;
  778. /* We need atomic snapshot of counters: rest doesn't change
  779.  * (other than comefrom, which userspace doesn't care
  780.  * about).
  781.  */
  782. countersize = sizeof(struct arpt_counters) * table->private->number;
  783. counters = vmalloc(countersize);
  785. if (counters == NULL)
  786. return -ENOMEM;
  788. /* First, sum counters... */
  789. memset(counters, 0, countersize);
  790. write_lock_bh(&table->lock);
  791. get_counters(table->private, counters);
  792. write_unlock_bh(&table->lock);
  794. /* ... then copy entire thing from CPU 0... */
  795. if (copy_to_user(userptr, table->private->entries, total_size) != 0) {
  796. ret = -EFAULT;
  797. goto free_counters;
  798. }
  800. /* FIXME: use iterator macros --RR */
  801. /* ... then go back and fix counters and names */
  802. for (off = 0, num = 0; off < total_size; off += e->next_offset, num++){
  803. struct arpt_entry_target *t;
  805. e = (struct arpt_entry *)(table->private->entries + off);
  806. if (copy_to_user(userptr + off
  807.  + offsetof(struct arpt_entry, counters),
  808.  &counters[num],
  809.  sizeof(counters[num])) != 0) {
  810. ret = -EFAULT;
  811. goto free_counters;
  812. }
  814. t = arpt_get_target(e);
  815. if (copy_to_user(userptr + off + e->target_offset
  816.  + offsetof(struct arpt_entry_target,
  817.     u.user.name),
  818.  t->u.kernel.target->name,
  819.  strlen(t->u.kernel.target->name)+1) != 0) {
  820. ret = -EFAULT;
  821. goto free_counters;
  822. }
  823. }
  825.  free_counters:
  826. vfree(counters);
  827. return ret;
  828. }
  830. static int get_entries(const struct arpt_get_entries *entries,
  831.        struct arpt_get_entries *uptr)
  832. {
  833. int ret;
  834. struct arpt_table *t;
  836. t = find_table_lock(entries->name, &ret, &arpt_mutex);
  837. if (t) {
  838. duprintf("t->private->number = %un",
  839.  t->private->number);
  840. if (entries->size == t->private->size)
  841. ret = copy_entries_to_user(t->private->size,
  842.    t, uptr->entrytable);
  843. else {
  844. duprintf("get_entries: I've got %u not %u!n",
  845.  t->private->size,
  846.  entries->size);
  847. ret = -EINVAL;
  848. }
  849. up(&arpt_mutex);
  850. } else
  851. duprintf("get_entries: Can't find %s!n",
  852.  entries->name);
  854. return ret;
  855. }
  857. static int do_replace(void *user, unsigned int len)
  858. {
  859. int ret;
  860. struct arpt_replace tmp;
  861. struct arpt_table *t;
  862. struct arpt_table_info *newinfo, *oldinfo;
  863. struct arpt_counters *counters;
  865. if (copy_from_user(&tmp, user, sizeof(tmp)) != 0)
  866. return -EFAULT;
  868. /* Hack: Causes ipchains to give correct error msg --RR */
  869. if (len != sizeof(tmp) + tmp.size)
  870. return -ENOPROTOOPT;
  872. /* Pedantry: prevent them from hitting BUG() in vmalloc.c --RR */
  873. if ((SMP_ALIGN(tmp.size) >> PAGE_SHIFT) + 2 > num_physpages)
  874. return -ENOMEM;
  876. newinfo = vmalloc(sizeof(struct arpt_table_info)
  877.   + SMP_ALIGN(tmp.size) * smp_num_cpus);
  878. if (!newinfo)
  879. return -ENOMEM;
  881. if (copy_from_user(newinfo->entries, user + sizeof(tmp),
  882.    tmp.size) != 0) {
  883. ret = -EFAULT;
  884. goto free_newinfo;
  885. }
  887. counters = vmalloc(tmp.num_counters * sizeof(struct arpt_counters));
  888. if (!counters) {
  889. ret = -ENOMEM;
  890. goto free_newinfo;
  891. }
  892. memset(counters, 0, tmp.num_counters * sizeof(struct arpt_counters));
  894. ret = translate_table(tmp.name, tmp.valid_hooks,
  895.       newinfo, tmp.size, tmp.num_entries,
  896.       tmp.hook_entry, tmp.underflow);
  897. if (ret != 0)
  898. goto free_newinfo_counters;
  900. duprintf("arp_tables: Translated tablen");
  902. t = find_table_lock(tmp.name, &ret, &arpt_mutex);
  903. if (!t)
  904. goto free_newinfo_counters_untrans;
  906. /* You lied! */
  907. if (tmp.valid_hooks != t->valid_hooks) {
  908. duprintf("Valid hook crap: %08X vs %08Xn",
  909.  tmp.valid_hooks, t->valid_hooks);
  910. ret = -EINVAL;
  911. goto free_newinfo_counters_untrans_unlock;
  912. }
  914. oldinfo = replace_table(t, tmp.num_counters, newinfo, &ret);
  915. if (!oldinfo)
  916. goto free_newinfo_counters_untrans_unlock;
  918. /* Update module usage count based on number of rules */
  919. duprintf("do_replace: oldnum=%u, initnum=%u, newnum=%un",
  920. oldinfo->number, oldinfo->initial_entries, newinfo->number);
  921. if (t->me && (oldinfo->number <= oldinfo->initial_entries) &&
  922.       (newinfo->number > oldinfo->initial_entries))
  923. __MOD_INC_USE_COUNT(t->me);
  924. else if (t->me && (oldinfo->number > oldinfo->initial_entries) &&
  925.    (newinfo->number <= oldinfo->initial_entries))
  926. __MOD_DEC_USE_COUNT(t->me);
  928. /* Get the old counters. */
  929. get_counters(oldinfo, counters);
  930. /* Decrease module usage counts and free resource */
  931. ARPT_ENTRY_ITERATE(oldinfo->entries, oldinfo->size, cleanup_entry,NULL);
  932. vfree(oldinfo);
  933. /* Silent error: too late now. */
  934. copy_to_user(tmp.counters, counters,
  935.      sizeof(struct arpt_counters) * tmp.num_counters);
  936. vfree(counters);
  937. up(&arpt_mutex);
  938. return 0;
  940.  free_newinfo_counters_untrans_unlock:
  941. up(&arpt_mutex);
  942.  free_newinfo_counters_untrans:
  943. ARPT_ENTRY_ITERATE(newinfo->entries, newinfo->size, cleanup_entry, NULL);
  944.  free_newinfo_counters:
  945. vfree(counters);
  946.  free_newinfo:
  947. vfree(newinfo);
  948. return ret;
  949. }
  951. /* We're lazy, and add to the first CPU; overflow works its fey magic
  952.  * and everything is OK.
  953.  */
  954. static inline int add_counter_to_entry(struct arpt_entry *e,
  955.        const struct arpt_counters addme[],
  956.        unsigned int *i)
  957. {
  959. ADD_COUNTER(e->counters, addme[*i].bcnt, addme[*i].pcnt);
  961. (*i)++;
  962. return 0;
  963. }
  965. static int do_add_counters(void *user, unsigned int len)
  966. {
  967. unsigned int i;
  968. struct arpt_counters_info tmp, *paddc;
  969. struct arpt_table *t;
  970. int ret;
  972. if (copy_from_user(&tmp, user, sizeof(tmp)) != 0)
  973. return -EFAULT;
  975. if (len != sizeof(tmp) + tmp.num_counters*sizeof(struct arpt_counters))
  976. return -EINVAL;
  978. paddc = vmalloc(len);
  979. if (!paddc)
  980. return -ENOMEM;
  982. if (copy_from_user(paddc, user, len) != 0) {
  983. ret = -EFAULT;
  984. goto free;
  985. }
  987. t = find_table_lock(tmp.name, &ret, &arpt_mutex);
  988. if (!t)
  989. goto free;
  991. write_lock_bh(&t->lock);
  992. if (t->private->number != paddc->num_counters) {
  993. ret = -EINVAL;
  994. goto unlock_up_free;
  995. }
  997. i = 0;
  998. ARPT_ENTRY_ITERATE(t->private->entries,
  999.    t->private->size,
  1000.    add_counter_to_entry,
  1001.    paddc->counters,
  1002.    &i);
  1003.  unlock_up_free:
  1004. write_unlock_bh(&t->lock);
  1005. up(&arpt_mutex);
  1006.  free:
  1007. vfree(paddc);
  1009. return ret;
  1010. }
  1012. static int do_arpt_set_ctl(struct sock *sk, int cmd, void *user, unsigned int len)
  1013. {
  1014. int ret;
  1016. if (!capable(CAP_NET_ADMIN))
  1017. return -EPERM;
  1019. switch (cmd) {
  1020. case ARPT_SO_SET_REPLACE:
  1021. ret = do_replace(user, len);
  1022. break;
  1024. case ARPT_SO_SET_ADD_COUNTERS:
  1025. ret = do_add_counters(user, len);
  1026. break;
  1028. default:
  1029. duprintf("do_arpt_set_ctl:  unknown request %in", cmd);
  1030. ret = -EINVAL;
  1031. }
  1033. return ret;
  1034. }
  1036. static int do_arpt_get_ctl(struct sock *sk, int cmd, void *user, int *len)
  1037. {
  1038. int ret;
  1040. if (!capable(CAP_NET_ADMIN))
  1041. return -EPERM;
  1043. switch (cmd) {
  1044. case ARPT_SO_GET_INFO: {
  1045. char name[ARPT_TABLE_MAXNAMELEN];
  1046. struct arpt_table *t;
  1048. if (*len != sizeof(struct arpt_getinfo)) {
  1049. duprintf("length %u != %Zun", *len,
  1050.  sizeof(struct arpt_getinfo));
  1051. ret = -EINVAL;
  1052. break;
  1053. }
  1055. if (copy_from_user(name, user, sizeof(name)) != 0) {
  1056. ret = -EFAULT;
  1057. break;
  1058. }
  1059. name[ARPT_TABLE_MAXNAMELEN-1] = '';
  1060. t = find_table_lock(name, &ret, &arpt_mutex);
  1061. if (t) {
  1062. struct arpt_getinfo info;
  1064. info.valid_hooks = t->valid_hooks;
  1065. memcpy(info.hook_entry, t->private->hook_entry,
  1066.        sizeof(info.hook_entry));
  1067. memcpy(info.underflow, t->private->underflow,
  1068.        sizeof(info.underflow));
  1069. info.num_entries = t->private->number;
  1070. info.size = t->private->size;
  1071. strcpy(info.name, name);
  1073. if (copy_to_user(user, &info, *len) != 0)
  1074. ret = -EFAULT;
  1075. else
  1076. ret = 0;
  1078. up(&arpt_mutex);
  1079. }
  1080. }
  1081. break;
  1083. case ARPT_SO_GET_ENTRIES: {
  1084. struct arpt_get_entries get;
  1086. if (*len < sizeof(get)) {
  1087. duprintf("get_entries: %u < %Zun", *len, sizeof(get));
  1088. ret = -EINVAL;
  1089. } else if (copy_from_user(&get, user, sizeof(get)) != 0) {
  1090. ret = -EFAULT;
  1091. } else if (*len != sizeof(struct arpt_get_entries) + get.size) {
  1092. duprintf("get_entries: %u != %Zun", *len,
  1093.  sizeof(struct arpt_get_entries) + get.size);
  1094. ret = -EINVAL;
  1095. } else
  1096. ret = get_entries(&get, user);
  1097. break;
  1098. }
  1100. default:
  1101. duprintf("do_arpt_get_ctl: unknown request %in", cmd);
  1102. ret = -EINVAL;
  1103. }
  1105. return ret;
  1106. }
  1108. /* Registration hooks for targets. */
  1109. int arpt_register_target(struct arpt_target *target)
  1110. {
  1111. int ret;
  1113. MOD_INC_USE_COUNT;
  1114. ret = down_interruptible(&arpt_mutex);
  1115. if (ret != 0) {
  1116. MOD_DEC_USE_COUNT;
  1117. return ret;
  1118. }
  1119. if (!list_named_insert(&arpt_target, target)) {
  1120. duprintf("arpt_register_target: `%s' already in list!n",
  1121.  target->name);
  1122. ret = -EINVAL;
  1123. MOD_DEC_USE_COUNT;
  1124. }
  1125. up(&arpt_mutex);
  1126. return ret;
  1127. }
  1129. void arpt_unregister_target(struct arpt_target *target)
  1130. {
  1131. down(&arpt_mutex);
  1132. LIST_DELETE(&arpt_target, target);
  1133. up(&arpt_mutex);
  1134. MOD_DEC_USE_COUNT;
  1135. }
  1137. int arpt_register_table(struct arpt_table *table)
  1138. {
  1139. int ret;
  1140. struct arpt_table_info *newinfo;
  1141. static struct arpt_table_info bootstrap
  1142. = { 0, 0, 0, { 0 }, { 0 }, { } };
  1144. MOD_INC_USE_COUNT;
  1145. newinfo = vmalloc(sizeof(struct arpt_table_info)
  1146.   + SMP_ALIGN(table->table->size) * smp_num_cpus);
  1147. if (!newinfo) {
  1148. ret = -ENOMEM;
  1149. MOD_DEC_USE_COUNT;
  1150. return ret;
  1151. }
  1152. memcpy(newinfo->entries, table->table->entries, table->table->size);
  1154. ret = translate_table(table->name, table->valid_hooks,
  1155.       newinfo, table->table->size,
  1156.       table->table->num_entries,
  1157.       table->table->hook_entry,
  1158.       table->table->underflow);
  1159. duprintf("arpt_register_table: translate table gives %dn", ret);
  1160. if (ret != 0) {
  1161. vfree(newinfo);
  1162. MOD_DEC_USE_COUNT;
  1163. return ret;
  1164. }
  1166. ret = down_interruptible(&arpt_mutex);
  1167. if (ret != 0) {
  1168. vfree(newinfo);
  1169. MOD_DEC_USE_COUNT;
  1170. return ret;
  1171. }
  1173. /* Don't autoload: we'd eat our tail... */
  1174. if (list_named_find(&arpt_tables, table->name)) {
  1175. ret = -EEXIST;
  1176. goto free_unlock;
  1177. }
  1179. /* Simplifies replace_table code. */
  1180. table->private = &bootstrap;
  1181. if (!replace_table(table, 0, newinfo, &ret))
  1182. goto free_unlock;
  1184. duprintf("table->private->number = %un",
  1185.  table->private->number);
  1187. /* save number of initial entries */
  1188. table->private->initial_entries = table->private->number;
  1190. table->lock = RW_LOCK_UNLOCKED;
  1191. list_prepend(&arpt_tables, table);
  1193.  unlock:
  1194. up(&arpt_mutex);
  1195. return ret;
  1197.  free_unlock:
  1198. vfree(newinfo);
  1199. MOD_DEC_USE_COUNT;
  1200. goto unlock;
  1201. }
  1203. void arpt_unregister_table(struct arpt_table *table)
  1204. {
  1205. down(&arpt_mutex);
  1206. LIST_DELETE(&arpt_tables, table);
  1207. up(&arpt_mutex);
  1209. /* Decrease module usage counts and free resources */
  1210. ARPT_ENTRY_ITERATE(table->private->entries, table->private->size,
  1211.    cleanup_entry, NULL);
  1212. vfree(table->private);
  1213. MOD_DEC_USE_COUNT;
  1214. }
  1216. /* The built-in targets: standard (NULL) and error. */
  1217. static struct arpt_target arpt_standard_target
  1218. = { { NULL, NULL }, ARPT_STANDARD_TARGET, NULL, NULL, NULL };
  1219. static struct arpt_target arpt_error_target
  1220. = { { NULL, NULL }, ARPT_ERROR_TARGET, arpt_error, NULL, NULL };
  1222. static struct nf_sockopt_ops arpt_sockopts
  1223. = { { NULL, NULL }, PF_INET, ARPT_BASE_CTL, ARPT_SO_SET_MAX+1, do_arpt_set_ctl,
  1224.     ARPT_BASE_CTL, ARPT_SO_GET_MAX+1, do_arpt_get_ctl, 0, NULL  };
  1226. #ifdef CONFIG_PROC_FS
  1227. static inline int print_name(const struct arpt_table *t,
  1228.      off_t start_offset, char *buffer, int length,
  1229.      off_t *pos, unsigned int *count)
  1230. {
  1231. if ((*count)++ >= start_offset) {
  1232. unsigned int namelen;
  1234. namelen = sprintf(buffer + *pos, "%sn", t->name);
  1235. if (*pos + namelen > length) {
  1236. /* Stop iterating */
  1237. return 1;
  1238. }
  1239. *pos += namelen;
  1240. }
  1241. return 0;
  1242. }
  1244. static int arpt_get_tables(char *buffer, char **start, off_t offset, int length)
  1245. {
  1246. off_t pos = 0;
  1247. unsigned int count = 0;
  1249. if (down_interruptible(&arpt_mutex) != 0)
  1250. return 0;
  1252. LIST_FIND(&arpt_tables, print_name, struct arpt_table *,
  1253.   offset, buffer, length, &pos, &count);
  1255. up(&arpt_mutex);
  1257. /* `start' hack - see fs/proc/generic.c line ~105 */
  1258. *start=(char *)((unsigned long)count-offset);
  1259. return pos;
  1260. }
  1261. #endif /*CONFIG_PROC_FS*/
  1263. static int __init init(void)
  1264. {
  1265. int ret;
  1267. /* Noone else will be downing sem now, so we won't sleep */
  1268. down(&arpt_mutex);
  1269. list_append(&arpt_target, &arpt_standard_target);
  1270. list_append(&arpt_target, &arpt_error_target);
  1271. up(&arpt_mutex);
  1273. /* Register setsockopt */
  1274. ret = nf_register_sockopt(&arpt_sockopts);
  1275. if (ret < 0) {
  1276. duprintf("Unable to register sockopts.n");
  1277. return ret;
  1278. }
  1280. #ifdef CONFIG_PROC_FS
  1281. {
  1282. struct proc_dir_entry *proc;
  1284. proc = proc_net_create("arp_tables_names", 0, arpt_get_tables);
  1285. if (!proc) {
  1286. nf_unregister_sockopt(&arpt_sockopts);
  1287. return -ENOMEM;
  1288. }
  1289. proc->owner = THIS_MODULE;
  1290. }
  1291. #endif
  1293. printk("arp_tables: (C) 2002 David S. Millern");
  1294. return 0;
  1295. }
  1297. static void __exit fini(void)
  1298. {
  1299. nf_unregister_sockopt(&arpt_sockopts);
  1300. #ifdef CONFIG_PROC_FS
  1301. proc_net_remove("arp_tables_names");
  1302. #endif
  1303. }
  1305. EXPORT_SYMBOL(arpt_register_table);
  1306. EXPORT_SYMBOL(arpt_unregister_table);
  1307. EXPORT_SYMBOL(arpt_do_table);
  1308. EXPORT_SYMBOL(arpt_register_target);
  1309. EXPORT_SYMBOL(arpt_unregister_target);
  1311. module_init(init);
  1312. module_exit(fini);
  1313. MODULE_LICENSE("GPL");