cregit-Linux how code gets into the kernel

Release 4.7 net/ipv4/netfilter/ip_tables.c

/*
 * Packet matching code.
 *
 * Copyright (C) 1999 Paul `Rusty' Russell & Michael J. Neuling
 * Copyright (C) 2000-2005 Netfilter Core Team <coreteam@netfilter.org>
 * Copyright (C) 2006-2010 Patrick McHardy <kaber@trash.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/cache.h>
#include <linux/capability.h>
#include <linux/skbuff.h>
#include <linux/kmod.h>
#include <linux/vmalloc.h>
#include <linux/netdevice.h>
#include <linux/module.h>
#include <linux/icmp.h>
#include <net/ip.h>
#include <net/compat.h>
#include <asm/uaccess.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/err.h>
#include <linux/cpumask.h>

#include <linux/netfilter/x_tables.h>
#include <linux/netfilter_ipv4/ip_tables.h>
#include <net/netfilter/nf_log.h>
#include "../../netfilter/xt_repldata.h"

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Netfilter Core Team <coreteam@netfilter.org>");
MODULE_DESCRIPTION("IPv4 packet filter");

#ifdef CONFIG_NETFILTER_DEBUG

#define IP_NF_ASSERT(x)		WARN_ON(!(x))
#else

#define IP_NF_ASSERT(x)
#endif


void *ipt_alloc_initial_table(const struct xt_table *info) { return xt_alloc_initial_table(ipt, IPT); }

Contributors

PersonTokensPropCommitsCommitProp
jan engelhardtjan engelhardt20100.00%1100.00%
Total20100.00%1100.00%

EXPORT_SYMBOL_GPL(ipt_alloc_initial_table); /* Returns whether matches rule or not. */ /* Performance critical - called for every packet */
static inline bool ip_packet_match(const struct iphdr *ip, const char *indev, const char *outdev, const struct ipt_ip *ipinfo, int isfrag) { unsigned long ret; #define FWINV(bool, invflg) ((bool) ^ !!(ipinfo->invflags & (invflg))) if (FWINV((ip->saddr&ipinfo->smsk.s_addr) != ipinfo->src.s_addr, IPT_INV_SRCIP) || FWINV((ip->daddr&ipinfo->dmsk.s_addr) != ipinfo->dst.s_addr, IPT_INV_DSTIP)) return false; ret = ifname_compare_aligned(indev, ipinfo->iniface, ipinfo->iniface_mask); if (FWINV(ret != 0, IPT_INV_VIA_IN)) return false; ret = ifname_compare_aligned(outdev, ipinfo->outiface, ipinfo->outiface_mask); if (FWINV(ret != 0, IPT_INV_VIA_OUT)) return false; /* Check specific protocol */ if (ipinfo->proto && FWINV(ip->protocol != ipinfo->proto, IPT_INV_PROTO)) return false; /* If we have a fragment rule but the packet is not a fragment * then we return zero */ if (FWINV((ipinfo->flags&IPT_F_FRAG) && !isfrag, IPT_INV_FRAG)) return false; return true; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git18491.09%120.00%
eric dumazeteric dumazet104.95%240.00%
patrick mchardypatrick mchardy73.47%120.00%
jan engelhardtjan engelhardt10.50%120.00%
Total202100.00%5100.00%


static bool ip_checkentry(const struct ipt_ip *ip) { if (ip->flags & ~IPT_F_MASK) return false; if (ip->invflags & ~IPT_INV_MASK) return false; return true; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git3589.74%150.00%
jan engelhardtjan engelhardt410.26%150.00%
Total39100.00%2100.00%


static unsigned int ipt_error(struct sk_buff *skb, const struct xt_action_param *par) { net_info_ratelimited("error: `%s'\n", (const char *)par->targinfo); return NF_DROP; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git2777.14%116.67%
jan engelhardtjan engelhardt617.14%350.00%
herbert xuherbert xu12.86%116.67%
joe perchesjoe perches12.86%116.67%
Total35100.00%6100.00%

/* Performance critical */
static inline struct ipt_entry * get_entry(const void *base, unsigned int offset) { return (struct ipt_entry *)(base + offset); }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git2996.67%150.00%
jan engelhardtjan engelhardt13.33%150.00%
Total30100.00%2100.00%

/* All zeroes == unconditional rule. */ /* Mildly perf critical (only if packet tracing is on) */
static inline bool unconditional(const struct ipt_entry *e) { static const struct ipt_ip uncond; return e->target_offset == sizeof(struct ipt_entry) && memcmp(&e->ip, &uncond, sizeof(uncond)) == 0; #undef FWINV }

Contributors

PersonTokensPropCommitsCommitProp
jan engelhardtjan engelhardt1835.29%250.00%
jozsef kadlecsikjozsef kadlecsik1835.29%125.00%
florian westphalflorian westphal1529.41%125.00%
Total51100.00%4100.00%

/* for const-correctness */
static inline const struct xt_entry_target * ipt_get_target_c(const struct ipt_entry *e) { return ipt_get_target((struct ipt_entry *)e); }

Contributors

PersonTokensPropCommitsCommitProp
jan engelhardtjan engelhardt27100.00%2100.00%
Total27100.00%2100.00%

#if IS_ENABLED(CONFIG_NETFILTER_XT_TARGET_TRACE) static const char *const hooknames[] = { [NF_INET_PRE_ROUTING] = "PREROUTING", [NF_INET_LOCAL_IN] = "INPUT", [NF_INET_FORWARD] = "FORWARD", [NF_INET_LOCAL_OUT] = "OUTPUT", [NF_INET_POST_ROUTING] = "POSTROUTING", }; enum nf_ip_trace_comments { NF_IP_TRACE_COMMENT_RULE, NF_IP_TRACE_COMMENT_RETURN, NF_IP_TRACE_COMMENT_POLICY, }; static const char *const comments[] = { [NF_IP_TRACE_COMMENT_RULE] = "rule", [NF_IP_TRACE_COMMENT_RETURN] = "return", [NF_IP_TRACE_COMMENT_POLICY] = "policy", }; static struct nf_loginfo trace_loginfo = { .type = NF_LOG_TYPE_LOG, .u = { .log = { .level = 4, .logflags = NF_LOG_MASK, }, }, }; /* Mildly perf critical (only if packet tracing is on) */
static inline int get_chainname_rulenum(const struct ipt_entry *s, const struct ipt_entry *e, const char *hookname, const char **chainname, const char **comment, unsigned int *rulenum) { const struct xt_standard_target *t = (void *)ipt_get_target_c(s); if (strcmp(t->target.u.kernel.target->name, XT_ERROR_TARGET) == 0) { /* Head of user chain: ERROR target with chainname */ *chainname = t->target.data; (*rulenum) = 0; } else if (s == e) { (*rulenum)++; if (unconditional(s) && strcmp(t->target.u.kernel.target->name, XT_STANDARD_TARGET) == 0 && t->verdict < 0) { /* Tail of chains: STANDARD target (return/policy) */ *comment = *chainname == hookname ? comments[NF_IP_TRACE_COMMENT_POLICY] : comments[NF_IP_TRACE_COMMENT_RETURN]; } return 1; } else (*rulenum)++; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
jozsef kadlecsikjozsef kadlecsik16593.22%116.67%
jan engelhardtjan engelhardt105.65%466.67%
florian westphalflorian westphal21.13%116.67%
Total177100.00%6100.00%


static void trace_packet(struct net *net, const struct sk_buff *skb, unsigned int hook, const struct net_device *in, const struct net_device *out, const char *tablename, const struct xt_table_info *private, const struct ipt_entry *e) { const struct ipt_entry *root; const char *hookname, *chainname, *comment; const struct ipt_entry *iter; unsigned int rulenum = 0; root = get_entry(private->entries, private->hook_entry[hook]); hookname = chainname = hooknames[hook]; comment = comments[NF_IP_TRACE_COMMENT_RULE]; xt_entry_foreach(iter, root, private->size - private->hook_entry[hook]) if (get_chainname_rulenum(iter, e, hookname, &chainname, &comment, &rulenum) != 0) break; nf_log_trace(net, AF_INET, hook, skb, in, out, &trace_loginfo, "TRACE: %s:%s:%s:%u ", tablename, chainname, comment, rulenum); }

Contributors

PersonTokensPropCommitsCommitProp
jozsef kadlecsikjozsef kadlecsik13478.82%111.11%
jan engelhardtjan engelhardt2514.71%444.44%
eric w. biedermaneric w. biederman52.94%111.11%
florian westphalflorian westphal31.76%111.11%
gao fenggao feng21.18%111.11%
pablo neira ayusopablo neira ayuso10.59%111.11%
Total170100.00%9100.00%

#endif
static inline struct ipt_entry *ipt_next_entry(const struct ipt_entry *entry) { return (void *)entry + entry->next_offset; }

Contributors

PersonTokensPropCommitsCommitProp
jan engelhardtjan engelhardt1765.38%150.00%
florian westphalflorian westphal934.62%150.00%
Total26100.00%2100.00%

/* Returns one of the generic firewall policies, like NF_ACCEPT. */
unsigned int ipt_do_table(struct sk_buff *skb, const struct nf_hook_state *state, struct xt_table *table) { unsigned int hook = state->hook; static const char nulldevname[IFNAMSIZ] __attribute__((aligned(sizeof(long)))); const struct iphdr *ip; /* Initializing verdict to NF_DROP keeps gcc happy. */ unsigned int verdict = NF_DROP; const char *indev, *outdev; const void *table_base; struct ipt_entry *e, **jumpstack; unsigned int stackidx, cpu; const struct xt_table_info *private; struct xt_action_param acpar; unsigned int addend; /* Initialization */ stackidx = 0; ip = ip_hdr(skb); indev = state->in ? state->in->name : nulldevname; outdev = state->out ? state->out->name : nulldevname; /* We handle fragments by dealing with the first fragment as * if it was a normal packet. All other fragments are treated * normally, except that they will NEVER match rules that ask * things we don't know, ie. tcp syn flag or ports). If the * rule is also a fragment-specific rule, non-fragments won't * match it. */ acpar.fragoff = ntohs(ip->frag_off) & IP_OFFSET; acpar.thoff = ip_hdrlen(skb); acpar.hotdrop = false; acpar.net = state->net; acpar.in = state->in; acpar.out = state->out; acpar.family = NFPROTO_IPV4; acpar.hooknum = hook; IP_NF_ASSERT(table->valid_hooks & (1 << hook)); local_bh_disable(); addend = xt_write_recseq_begin(); private = table->private; cpu = smp_processor_id(); /* * Ensure we load private-> members after we've fetched the base * pointer. */ smp_read_barrier_depends(); table_base = private->entries; jumpstack = (struct ipt_entry **)private->jumpstack[cpu]; /* Switch to alternate jumpstack if we're being invoked via TEE. * TEE issues XT_CONTINUE verdict on original skb so we must not * clobber the jumpstack. * * For recursion via REJECT or SYNPROXY the stack will be clobbered * but it is no problem since absolute verdict is issued by these. */ if (static_key_false(&xt_tee_enabled)) jumpstack += private->stacksize * __this_cpu_read(nf_skb_duplicated); e = get_entry(table_base, private->hook_entry[hook]); do { const struct xt_entry_target *t; const struct xt_entry_match *ematch; struct xt_counters *counter; IP_NF_ASSERT(e); if (!ip_packet_match(ip, indev, outdev, &e->ip, acpar.fragoff)) { no_match: e = ipt_next_entry(e); continue; } xt_ematch_foreach(ematch, e) { acpar.match = ematch->u.kernel.match; acpar.matchinfo = ematch->data; if (!acpar.match->match(skb, &acpar)) goto no_match; } counter = xt_get_this_cpu_counter(&e->counters); ADD_COUNTER(*counter, skb->len, 1); t = ipt_get_target(e); IP_NF_ASSERT(t->u.kernel.target); #if IS_ENABLED(CONFIG_NETFILTER_XT_TARGET_TRACE) /* The packet is traced: log it */ if (unlikely(skb->nf_trace)) trace_packet(state->net, skb, hook, state->in, state->out, table->name, private, e); #endif /* Standard target? */ if (!t->u.kernel.target->target) { int v; v = ((struct xt_standard_target *)t)->verdict; if (v < 0) { /* Pop from stack? */ if (v != XT_RETURN) { verdict = (unsigned int)(-v) - 1; break; } if (stackidx == 0) { e = get_entry(table_base, private->underflow[hook]); } else { e = jumpstack[--stackidx]; e = ipt_next_entry(e); } continue; } if (table_base + v != ipt_next_entry(e) && !(e->ip.flags & IPT_F_GOTO)) jumpstack[stackidx++] = e; e = get_entry(table_base, v); continue; } acpar.target = t->u.kernel.target; acpar.targinfo = t->data; verdict = t->u.kernel.target->target(skb, &acpar); /* Target might have changed stuff. */ ip = ip_hdr(skb); if (verdict == XT_CONTINUE) e = ipt_next_entry(e); else /* Verdict */ break; } while (!acpar.hotdrop); xt_write_recseq_end(addend); local_bh_enable(); if (acpar.hotdrop) return NF_DROP; else return verdict; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git31843.86%25.13%
jan engelhardtjan engelhardt21930.21%1641.03%
florian westphalflorian westphal415.66%37.69%
jozsef kadlecsikjozsef kadlecsik344.69%12.56%
eric w. biedermaneric w. biederman202.76%37.69%
eric dumazeteric dumazet192.62%37.69%
david s. millerdavid s. miller182.48%12.56%
patrick mchardypatrick mchardy172.34%25.13%
kurt garloffkurt garloff121.66%12.56%
herbert xuherbert xu70.97%12.56%
arnaldo carvalho de meloarnaldo carvalho de melo60.83%12.56%
harald welteharald welte50.69%12.56%
will deaconwill deacon40.55%12.56%
changli gaochangli gao20.28%12.56%
stephen hemmingerstephen hemminger20.28%12.56%
gao fenggao feng10.14%12.56%
Total725100.00%39100.00%


static bool find_jump_target(const struct xt_table_info *t, const struct ipt_entry *target) { struct ipt_entry *iter; xt_entry_foreach(iter, t->entries, t->size) { if (iter == target) return true; } return false; }

Contributors

PersonTokensPropCommitsCommitProp
florian westphalflorian westphal45100.00%1100.00%
Total45100.00%1100.00%

/* Figures out from what hook each rule can be called: returns 0 if there are loops. Puts hook bitmask in comefrom. */
static int mark_source_chains(const struct xt_table_info *newinfo, unsigned int valid_hooks, void *entry0) { unsigned int hook; /* No recursion; use packet counter to save back ptrs (reset to 0 as we leave), and comefrom to save source hook bitmask */ for (hook = 0; hook < NF_INET_NUMHOOKS; hook++) { unsigned int pos = newinfo->hook_entry[hook]; struct ipt_entry *e = (struct ipt_entry *)(entry0 + pos); if (!(valid_hooks & (1 << hook))) continue; /* Set initial back pointer. */ e->counters.pcnt = pos; for (;;) { const struct xt_standard_target *t = (void *)ipt_get_target_c(e); int visited = e->comefrom & (1 << hook); if (e->comefrom & (1 << NF_INET_NUMHOOKS)) return 0; e->comefrom |= ((1 << hook) | (1 << NF_INET_NUMHOOKS)); /* Unconditional return/END. */ if ((unconditional(e) && (strcmp(t->target.u.user.name, XT_STANDARD_TARGET) == 0) && t->verdict < 0) || visited) { unsigned int oldpos, size; if ((strcmp(t->target.u.user.name, XT_STANDARD_TARGET) == 0) && t->verdict < -NF_MAX_VERDICT - 1) return 0; /* Return: backtrack through the last big jump. */ do { e->comefrom ^= (1<<NF_INET_NUMHOOKS); oldpos = pos; pos = e->counters.pcnt; e->counters.pcnt = 0; /* We're at the start. */ if (pos == oldpos) goto next; e = (struct ipt_entry *) (entry0 + pos); } while (oldpos == pos + e->next_offset); /* Move along one */ size = e->next_offset; e = (struct ipt_entry *) (entry0 + pos + size); if (pos + size >= newinfo->size) return 0; e->counters.pcnt = pos; pos += size; } else { int newpos = t->verdict; if (strcmp(t->target.u.user.name, XT_STANDARD_TARGET) == 0 && newpos >= 0) { /* This a jump; chase it. */ e = (struct ipt_entry *) (entry0 + newpos); if (!find_jump_target(newinfo, e)) return 0; } else { /* ... this is a fallthru */ newpos = pos + e->next_offset; if (newpos >= newinfo->size) return 0; } e = (struct ipt_entry *) (entry0 + newpos); e->counters.pcnt = pos; pos = newpos; } } next: ; } return 1; }

Contributors

PersonTokensPropCommitsCommitProp
harald welteharald welte26656.96%15.26%
rusty russellrusty russell7616.27%421.05%
florian westphalflorian westphal5311.35%421.05%
patrick mchardypatrick mchardy224.71%210.53%
al viroal viro173.64%15.26%
dmitry mishindmitry mishin143.00%15.26%
pre-gitpre-git102.14%15.26%
jan engelhardtjan engelhardt61.28%315.79%
jamal hadi salimjamal hadi salim20.43%15.26%
pablo neira ayusopablo neira ayuso10.21%15.26%
Total467100.00%19100.00%


static void cleanup_match(struct xt_entry_match *m, struct net *net) { struct xt_mtdtor_param par; par.net = net; par.match = m->u.kernel.match; par.matchinfo = m->data; par.family = NFPROTO_IPV4; if (par.match->destroy != NULL) par.match->destroy(&par); module_put(par.match->me); }

Contributors

PersonTokensPropCommitsCommitProp
jan engelhardtjan engelhardt3644.44%450.00%
harald welteharald welte2125.93%112.50%
rusty russellrusty russell1113.58%112.50%
alexey dobriyanalexey dobriyan1012.35%112.50%
patrick mchardypatrick mchardy33.70%112.50%
Total81100.00%8100.00%


static int check_match(struct xt_entry_match *m, struct xt_mtchk_param *par) { const struct ipt_ip *ip = par->entryinfo; par->match = m->u.kernel.match; par->matchinfo = m->data; return xt_check_match(par, m->u.match_size - sizeof(*m), ip->proto, ip->invflags & IPT_INV_PROTO); }

Contributors

PersonTokensPropCommitsCommitProp
patrick mchardypatrick mchardy2533.78%114.29%
jan engelhardtjan engelhardt2128.38%228.57%
dmitry mishindmitry mishin1520.27%114.29%
harald welteharald welte79.46%114.29%
pre-gitpre-git56.76%114.29%
pablo neira ayusopablo neira ayuso11.35%114.29%
Total74100.00%7100.00%


static int find_check_match(struct xt_entry_match *m, struct xt_mtchk_param *par) { struct xt_match *match; int ret; match = xt_request_find_match(NFPROTO_IPV4, m->u.user.name, m->u.user.revision); if (IS_ERR(match)) return PTR_ERR(match); m->u.kernel.match = match; ret = check_match(m, par); if (ret) goto err; return 0; err: module_put(m->u.kernel.match->me); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin5248.60%112.50%
harald welteharald welte3532.71%112.50%
pre-gitpre-git1312.15%225.00%
jan engelhardtjan engelhardt76.54%450.00%
Total107100.00%8100.00%


static int check_target(struct ipt_entry *e, struct net *net, const char *name) { struct xt_entry_target *t = ipt_get_target(e); struct xt_tgchk_param par = { .net = net, .table = name, .entryinfo = e, .target = t->u.kernel.target, .targinfo = t->data, .hook_mask = e->comefrom, .family = NFPROTO_IPV4, }; return xt_check_target(&par, t->u.target_size - sizeof(*t), e->ip.proto, e->ip.invflags & IPT_INV_PROTO); }

Contributors

PersonTokensPropCommitsCommitProp
jan engelhardtjan engelhardt4236.52%330.00%
patrick mchardypatrick mchardy3833.04%220.00%
dmitry mishindmitry mishin2925.22%110.00%
pre-gitpre-git32.61%220.00%
harald welteharald welte21.74%110.00%
pablo neira ayusopablo neira ayuso10.87%110.00%
Total115100.00%10100.00%


static int find_check_entry(struct ipt_entry *e, struct net *net, const char *name, unsigned int size) { struct xt_entry_target *t; struct xt_target *target; int ret; unsigned int j; struct xt_mtchk_param mtpar; struct xt_entry_match *ematch; unsigned long pcnt; pcnt = xt_percpu_counter_alloc(); if (IS_ERR_VALUE(pcnt)) return -ENOMEM; e->counters.pcnt = pcnt; j = 0; mtpar.net = net; mtpar.table = name; mtpar.entryinfo = &e->ip; mtpar.hook_mask = e->comefrom; mtpar.family = NFPROTO_IPV4; xt_ematch_foreach(ematch, e) { ret = find_check_match(ematch, &mtpar); if (ret != 0) goto cleanup_matches; ++j; } t = ipt_get_target(e); target = xt_request_find_target(NFPROTO_IPV4, t->u.user.name, t->u.user.revision); if (IS_ERR(target)) { ret = PTR_ERR(target); goto cleanup_matches; } t->u.kernel.target = target; ret = check_target(e, net, name); if (ret) goto err; return 0; err: module_put(t->u.kernel.target->me); cleanup_matches: xt_ematch_foreach(ematch, e) { if (j-- == 0) break; cleanup_match(ematch, net); } xt_percpu_counter_free(e->counters.pcnt); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin14351.07%16.25%
jan engelhardtjan engelhardt6924.64%743.75%
florian westphalflorian westphal258.93%16.25%
alexey dobriyanalexey dobriyan124.29%212.50%
pablo neira ayusopablo neira ayuso124.29%16.25%
harald welteharald welte103.57%16.25%
patrick mchardypatrick mchardy82.86%212.50%
pre-gitpre-git10.36%16.25%
Total280100.00%16100.00%


static bool check_underflow(const struct ipt_entry *e) { const struct xt_entry_target *t; unsigned int verdict; if (!unconditional(e)) return false; t = ipt_get_target_c(e); if (strcmp(t->u.user.name, XT_STANDARD_TARGET) != 0) return false; verdict = ((struct xt_standard_target *)t)->verdict; verdict = -verdict - 1; return verdict == NF_DROP || verdict == NF_ACCEPT; }

Contributors

PersonTokensPropCommitsCommitProp
jan engelhardtjan engelhardt89100.00%3100.00%
Total89100.00%3100.00%


static int check_entry_size_and_hooks(struct ipt_entry *e, struct xt_table_info *newinfo, const unsigned char *base, const unsigned char *limit, const unsigned int *hook_entries, const unsigned int *underflows, unsigned int valid_hooks) { unsigned int h; int err; if ((unsigned long)e % __alignof__(struct ipt_entry) != 0 || (unsigned char *)e + sizeof(struct ipt_entry) >= limit || (unsigned char *)e + e->next_offset > limit) return -EINVAL; if (e->next_offset < sizeof(struct ipt_entry) + sizeof(struct xt_entry_target)) return -EINVAL; if (!ip_checkentry(&e->ip)) return -EINVAL; err = xt_check_entry_offsets(e, e->elems, e->target_offset, e->next_offset); if (err) return err; /* Check hooks & underflows */ for (h = 0; h < NF_INET_NUMHOOKS; h++) { if (!(valid_hooks & (1 << h))) continue; if ((unsigned char *)e - base == hook_entries[h]) newinfo->hook_entry[h] = hook_entries[h]; if ((unsigned char *)e - base == underflows[h]) { if (!check_underflow(e)) return -EINVAL; newinfo->underflow[h] = underflows[h]; } } /* Clear counters and comefrom */ e->counters = ((struct xt_counters) { 0, 0 }); e->comefrom = 0; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
harald welteharald welte15453.47%17.69%
florian westphalflorian westphal5719.79%430.77%
pre-gitpre-git4415.28%215.38%
jan engelhardtjan engelhardt3211.11%538.46%
patrick mchardypatrick mchardy10.35%17.69%
Total288100.00%13100.00%


static void cleanup_entry(struct ipt_entry *e, struct net *net) { struct xt_tgdtor_param par; struct xt_entry_target *t; struct xt_entry_match *ematch; /* Cleanup all matches */ xt_ematch_foreach(ematch, e) cleanup_match(ematch, net); t = ipt_get_target(e); par.net = net; par.target = t->u.kernel.target; par.targinfo = t->data; par.family = NFPROTO_IPV4; if (par.target->destroy != NULL) par.target->destroy(&par); module_put(par.target->me); xt_percpu_counter_free(e->counters.pcnt); }

Contributors

PersonTokensPropCommitsCommitProp
jan engelhardtjan engelhardt4738.84%642.86%
pre-gitpre-git3226.45%214.29%
harald welteharald welte1814.88%17.14%
florian westphalflorian westphal97.44%17.14%
patrick mchardypatrick mchardy97.44%214.29%
alexey dobriyanalexey dobriyan54.13%17.14%
rusty russellrusty russell10.83%17.14%
Total121100.00%14100.00%

/* Checks and translates the user-supplied table segment (held in newinfo) */
static int translate_table(struct net *net, struct xt_table_info *newinfo, void *entry0, const struct ipt_replace *repl) { struct ipt_entry *iter; unsigned int i; int ret = 0; newinfo->size = repl->size; newinfo->number = repl->num_entries; /* Init all hooks to impossible value. */ for (i = 0; i < NF_INET_NUMHOOKS; i++) { newinfo->hook_entry[i] = 0xFFFFFFFF; newinfo->underflow[i] = 0xFFFFFFFF; } i = 0; /* Walk through entries, checking offsets. */ xt_entry_foreach(iter, entry0, newinfo->size) { ret = check_entry_size_and_hooks(iter, newinfo, entry0, entry0 + repl->size, repl->hook_entry, repl->underflow, repl->valid_hooks); if (ret != 0) return ret; ++i; if (strcmp(ipt_get_target(iter)->u.user.name, XT_ERROR_TARGET) == 0) ++newinfo->stacksize; } if (i != repl->num_entries) return -EINVAL; /* Check hooks all assigned */ for (i = 0; i < NF_INET_NUMHOOKS; i++) { /* Only hooks which are valid */ if (!(repl->valid_hooks & (1 << i))) continue; if (newinfo->hook_entry[i] == 0xFFFFFFFF) return -EINVAL; if (newinfo->underflow[i] == 0xFFFFFFFF) return -EINVAL; } if (!mark_source_chains(newinfo, repl->valid_hooks, entry0)) return -ELOOP; /* Finally, each sanity check must pass */ i = 0; xt_entry_foreach(iter, entry0, newinfo->size) { ret = find_check_entry(iter, net, repl->name, repl->size); if (ret != 0) break; ++i; } if (ret != 0) { xt_entry_foreach(iter, entry0, newinfo->size) { if (i-- == 0) break; cleanup_entry(iter, net); } return ret; } return ret; }

Contributors

PersonTokensPropCommitsCommitProp
harald welteharald welte13238.26%17.14%
jan engelhardtjan engelhardt9226.67%428.57%
pre-gitpre-git5315.36%17.14%
florian westphalflorian westphal257.25%17.14%
dmitry mishindmitry mishin246.96%214.29%
pablo neira ayusopablo neira ayuso82.32%17.14%
alexey dobriyanalexey dobriyan82.32%214.29%
patrick mchardypatrick mchardy20.58%17.14%
rusty russellrusty russell10.29%17.14%
Total345100.00%14100.00%


static void get_counters(const struct xt_table_info *t, struct xt_counters counters[]) { struct ipt_entry *iter; unsigned int cpu; unsigned int i; for_each_possible_cpu(cpu) { seqcount_t *s = &per_cpu(xt_recseq, cpu); i = 0; xt_entry_foreach(iter, t->entries, t->size) { struct xt_counters *tmp; u64 bcnt, pcnt; unsigned int start; tmp = xt_get_per_cpu_counter(&iter->counters, cpu); do { start = read_seqcount_begin(s); bcnt = tmp->bcnt; pcnt = tmp->pcnt; } while (read_seqcount_retry(s, start)); ADD_COUNTER(counters[i], bcnt, pcnt); ++i; /* macro does multi eval of i */ } } }

Contributors

PersonTokensPropCommitsCommitProp
eric dumazeteric dumazet4432.35%330.00%
jan engelhardtjan engelhardt3223.53%220.00%
florian westphalflorian westphal2014.71%220.00%
harald welteharald welte1813.24%110.00%
pre-gitpre-git1511.03%110.00%
stephen hemmingerstephen hemminger75.15%110.00%
Total136100.00%10100.00%


static struct xt_counters *alloc_counters(const struct xt_table *table) { unsigned int countersize; struct xt_counters *counters; const struct xt_table_info *private = table->private; /* We need atomic snapshot of counters: rest doesn't change (other than comefrom, which userspace doesn't care about). */ countersize = sizeof(struct xt_counters) * private->number; counters = vzalloc(countersize); if (counters == NULL) return ERR_PTR(-ENOMEM); get_counters(private, counters); return counters; }

Contributors

PersonTokensPropCommitsCommitProp
harald welteharald welte3850.00%112.50%
pre-gitpre-git1925.00%112.50%
dmitry mishindmitry mishin810.53%112.50%
stephen hemmingerstephen hemminger79.21%225.00%
jan engelhardtjan engelhardt33.95%225.00%
eric dumazeteric dumazet11.32%112.50%
Total76100.00%8100.00%


static int copy_entries_to_user(unsigned int total_size, const struct xt_table *table, void __user *userptr) { unsigned int off, num; const struct ipt_entry *e; struct xt_counters *counters; const struct xt_table_info *private = table->private; int ret = 0; const void *loc_cpu_entry; counters = alloc_counters(table); if (IS_ERR(counters)) return PTR_ERR(counters); loc_cpu_entry = private->entries; if (copy_to_user(userptr, loc_cpu_entry, total_size) != 0) { ret = -EFAULT; goto free_counters; } /* FIXME: use iterator macros --RR */ /* ... then go back and fix counters and names */ for (off = 0, num = 0; off < total_size; off += e->next_offset, num++){ unsigned int i; const struct xt_entry_match *m; const struct xt_entry_target *t; e = (struct ipt_entry *)(loc_cpu_entry + off); if (copy_to_user(userptr + off + offsetof(struct ipt_entry, counters), &counters[num], sizeof(counters[num])) != 0) { ret = -EFAULT; goto free_counters; } for (i = sizeof(struct ipt_entry); i < e->target_offset; i += m->u.match_size) { m = (void *)e + i; if (copy_to_user(userptr + off + i + offsetof(struct xt_entry_match, u.user.name), m->u.kernel.match->name, strlen(m->u.kernel.match->name)+1) != 0) { ret = -EFAULT; goto free_counters; } } t = ipt_get_target_c(e); if (copy_to_user(userptr + off + e->target_offset + offsetof(struct xt_entry_target, u.user.name), t->u.kernel.target->name, strlen(t->u.kernel.target->name)+1) != 0) { ret = -EFAULT; goto free_counters; } } free_counters: vfree(counters); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
harald welteharald welte23461.42%110.00%
dmitry mishindmitry mishin7218.90%110.00%
pre-gitpre-git5714.96%110.00%
jan engelhardtjan engelhardt112.89%440.00%
eric dumazeteric dumazet51.31%220.00%
david s. millerdavid s. miller20.52%110.00%
Total381100.00%10100.00%

#ifdef CONFIG_COMPAT
static void compat_standard_from_user(void *dst, const void *src) { int v = *(compat_int_t *)src; if (v > 0) v += xt_compat_calc_jump(AF_INET, v); memcpy(dst, &v, sizeof(v)); }

Contributors

PersonTokensPropCommitsCommitProp
patrick mchardypatrick mchardy2750.94%228.57%
dmitry mishindmitry mishin1120.75%114.29%
pre-gitpre-git1018.87%114.29%
harald welteharald welte35.66%114.29%
jan engelhardtjan engelhardt11.89%114.29%
eric dumazeteric dumazet11.89%114.29%
Total53100.00%7100.00%


static int compat_standard_to_user(void __user *dst, const void *src) { compat_int_t cv = *(int *)src; if (cv > 0) cv -= xt_compat_calc_jump(AF_INET, cv); return copy_to_user(dst, &cv, sizeof(cv)) ? -EFAULT : 0; }

Contributors

PersonTokensPropCommitsCommitProp
patrick mchardypatrick mchardy4168.33%233.33%
pre-gitpre-git915.00%116.67%
dmitry mishindmitry mishin610.00%116.67%
harald welteharald welte35.00%116.67%
jan engelhardtjan engelhardt11.67%116.67%
Total60100.00%6100.00%


static int compat_calc_entry(const struct ipt_entry *e, const struct xt_table_info *info, const void *base, struct xt_table_info *newinfo) { const struct xt_entry_match *ematch; const struct xt_entry_target *t; unsigned int entry_offset; int off, i, ret; off = sizeof(struct ipt_entry) - sizeof(struct compat_ipt_entry); entry_offset = (void *)e - base; xt_ematch_foreach(ematch, e) off += xt_compat_match_offset(ematch->u.kernel.match); t = ipt_get_target_c(e); off += xt_compat_target_offset(t->u.kernel.target); newinfo->size -= off; ret = xt_compat_add_offset(AF_INET, entry_offset, off); if (ret) return ret; for (i = 0; i < NF_INET_NUMHOOKS; i++) { if (info->hook_entry[i] && (e < (struct ipt_entry *)(base + info->hook_entry[i]))) newinfo->hook_entry[i] -= off; if (info->underflow[i] && (e < (struct ipt_entry *)(base + info->underflow[i]))) newinfo->underflow[i] -= off; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin17073.28%214.29%
jan engelhardtjan engelhardt2711.64%428.57%
patrick mchardypatrick mchardy198.19%428.57%
eric dumazeteric dumazet73.02%214.29%
harald welteharald welte52.16%17.14%
rusty russellrusty russell41.72%17.14%
Total232100.00%14100.00%


static int compat_table_info(const struct xt_table_info *info, struct xt_table_info *newinfo) { struct ipt_entry *iter; const void *loc_cpu_entry; int ret; if (!newinfo || !info) return -EINVAL; /* we dont care about newinfo->entries */ memcpy(newinfo, info, offsetof(struct xt_table_info, entries)); newinfo->initial_entries = 0; loc_cpu_entry = info->entries; xt_compat_init_offsets(AF_INET, info->number); xt_entry_foreach(iter, loc_cpu_entry, info->size) { ret = compat_calc_entry(iter, info, loc_cpu_entry, newinfo); if (ret != 0) return ret; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin6557.02%114.29%
jan engelhardtjan engelhardt3127.19%228.57%
eric dumazeteric dumazet1714.91%342.86%
florian westphalflorian westphal10.88%114.29%
Total114100.00%7100.00%

#endif
static int get_info(struct net *net, void __user *user, const int *len, int compat) { char name[XT_TABLE_MAXNAMELEN]; struct xt_table *t; int ret; if (*len != sizeof(struct ipt_getinfo)) return -EINVAL; if (copy_from_user(name, user, sizeof(name)) != 0) return -EFAULT; name[XT_TABLE_MAXNAMELEN-1] = '\0'; #ifdef CONFIG_COMPAT if (compat) xt_compat_lock(AF_INET); #endif t = try_then_request_module(xt_find_table_lock(net, AF_INET, name), "iptable_%s", name); if (!IS_ERR_OR_NULL(t)) { struct ipt_getinfo info; const struct xt_table_info *private = t->private; #ifdef CONFIG_COMPAT struct xt_table_info tmp; if (compat) { ret = compat_table_info(private, &tmp); xt_compat_flush_offsets(AF_INET); private = &tmp; } #endif memset(&info, 0, sizeof(info)); info.valid_hooks = t->valid_hooks; memcpy(info.hook_entry, private->hook_entry, sizeof(info.hook_entry)); memcpy(info.underflow, private->underflow, sizeof(info.underflow)); info.num_entries = private->number; info.size = private->size; strcpy(info.name, name); if (copy_to_user(user, &info, *len) != 0) ret = -EFAULT; else ret = 0; xt_table_unlock(t); module_put(t->me); } else ret = t ? PTR_ERR(t) : -ENOENT; #ifdef CONFIG_COMPAT if (compat) xt_compat_unlock(AF_INET); #endif return ret; }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin28889.44%19.09%
vasiliy kulikovvasiliy kulikov134.04%19.09%
alexey dobriyanalexey dobriyan113.42%327.27%
jan engelhardtjan engelhardt51.55%436.36%
patrick mchardypatrick mchardy41.24%19.09%
hideaki yoshifujihideaki yoshifuji10.31%19.09%
Total322100.00%11100.00%


static int get_entries(struct net *net, struct ipt_get_entries __user *uptr, const int *len) { int ret; struct ipt_get_entries get; struct xt_table *t; if (*len < sizeof(get)) return -EINVAL; if (copy_from_user(&get, uptr, sizeof(get)) != 0) return -EFAULT; if (*len != sizeof(struct ipt_get_entries) + get.size) return -EINVAL; get.name[sizeof(get.name) - 1] = '\0'; t = xt_find_table_lock(net, AF_INET, get.name); if (!IS_ERR_OR_NULL(t)) { const struct xt_table_info *private = t->private; if (get.size == private->size) ret = copy_entries_to_user(private->size, t, uptr->entrytable); else ret = -EAGAIN; module_put(t->me); xt_table_unlock(t); } else ret = t ? PTR_ERR(t) : -ENOENT; return ret; }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin16885.71%111.11%
pablo neira ayusopablo neira ayuso168.16%111.11%
alexey dobriyanalexey dobriyan73.57%222.22%
jan engelhardtjan engelhardt31.53%333.33%
patrick mchardypatrick mchardy10.51%111.11%
hideaki yoshifujihideaki yoshifuji10.51%111.11%
Total196100.00%9100.00%


static int __do_replace(struct net *net, const char *name, unsigned int valid_hooks, struct xt_table_info *newinfo, unsigned int num_counters, void __user *counters_ptr) { int ret; struct xt_table *t; struct xt_table_info *oldinfo; struct xt_counters *counters; struct ipt_entry *iter; ret = 0; counters = vzalloc(num_counters * sizeof(struct xt_counters)); if (!counters) { ret = -ENOMEM; goto out; } t = try_then_request_module(xt_find_table_lock(net, AF_INET, name), "iptable_%s", name); if (IS_ERR_OR_NULL(t)) { ret = t ? PTR_ERR(t) : -ENOENT; goto free_newinfo_counters_untrans; } /* You lied! */ if (valid_hooks != t->valid_hooks) { ret = -EINVAL; goto put_module; } oldinfo = xt_replace_table(t, num_counters, newinfo, &ret); if (!oldinfo) goto put_module; /* Update module usage count based on number of rules */ if ((oldinfo->number > oldinfo->initial_entries) || (newinfo->number <= oldinfo->initial_entries)) module_put(t->me); if ((oldinfo->number > oldinfo->initial_entries) && (newinfo->number <= oldinfo->initial_entries)) module_put(t->me); /* Get the old counters, and synchronize with replace */ get_counters(oldinfo, counters); /* Decrease module usage counts and free resource */ xt_entry_foreach(iter, oldinfo->entries, oldinfo->size) cleanup_entry(iter, net); xt_free_table_info(oldinfo); if (copy_to_user(counters_ptr, counters, sizeof(struct xt_counters) * num_counters) != 0) { /* Silent error, can't fail, new table is already in place */ net_warn_ratelimited("iptables: counters copy to user failed while replacing table\n"); } vfree(counters); xt_table_unlock(t); return ret; put_module: module_put(t->me); xt_table_unlock(t); free_newinfo_counters_untrans: vfree(counters); out: return ret; }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin29490.18%18.33%
jan engelhardtjan engelhardt133.99%325.00%
alexey dobriyanalexey dobriyan82.45%325.00%
thomas grafthomas graf72.15%18.33%
florian westphalflorian westphal10.31%18.33%
eric dumazeteric dumazet10.31%18.33%
hideaki yoshifujihideaki yoshifuji10.31%18.33%
stephen hemmingerstephen hemminger10.31%18.33%
Total326100.00%12100.00%


static int do_replace(struct net *net, const void __user *user, unsigned int len) { int ret; struct ipt_replace tmp; struct xt_table_info *newinfo; void *loc_cpu_entry; struct ipt_entry *iter; if (copy_from_user(&tmp, user, sizeof(tmp)) != 0) return -EFAULT; /* overflow check */ if (tmp.num_counters >= INT_MAX / sizeof(struct xt_counters)) return -ENOMEM; if (tmp.num_counters == 0) return -EINVAL; tmp.name[sizeof(tmp.name)-1] = 0; newinfo = xt_alloc_table_info(tmp.size); if (!newinfo) return -ENOMEM; loc_cpu_entry = newinfo->entries; if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), tmp.size) != 0) { ret = -EFAULT; goto free_newinfo; } ret = translate_table(net, newinfo, loc_cpu_entry, &tmp); if (ret != 0) goto free_newinfo; ret = __do_replace(net, tmp.name, tmp.valid_hooks, newinfo, tmp.num_counters, tmp.counters); if (ret) goto free_newinfo_untrans; return 0; free_newinfo_untrans: xt_entry_foreach(iter, loc_cpu_entry, newinfo->size) cleanup_entry(iter, net); free_newinfo: xt_free_table_info(newinfo); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin18273.09%110.00%
jan engelhardtjan engelhardt239.24%440.00%
vasiliy kulikovvasiliy kulikov166.43%110.00%
dave jonesdave jones124.82%110.00%
alexey dobriyanalexey dobriyan93.61%220.00%
stephen hemmingerstephen hemminger72.81%110.00%
Total249100.00%10100.00%


static int do_add_counters(struct net *net, const void __user *user, unsigned int len, int compat) { unsigned int i; struct xt_counters_info tmp; struct xt_counters *paddc; struct xt_table *t; const struct xt_table_info *private; int ret = 0; struct ipt_entry *iter; unsigned int addend; paddc = xt_copy_counters_from_user(user, len, &tmp, compat); if (IS_ERR(paddc)) return PTR_ERR(paddc); t = xt_find_table_lock(net, AF_INET, tmp.name); if (IS_ERR_OR_NULL(t)) { ret = t ? PTR_ERR(t) : -ENOENT; goto free; } local_bh_disable(); private = t->private; if (private->number != tmp.num_counters) { ret = -EINVAL; goto unlock_up_free; } i = 0; addend = xt_write_recseq_begin(); xt_entry_foreach(iter, private->entries, private->size) { struct xt_counters *tmp; tmp = xt_get_this_cpu_counter(&iter->counters); ADD_COUNTER(*tmp, paddc[i].bcnt, paddc[i].pcnt); ++i; } xt_write_recseq_end(addend); unlock_up_free: local_bh_enable(); xt_table_unlock(t); module_put(t->me); free: vfree(paddc); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin15663.93%16.67%
jan engelhardtjan engelhardt3213.11%533.33%
florian westphalflorian westphal3012.30%320.00%
eric dumazeteric dumazet104.10%16.67%
stephen hemmingerstephen hemminger83.28%213.33%
alexey dobriyanalexey dobriyan72.87%213.33%
hideaki yoshifujihideaki yoshifuji10.41%16.67%
Total244100.00%15100.00%

#ifdef CONFIG_COMPAT struct compat_ipt_replace { char name[XT_TABLE_MAXNAMELEN]; u32 valid_hooks; u32 num_entries; u32 size; u32 hook_entry[NF_INET_NUMHOOKS]; u32 underflow[NF_INET_NUMHOOKS]; u32 num_counters; compat_uptr_t counters; /* struct xt_counters * */ struct compat_ipt_entry entries[0]; };
static int compat_copy_entry_to_user(struct ipt_entry *e, void __user **dstptr, unsigned int *size, struct xt_counters *counters, unsigned int i) { struct xt_entry_target *t; struct compat_ipt_entry __user *ce; u_int16_t target_offset, next_offset; compat_uint_t origsize; const struct xt_entry_match *ematch; int ret = 0; origsize = *size; ce = (struct compat_ipt_entry __user *)*dstptr; if (copy_to_user(ce, e, sizeof(struct ipt_entry)) != 0 || copy_to_user(&ce->counters, &counters[i], sizeof(counters[i])) != 0) return -EFAULT; *dstptr += sizeof(struct compat_ipt_entry); *size -= sizeof(struct ipt_entry) - sizeof(struct compat_ipt_entry); xt_ematch_foreach(ematch, e) { ret = xt_compat_match_to_user(ematch, dstptr, size); if (ret != 0) return ret; } target_offset = e->target_offset - (origsize - *size); t = ipt_get_target(e); ret = xt_compat_target_to_user(t, dstptr, size); if (ret) return ret; next_offset = e->next_offset - (origsize - *size); if (put_user(target_offset, &ce->target_offset) != 0 || put_user(next_offset, &ce->next_offset) != 0) return -EFAULT; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin15660.47%18.33%
patrick mchardypatrick mchardy5420.93%650.00%
jan engelhardtjan engelhardt4718.22%433.33%
al viroal viro10.39%18.33%
Total258100.00%12100.00%


static int compat_find_calc_match(struct xt_entry_match *m, const struct ipt_ip *ip, int *size) { struct xt_match *match; match = xt_request_find_match(NFPROTO_IPV4, m->u.user.name, m->u.user.revision); if (IS_ERR(match)) return PTR_ERR(match); m->u.kernel.match = match; *size += xt_compat_match_offset(match); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin7590.36%233.33%
jan engelhardtjan engelhardt44.82%350.00%
patrick mchardypatrick mchardy44.82%116.67%
Total83100.00%6100.00%


static void compat_release_entry(struct compat_ipt_entry *e) { struct xt_entry_target *t; struct xt_entry_match *ematch; /* Cleanup all matches */ xt_ematch_foreach(ematch, e) module_put(ematch->u.kernel.match->me); t = compat_ipt_get_target(e); module_put(t->u.kernel.target->me); }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin3557.38%116.67%
jan engelhardtjan engelhardt2439.34%466.67%
patrick mchardypatrick mchardy23.28%116.67%
Total61100.00%6100.00%


static int check_compat_entry_size_and_hooks(struct compat_ipt_entry *e, struct xt_table_info *newinfo, unsigned int *size, const unsigned char *base, const unsigned char *limit) { struct xt_entry_match *ematch; struct xt_entry_target *t; struct xt_target *target; unsigned int entry_offset; unsigned int j; int ret, off; if ((unsigned long)e % __alignof__(struct compat_ipt_entry) != 0 || (unsigned char *)e + sizeof(struct compat_ipt_entry) >= limit || (unsigned char *)e + e->next_offset > limit) return -EINVAL; if (e->next_offset < sizeof(struct compat_ipt_entry) + sizeof(struct compat_xt_entry_target)) return -EINVAL; if (!ip_checkentry(&e->ip)) return -EINVAL; ret = xt_compat_check_entry_offsets(e, e->elems, e->target_offset, e->next_offset); if (ret) return ret; off = sizeof(struct ipt_entry) - sizeof(struct compat_ipt_entry); entry_offset = (void *)e - (void *)base; j = 0; xt_ematch_foreach(ematch, e) { ret = compat_find_calc_match(ematch, &e->ip, &off); if (ret != 0) goto release_matches; ++j; } t = compat_ipt_get_target(e); target = xt_request_find_target(NFPROTO_IPV4, t->u.user.name, t->u.user.revision); if (IS_ERR(target)) { ret = PTR_ERR(target); goto release_matches; } t->u.kernel.target = target; off += xt_compat_target_offset(target); *size += off; ret = xt_compat_add_offset(AF_INET, entry_offset, off); if (ret) goto out; return 0; out: module_put(t->u.kernel.target->me); release_matches: xt_ematch_foreach(ematch, e) { if (j-- == 0) break; module_put(ematch->u.kernel.match->me); } return ret; }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin25266.32%523.81%
jan engelhardtjan engelhardt5013.16%628.57%
florian westphalflorian westphal4110.79%419.05%
patrick mchardypatrick mchardy379.74%628.57%
Total380100.00%21100.00%


static void compat_copy_entry_from_user(struct compat_ipt_entry *e, void **dstptr, unsigned int *size, struct xt_table_info *newinfo, unsigned char *base) { struct xt_entry_target *t; struct xt_target *target; struct ipt_entry *de; unsigned int origsize; int h; struct xt_entry_match *ematch; origsize = *size; de = (struct ipt_entry *)*dstptr; memcpy(de, e, sizeof(struct ipt_entry)); memcpy(&de->counters, &e->counters, sizeof(e->counters)); *dstptr += sizeof(struct ipt_entry); *size += sizeof(struct ipt_entry) - sizeof(struct compat_ipt_entry); xt_ematch_foreach(ematch, e) xt_compat_match_from_user(ematch, dstptr, size); de->target_offset = e->target_offset - (origsize - *size); t = compat_ipt_get_target(e); target = t->u.kernel.target; xt_compat_target_from_user(t, dstptr, size); de->next_offset = e->next_offset - (origsize - *size); for (h = 0; h < NF_INET_NUMHOOKS; h++) { if ((unsigned char *)de - base < newinfo->hook_entry[h]) newinfo->hook_entry[h] -= origsize - *size; if ((unsigned char *)de - base < newinfo->underflow[h]) newinfo->underflow[h] -= origsize - *size; } }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin22180.07%218.18%
patrick mchardypatrick mchardy4114.86%545.45%
jan engelhardtjan engelhardt134.71%327.27%
florian westphalflorian westphal10.36%19.09%
Total276100.00%11100.00%


static int translate_compat_table(struct net *net, struct xt_table_info **pinfo, void **pentry0, const struct compat_ipt_replace *compatr) { unsigned int i, j; struct xt_table_info *newinfo, *info; void *pos, *entry0, *entry1; struct compat_ipt_entry *iter0; struct ipt_replace repl; unsigned int size; int ret; info = *pinfo; entry0 = *pentry0; size = compatr->size; info->number = compatr->num_entries; j = 0; xt_compat_lock(AF_INET); xt_compat_init_offsets(AF_INET, compatr->num_entries); /* Walk through entries, checking offsets. */ xt_entry_foreach(iter0, entry0, compatr->size) { ret = check_compat_entry_size_and_hooks(iter0, info, &size, entry0, entry0 + compatr->size); if (ret != 0) goto out_unlock; ++j; } ret = -EINVAL; if (j != compatr->num_entries) goto out_unlock; ret = -ENOMEM; newinfo = xt_alloc_table_info(size); if (!newinfo) goto out_unlock; newinfo->number = compatr->num_entries; for (i = 0; i < NF_INET_NUMHOOKS; i++) { newinfo->hook_entry[i] = compatr->hook_entry[i]; newinfo->underflow[i] = compatr->underflow[i]; } entry1 = newinfo->entries; pos = entry1; size = compatr->size; xt_entry_foreach(iter0, entry0, compatr->size) compat_copy_entry_from_user(iter0, &pos, &size, newinfo, entry1); /* all module references in entry0 are now gone. * entry1/newinfo contains a 64bit ruleset that looks exactly as * generated by 64bit userspace. * * Call standard translate_table() to validate all hook_entrys, * underflows, check for loops, etc. */ xt_compat_flush_offsets(AF_INET); xt_compat_unlock(AF_INET); memcpy(&repl, compatr, sizeof(*compatr)); for (i = 0; i < NF_INET_NUMHOOKS; i++) { repl.hook_entry[i] = newinfo->hook_entry[i]; repl.underflow[i] = newinfo->underflow[i]; } repl.num_counters = 0; repl.counters = NULL; repl.size = newinfo->size; ret = translate_table(net, newinfo, entry1, &repl); if (ret) goto free_newinfo; *pinfo = newinfo; *pentry0 = entry1; xt_free_table_info(info); return 0; free_newinfo: xt_free_table_info(newinfo); return ret; out_unlock: xt_compat_flush_offsets(AF_INET); xt_compat_unlock(AF_INET); xt_entry_foreach(iter0, entry0, compatr->size) { if (j-- == 0) break; compat_release_entry(iter0); } return ret; }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin20244.49%423.53%
florian westphalflorian westphal17638.77%317.65%
jan engelhardtjan engelhardt5712.56%529.41%
patrick mchardypatrick mchardy81.76%317.65%
eric dumazeteric dumazet61.32%15.88%
alexey dobriyanalexey dobriyan51.10%15.88%
Total454100.00%17100.00%


static int compat_do_replace(struct net *net, void __user *user, unsigned int len) { int ret; struct compat_ipt_replace tmp; struct xt_table_info *newinfo; void *loc_cpu_entry; struct ipt_entry *iter; if (copy_from_user(&tmp, user, sizeof(tmp)) != 0) return -EFAULT; /* overflow check */ if (tmp.num_counters >= INT_MAX / sizeof(struct xt_counters)) return -ENOMEM; if (tmp.num_counters == 0) return -EINVAL; tmp.name[sizeof(tmp.name)-1] = 0; newinfo = xt_alloc_table_info(tmp.size); if (!newinfo) return -ENOMEM; loc_cpu_entry = newinfo->entries; if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), tmp.size) != 0) { ret = -EFAULT; goto free_newinfo; } ret = translate_compat_table(net, &newinfo, &loc_cpu_entry, &tmp); if (ret != 0) goto free_newinfo; ret = __do_replace(net, tmp.name, tmp.valid_hooks, newinfo, tmp.num_counters, compat_ptr(tmp.counters)); if (ret) goto free_newinfo_untrans; return 0; free_newinfo_untrans: xt_entry_foreach(iter, loc_cpu_entry, newinfo->size) cleanup_entry(iter, net); free_newinfo: xt_free_table_info(newinfo); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin18472.73%19.09%
vasiliy kulikovvasiliy kulikov166.32%19.09%
harald welteharald welte145.53%19.09%
jan engelhardtjan engelhardt135.14%218.18%
dave jonesdave jones124.74%19.09%
alexey dobriyanalexey dobriyan103.95%327.27%
eric dumazeteric dumazet31.19%19.09%
florian westphalflorian westphal10.40%19.09%
Total253100.00%11100.00%


static int compat_do_ipt_set_ctl(struct sock *sk, int cmd, void __user *user, unsigned int len) { int ret; if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN)) return -EPERM; switch (cmd) { case IPT_SO_SET_REPLACE: ret = compat_do_replace(sock_net(sk), user, len); break; case IPT_SO_SET_ADD_COUNTERS: ret = do_add_counters(sock_net(sk), user, len, 1); break; default: ret = -EINVAL; } return ret; }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin6667.35%116.67%
eric w. biedermaneric w. biederman88.16%116.67%
harald welteharald welte77.14%116.67%
eric dumazeteric dumazet77.14%116.67%
hideaki yoshifujihideaki yoshifuji66.12%116.67%
alexey dobriyanalexey dobriyan44.08%116.67%
Total98100.00%6100.00%

struct compat_ipt_get_entries { char name[XT_TABLE_MAXNAMELEN]; compat_uint_t size; struct compat_ipt_entry entrytable[0]; };
static int compat_copy_entries_to_user(unsigned int total_size, struct xt_table *table, void __user *userptr) { struct xt_counters *counters; const struct xt_table_info *private = table->private; void __user *pos; unsigned int size; int ret = 0; unsigned int i = 0; struct ipt_entry *iter; counters = alloc_counters(table); if (IS_ERR(counters)) return PTR_ERR(counters); pos = userptr; size = total_size; xt_entry_foreach(iter, private->entries, total_size) { ret = compat_copy_entry_to_user(iter, &pos, &size, counters, i++); if (ret != 0) break; } vfree(counters); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin7557.25%19.09%
jan engelhardtjan engelhardt2519.08%436.36%
harald welteharald welte1914.50%19.09%
patrick mchardypatrick mchardy64.58%19.09%
pre-gitpre-git32.29%19.09%
linus torvaldslinus torvalds10.76%19.09%
florian westphalflorian westphal10.76%19.09%
eric dumazeteric dumazet10.76%19.09%
Total131100.00%11100.00%


static int compat_get_entries(struct net *net, struct compat_ipt_get_entries __user *uptr, int *len) { int ret; struct compat_ipt_get_entries get; struct xt_table *t; if (*len < sizeof(get)) return -EINVAL; if (copy_from_user(&get, uptr, sizeof(get)) != 0) return -EFAULT; if (*len != sizeof(struct compat_ipt_get_entries) + get.size) return -EINVAL; get.name[sizeof(get.name) - 1] = '\0'; xt_compat_lock(AF_INET); t = xt_find_table_lock(net, AF_INET, get.name); if (!IS_ERR_OR_NULL(t)) { const struct xt_table_info *private = t->private; struct xt_table_info info; ret = compat_table_info(private, &info); if (!ret && get.size == info.size) ret = compat_copy_entries_to_user(private->size, t, uptr->entrytable); else if (!ret) ret = -EAGAIN; xt_compat_flush_offsets(AF_INET); module_put(t->me); xt_table_unlock(t); } else ret = t ? PTR_ERR(t) : -ENOENT; xt_compat_unlock(AF_INET); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin10645.69%17.14%
harald welteharald welte5423.28%17.14%
pre-gitpre-git3314.22%17.14%
pablo neira ayusopablo neira ayuso166.90%17.14%
alexey dobriyanalexey dobriyan73.02%214.29%
rusty russellrusty russell73.02%214.29%
patrick mchardypatrick mchardy52.16%214.29%
jan engelhardtjan engelhardt20.86%214.29%
hideaki yoshifujihideaki yoshifuji10.43%17.14%
eric dumazeteric dumazet10.43%17.14%
Total232100.00%14100.00%

static int do_ipt_get_ctl(struct sock *, int, void __user *, int *);
static int compat_do_ipt_get_ctl(struct sock *sk, int cmd, void __user *user, int *len) { int ret; if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN)) return -EPERM; switch (cmd) { case IPT_SO_GET_INFO: ret = get_info(sock_net(sk), user, len, 1); break; case IPT_SO_GET_ENTRIES: ret = compat_get_entries(sock_net(sk), user, len); break; default: ret = do_ipt_get_ctl(sk, cmd, user, len); } return ret; }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin6258.49%112.50%
bjorn steinbrinkbjorn steinbrink1110.38%112.50%
patrick mchardypatrick mchardy87.55%112.50%
eric w. biedermaneric w. biederman87.55%112.50%
hideaki yoshifujihideaki yoshifuji65.66%112.50%
alexey dobriyanalexey dobriyan43.77%112.50%
pre-gitpre-git43.77%112.50%
rusty russellrusty russell32.83%112.50%
Total106100.00%8100.00%

#endif
static int do_ipt_set_ctl(struct sock *sk, int cmd, void __user *user, unsigned int len) { int ret; if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN)) return -EPERM; switch (cmd) { case IPT_SO_SET_REPLACE: ret = do_replace(sock_net(sk), user, len); break; case IPT_SO_SET_ADD_COUNTERS: ret = do_add_counters(sock_net(sk), user, len, 0); break; default: ret = -EINVAL; } return ret; }

Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin5657.14%116.67%
pre-gitpre-git1616.33%116.67%
eric w. biedermaneric w. biederman88.16%116.67%
harald welteharald welte88.16%116.67%
hideaki yoshifujihideaki yoshifuji66.12%116.67%
alexey dobriyanalexey dobriyan44.08%116.67%
Total98100.00%6100.00%


static int do_ipt_get_ctl(struct sock *sk, int cmd, void __user *user, int *len) { int ret; if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN)) return -EPERM; switch (cmd) { case IPT_SO_GET_INFO: ret = get_info(sock_net(sk), user, len, 0); break; case IPT_SO_GET_ENTRIES: ret = get_entries(sock_net(sk), user, len); break; case IPT_SO_GET_REVISION_MATCH: case IPT_SO_GET_REVISION_TARGET: { struct xt_get_revision rev; int target; if (*len != sizeof(rev)) { ret = -EINVAL; break; } if (copy_from_user(&rev, user, sizeof(rev)) != 0) { ret = -EFAULT; break; } rev.name[sizeof(rev.name)-1] = 0; if (cmd == IPT_SO_GET_REVISION_TARGET) target = 1; else target = 0; try_then_request_module(xt_find_revision(AF_INET, rev.name, rev.revision, target, &ret), "ipt_%s", rev.name); break; } default: ret = -EINVAL; } return ret; }

Contributors

PersonTokensPropCommitsCommitProp
harald welteharald welte7836.28%110.00%
dmitry mishindmitry mishin4922.79%110.00%
pre-gitpre-git4822.33%110.00%
vasiliy kulikovvasiliy kulikov167.44%110.00%
eric w. biedermaneric w. biederman83.72%110.00%
hideaki yoshifujihideaki yoshifuji62.79%110.00%
alexey dobriyanalexey dobriyan41.86%110.00%
rusty russellrusty russell31.40%110.00%
linus torvaldslinus torvalds20.93%110.00%
jan engelhardtjan engelhardt10.47%110.00%
Total215100.00%10100.00%


static void __ipt_unregister_table(struct net *net, struct xt_table *table) { struct xt_table_info *private; void *loc_cpu_entry; struct module *table_owner = table->me; struct ipt_entry *iter; private = xt_unregister_table(table); /* Decrease module usage counts and free resources */ loc_cpu_entry = private->entries; xt_entry_foreach(iter, loc_cpu_entry, private->size) cleanup_entry(iter, net); if (private->number > private->initial_entries) module_put(table_owner); xt_free_table_info(private); }

Contributors

PersonTokensPropCommitsCommitProp
florian westphalflorian westphal88100.00%1100.00%
Total88100.00%1100.00%


int ipt_register_table(struct net *net, const struct xt_table *table, const struct ipt_replace *repl, const struct nf_hook_ops *ops, struct xt_table **res) { int ret; struct xt_table_info *newinfo; struct xt_table_info bootstrap = {0}; void *loc_cpu_entry; struct xt_table *new_table; newinfo = xt_alloc_table_info(repl->size); if (!newinfo) return -ENOMEM; loc_cpu_entry = newinfo->entries; memcpy(loc_cpu_entry, repl->entries, repl->size); ret = translate_table(net, newinfo, loc_cpu_entry, repl); if (ret != 0) goto out_free; new_table = xt_register_table(net, table, &bootstrap, newinfo); if (IS_ERR(new_table)) { ret = PTR_ERR(new_table); goto out_free; } /* set res now, will see skbs right after nf_register_net_hooks */ WRITE_ONCE(*res, new_table); ret = nf_register_net_hooks(net, ops, hweight32(table->valid_hooks)); if (ret != 0) { __ipt_unregister_table(net, new_table); *res = NULL; } return ret; out_free: xt_free_table_info(newinfo); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
harald welteharald welte7736.84%19.09%
florian westphalflorian westphal6129.19%218.18%
alexey dobriyanalexey dobriyan3818.18%436.36%
pre-gitpre-git2813.40%218.18%
patrick mchardypatrick mchardy41.91%19.09%
jan engelhardtjan engelhardt10.48%19.09%
Total209100.00%11100.00%


void ipt_unregister_table(struct net *net, struct xt_table *table, const struct nf_hook_ops *ops) { nf_unregister_net_hooks(net, ops, hweight32(table->valid_hooks)); __ipt_unregister_table(net, table); }

Contributors

PersonTokensPropCommitsCommitProp
florian westphalflorian westphal1740.48%225.00%
patrick mchardypatrick mchardy819.05%112.50%
alexey dobriyanalexey dobriyan819.05%225.00%
harald welteharald welte716.67%112.50%
jan engelhardtjan engelhardt24.76%225.00%
Total42100.00%8100.00%

/* Returns 1 if the type and code is matched by the range, 0 otherwise */
static inline bool icmp_type_code_match(u_int8_t test_type, u_int8_t min_code, u_int8_t max_code, u_int8_t type, u_int8_t code, bool invert) { return ((test_type == 0xFF) || (type == test_type && code >= min_code && code <= max_code)) ^ invert; }

Contributors

PersonTokensPropCommitsCommitProp
harald welteharald welte3366.00%133.33%
pre-gitpre-git1530.00%133.33%
jan engelhardtjan engelhardt24.00%133.33%
Total50100.00%3100.00%


static bool icmp_match(const struct sk_buff *skb, struct xt_action_param *par) { const struct icmphdr *ic; struct icmphdr _icmph; const struct ipt_icmp *icmpinfo = par->matchinfo; /* Must not be a fragment. */ if (par->fragoff != 0) return false; ic = skb_header_pointer(skb, par->thoff, sizeof(_icmph), &_icmph); if (ic == NULL) { /* We've been asked to examine this packet, and we * can't. Hence, no choice but to drop. */ par->hotdrop = true; return false; } return icmp_type_code_match(icmpinfo->type, icmpinfo->code[0], icmpinfo->code[1], ic->type, ic->code, !!(icmpinfo->invflags&IPT_ICMP_INV)); }

Contributors

PersonTokensPropCommitsCommitProp
harald welteharald welte10381.75%228.57%
jan engelhardtjan engelhardt2318.25%571.43%
Total126100.00%7100.00%


static int icmp_checkentry(const struct xt_mtchk_param *par) { const struct ipt_icmp *icmpinfo = par->matchinfo; /* Must specify no unknown invflags */ return (icmpinfo->invflags & ~IPT_ICMP_INV) ? -EINVAL : 0; }

Contributors

PersonTokensPropCommitsCommitProp
harald welteharald welte2668.42%228.57%
jan engelhardtjan engelhardt1026.32%342.86%
patrick mchardypatrick mchardy25.26%228.57%
Total38100.00%7100.00%

static struct xt_target ipt_builtin_tg[] __read_mostly = { { .name = XT_STANDARD_TARGET, .targetsize = sizeof(int), .family = NFPROTO_IPV4, #ifdef CONFIG_COMPAT .compatsize = sizeof(compat_int_t), .compat_from_user = compat_standard_from_user, .compat_to_user = compat_standard_to_user, #endif }, { .name = XT_ERROR_TARGET, .target = ipt_error, .targetsize = XT_FUNCTION_MAXNAMELEN, .family = NFPROTO_IPV4, }, }; static struct nf_sockopt_ops ipt_sockopts = { .pf = PF_INET, .set_optmin = IPT_BASE_CTL, .set_optmax = IPT_SO_SET_MAX+1, .set = do_ipt_set_ctl, #ifdef CONFIG_COMPAT .compat_set = compat_do_ipt_set_ctl, #endif .get_optmin = IPT_BASE_CTL, .get_optmax = IPT_SO_GET_MAX+1, .get = do_ipt_get_ctl, #ifdef CONFIG_COMPAT .compat_get = compat_do_ipt_get_ctl, #endif .owner = THIS_MODULE, }; static struct xt_match ipt_builtin_mt[] __read_mostly = { { .name = "icmp", .match = icmp_match, .matchsize = sizeof(struct ipt_icmp), .checkentry = icmp_checkentry, .proto = IPPROTO_ICMP, .family = NFPROTO_IPV4, }, };
static int __net_init ip_tables_net_init(struct net *net) { return xt_proto_init(net, NFPROTO_IPV4); }

Contributors

PersonTokensPropCommitsCommitProp
alexey dobriyanalexey dobriyan1995.00%150.00%
jan engelhardtjan engelhardt15.00%150.00%
Total20100.00%2100.00%


static void __net_exit ip_tables_net_exit(struct net *net) { xt_proto_fini(net, NFPROTO_IPV4); }

Contributors

PersonTokensPropCommitsCommitProp
alexey dobriyanalexey dobriyan1894.74%150.00%
jan engelhardtjan engelhardt15.26%150.00%
Total19100.00%2100.00%

static struct pernet_operations ip_tables_net_ops = { .init = ip_tables_net_init, .exit = ip_tables_net_exit, };
static int __init ip_tables_init(void) { int ret; ret = register_pernet_subsys(&ip_tables_net_ops); if (ret < 0) goto err1; /* No one else will be downing sem now, so we won't sleep */ ret = xt_register_targets(ipt_builtin_tg, ARRAY_SIZE(ipt_builtin_tg)); if (ret < 0) goto err2; ret = xt_register_matches(ipt_builtin_mt, ARRAY_SIZE(ipt_builtin_mt)); if (ret < 0) goto err4; /* Register setsockopt */ ret = nf_register_sockopt(&ipt_sockopts); if (ret < 0) goto err5; pr_info("(C) 2000-2006 Netfilter Core Team\n"); return 0; err5: xt_unregister_matches(ipt_builtin_mt, ARRAY_SIZE(ipt_builtin_mt)); err4: xt_unregister_targets(ipt_builtin_tg, ARRAY_SIZE(ipt_builtin_tg)); err2: unregister_pernet_subsys(&ip_tables_net_ops); err1: return ret; }

Contributors

PersonTokensPropCommitsCommitProp
patrick mchardypatrick mchardy5540.74%114.29%
pre-gitpre-git4432.59%114.29%
jan engelhardtjan engelhardt2820.74%228.57%
alexey dobriyanalexey dobriyan64.44%114.29%
andrew mortonandrew morton10.74%114.29%
lucas de marchilucas de marchi10.74%114.29%
Total135100.00%7100.00%


static void __exit ip_tables_fini(void) { nf_unregister_sockopt(&ipt_sockopts); xt_unregister_matches(ipt_builtin_mt, ARRAY_SIZE(ipt_builtin_mt)); xt_unregister_targets(ipt_builtin_tg, ARRAY_SIZE(ipt_builtin_tg)); unregister_pernet_subsys(&ip_tables_net_ops); }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git2356.10%233.33%
jan engelhardtjan engelhardt1331.71%116.67%
alexey dobriyanalexey dobriyan37.32%116.67%
andrew mortonandrew morton12.44%116.67%
harald welteharald welte12.44%116.67%
Total41100.00%6100.00%

EXPORT_SYMBOL(ipt_register_table); EXPORT_SYMBOL(ipt_unregister_table); EXPORT_SYMBOL(ipt_do_table); module_init(ip_tables_init); module_exit(ip_tables_fini);

Overall Contributors

PersonTokensPropCommitsCommitProp
dmitry mishindmitry mishin334233.83%84.42%
harald welteharald welte148114.99%31.66%
jan engelhardtjan engelhardt132413.40%4826.52%
pre-gitpre-git114711.61%63.31%
florian westphalflorian westphal7237.32%2011.05%
patrick mchardypatrick mchardy5355.42%2815.47%
jozsef kadlecsikjozsef kadlecsik4624.68%10.55%
alexey dobriyanalexey dobriyan2242.27%94.97%
eric dumazeteric dumazet1331.35%116.08%
rusty russellrusty russell1131.14%63.31%
pablo neira ayusopablo neira ayuso660.67%52.76%
vasiliy kulikovvasiliy kulikov610.62%21.10%
eric w. biedermaneric w. biederman570.58%42.21%
stephen hemmingerstephen hemminger330.33%31.66%
hideaki yoshifujihideaki yoshifuji290.29%21.10%
dave jonesdave jones240.24%10.55%
david s. millerdavid s. miller230.23%21.10%
al viroal viro180.18%21.10%
kurt garloffkurt garloff120.12%10.55%
bjorn steinbrinkbjorn steinbrink110.11%10.55%
herbert xuherbert xu80.08%10.55%
thomas grafthomas graf70.07%10.55%
denys vlasenkodenys vlasenko60.06%10.55%
arnaldo carvalho de meloarnaldo carvalho de melo60.06%10.55%
neil hormanneil horman50.05%10.55%
gao fenggao feng40.04%21.10%
andrew mortonandrew morton40.04%10.55%
will deaconwill deacon40.04%10.55%
thiemo seuferthiemo seufer30.03%10.55%
randy dunlaprandy dunlap30.03%10.55%
linus torvaldslinus torvalds30.03%21.10%
changli gaochangli gao20.02%10.55%
jamal hadi salimjamal hadi salim20.02%10.55%
ingo molnaringo molnar10.01%10.55%
lucas de marchilucas de marchi10.01%10.55%
joe perchesjoe perches10.01%10.55%
Total9878100.00%181100.00%
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
{% endraw %}