Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
Linux Kernel | net/netfilter/xt_MASQUERADE.c | static unsigned int masquerade_tg6(struct sk_buff *skb,
const struct xt_action_param *par) {
return nf_nat_masquerade_ipv6(skb, par->targinfo, xt_out(par));
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_multiport.c | static bool multiport_mt(const struct sk_buff *skb,
struct xt_action_param *par) {
const __be16 *pptr;
__be16 _ports[2];
const struct xt_multiport_v1 *multiinfo = par->matchinfo;
if (par->fragoff != 0)
return false;
pptr = skb_header_pointer(skb, par->thoff, sizeof(_ports), _por... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_nat.c |
static int xt_nat_checkentry_v0(const struct xt_tgchk_param *par) {
const struct nf_nat_ipv4_multi_range_compat *mr = par->targinfo;
if (mr->rangesize != 1) {
pr_info_ratelimited("multiple ranges no longer supported\n");
return -EINVAL;
}
return nf_ct_netns_get(par->net, par->family);
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_nat.c |
static void xt_nat_convert_range(struct nf_nat_range2 *dst,
const struct nf_nat_ipv4_range *src) {
memset(&dst->min_addr, 0, sizeof(dst->min_addr));
memset(&dst->max_addr, 0, sizeof(dst->max_addr));
memset(&dst->base_proto, 0, sizeof(dst->base_proto));
dst->flags = src->flags;... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_nat.c |
static unsigned int xt_snat_target_v0(struct sk_buff *skb,
const struct xt_action_param *par) {
const struct nf_nat_ipv4_multi_range_compat *mr = par->targinfo;
struct nf_nat_range2 range;
enum ip_conntrack_info ctinfo;
struct nf_conn *ct;
ct = nf_ct_get(skb, &ctinfo);
... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_nat.c |
static unsigned int xt_snat_target_v1(struct sk_buff *skb,
const struct xt_action_param *par) {
const struct nf_nat_range *range_v1 = par->targinfo;
struct nf_nat_range2 range;
enum ip_conntrack_info ctinfo;
struct nf_conn *ct;
ct = nf_ct_get(skb, &ctinfo);
WARN_ON(!(... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_nat.c |
static unsigned int xt_dnat_target_v1(struct sk_buff *skb,
const struct xt_action_param *par) {
const struct nf_nat_range *range_v1 = par->targinfo;
struct nf_nat_range2 range;
enum ip_conntrack_info ctinfo;
struct nf_conn *ct;
ct = nf_ct_get(skb, &ctinfo);
WARN_ON(!(... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_nat.c |
static unsigned int xt_snat_target_v2(struct sk_buff *skb,
const struct xt_action_param *par) {
const struct nf_nat_range2 *range = par->targinfo;
enum ip_conntrack_info ctinfo;
struct nf_conn *ct;
ct = nf_ct_get(skb, &ctinfo);
WARN_ON(!(ct != NULL && (ctinfo == IP_CT_N... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_nat.c |
static int __init xt_nat_init(void) {
return xt_register_targets(xt_nat_target_reg, ARRAY_SIZE(xt_nat_target_reg));
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_nat.c |
static void __exit xt_nat_exit(void) {
xt_unregister_targets(xt_nat_target_reg, ARRAY_SIZE(xt_nat_target_reg));
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_NETMAP.c |
static int netmap_tg4_check(const struct xt_tgchk_param *par) {
const struct nf_nat_ipv4_multi_range_compat *mr = par->targinfo;
if (!(mr->range[0].flags & NF_NAT_RANGE_MAP_IPS)) {
pr_debug("bad MAP_IPS.\n");
return -EINVAL;
}
if (mr->rangesize != 1) {
pr_debug("bad rangesize %u.\n", mr->rangesize... | [
0,
0
] |
Linux Kernel | net/netfilter/xt_NFLOG.c |
static void nflog_tg_destroy(const struct xt_tgdtor_param *par) {
nf_logger_put(par->family, NF_LOG_TYPE_ULOG);
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_owner.c | static bool owner_mt(const struct sk_buff *skb, struct xt_action_param *par) {
const struct xt_owner_match_info *info = par->matchinfo;
const struct file *filp;
struct sock *sk = skb_to_full_sk(skb);
struct net *net = xt_net(par);
if (!sk || !sk->sk_socket || !net_eq(net, sock_net(sk)))
return (info->mat... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_owner.c |
static int __init owner_mt_init(void) {
return xt_register_match(&owner_mt_reg);
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_policy.c |
static int match_policy_in(const struct sk_buff *skb,
const struct xt_policy_info *info,
unsigned short family) {
const struct xt_policy_elem *e;
const struct sec_path *sp = skb_sec_path(skb);
int strict = info->flags & XT_POLICY_MATCH_STRICT;
int i, pos;
... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_policy.c |
static int __init policy_mt_init(void) {
return xt_register_matches(policy_mt_reg, ARRAY_SIZE(policy_mt_reg));
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_quota.c |
static int quota_mt_check(const struct xt_mtchk_param *par) {
struct xt_quota_info *q = par->matchinfo;
if (q->flags & ~XT_QUOTA_MASK)
return -EINVAL;
q->master = kmalloc(sizeof(*q->master), GFP_KERNEL);
if (q->master == NULL)
return -ENOMEM;
spin_lock_init(&q->master->lock);
q->master->quota = ... | [
0,
0
] |
Linux Kernel | net/netfilter/xt_quota.c |
static void __exit quota_mt_exit(void) { xt_unregister_match("a_mt_reg); } | [
0,
0
] |
Linux Kernel | net/netfilter/xt_rateest.c |
static void xt_rateest_mt_destroy(const struct xt_mtdtor_param *par) {
struct xt_rateest_match_info *info = par->matchinfo;
xt_rateest_put(par->net, info->est1);
if (info->est2)
xt_rateest_put(par->net, info->est2);
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_realm.c |
static bool realm_mt(const struct sk_buff *skb, struct xt_action_param *par) {
const struct xt_realm_info *info = par->matchinfo;
const struct dst_entry *dst = skb_dst(skb);
return (info->id == (dst->tclassid & info->mask)) ^ info->invert;
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_realm.c |
static void __exit realm_mt_exit(void) { xt_unregister_match(&realm_mt_reg); } | [
0,
0
] |
Linux Kernel | net/netfilter/xt_recent.c |
static inline struct recent_net *recent_pernet(struct net *net) {
return net_generic(net, recent_net_id);
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_recent.c |
static void recent_entry_remove(struct recent_table *t,
struct recent_entry *e) {
list_del(&e->list);
list_del(&e->lru_list);
kfree(e);
t->entries--;
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_recent.c |
static struct recent_entry *recent_entry_init(struct recent_table *t,
const union nf_inet_addr *addr,
u_int16_t family, u_int8_t ttl) {
struct recent_entry *e;
unsigned int nstamps_max = t->nstamps_max_mask;
if (t->entri... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_recent.c |
static void recent_entry_update(struct recent_table *t,
struct recent_entry *e) {
e->index &= t->nstamps_max_mask;
e->stamps[e->index++] = jiffies;
if (e->index > e->nstamps)
e->nstamps = e->index;
list_move_tail(&e->lru_list, &t->lru_list);
} | [
1,
0
] |
Linux Kernel | net/netfilter/xt_recent.c |
static void recent_table_flush(struct recent_table *t) {
struct recent_entry *e, *next;
unsigned int i;
for (i = 0; i < ip_list_hash_size; i++)
list_for_each_entry_safe(e, next, &t->iphash[i], list)
recent_entry_remove(t, e);
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_recent.c |
static int recent_mt_check_v1(const struct xt_mtchk_param *par) {
return recent_mt_check(par, par->matchinfo);
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_recent.c |
static void recent_mt_destroy(const struct xt_mtdtor_param *par) {
struct recent_net *recent_net = recent_pernet(par->net);
const struct xt_recent_mtinfo_v1 *info = par->matchinfo;
struct recent_table *t;
mutex_lock(&recent_mutex);
t = recent_table_lookup(recent_net, info->name);
if (--t->refcnt == 0) {
... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_recent.c |
static void *recent_seq_start(struct seq_file *seq, loff_t *pos)
__acquires(recent_lock) {
struct recent_iter_state *st = seq->private;
const struct recent_table *t = st->table;
struct recent_entry *e;
loff_t p = *pos;
spin_lock_bh(&recent_lock);
for (st->bucket = 0; st->bucket < ip_list_hash_size; s... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_recent.c |
static void recent_seq_stop(struct seq_file *s, void *v)
__releases(recent_lock) {
spin_unlock_bh(&recent_lock);
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_recent.c |
static void __net_exit recent_net_exit(struct net *net) {
recent_proc_net_exit(net);
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_recent.c |
static int __init recent_mt_init(void) {
int err;
BUILD_BUG_ON_NOT_POWER_OF_2(XT_RECENT_MAX_NSTAMPS);
if (!ip_list_tot || ip_pkt_list_tot >= XT_RECENT_MAX_NSTAMPS)
return -EINVAL;
ip_list_hash_size = 1 << fls(ip_list_tot);
err = register_pernet_subsys(&recent_net_ops);
if (err)
return err;
err... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_recent.c |
static void __exit recent_mt_exit(void) {
xt_unregister_matches(recent_mt_reg, ARRAY_SIZE(recent_mt_reg));
unregister_pernet_subsys(&recent_net_ops);
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_sctp.c |
static bool sctp_mt(const struct sk_buff *skb, struct xt_action_param *par) {
const struct xt_sctp_info *info = par->matchinfo;
const struct sctphdr *sh;
struct sctphdr _sh;
if (par->fragoff != 0) {
pr_debug("Dropping non-first fragment.. FIXME\n");
return false;
}
sh = skb_header_pointer(skb, pa... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_SECMARK.c |
static unsigned int secmark_tg(struct sk_buff *skb,
const struct xt_secmark_target_info_v1 *info) {
u32 secmark = 0;
switch (mode) {
case SECMARK_MODE_SEL:
secmark = info->secid;
break;
default:
BUG();
}
skb->secmark = secmark;
return XT_CONTINUE;
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_SECMARK.c |
static int secmark_tg_check_v1(const struct xt_tgchk_param *par) {
return secmark_tg_check(par->table, par->targinfo);
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_SECMARK.c |
static void __exit secmark_tg_exit(void) {
xt_unregister_targets(secmark_tg_reg, ARRAY_SIZE(secmark_tg_reg));
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_set.c |
static inline int match_set(ip_set_id_t index, const struct sk_buff *skb,
const struct xt_action_param *par,
struct ip_set_adt_opt *opt, int inv) {
if (ip_set_test(index, skb, par, opt))
inv = !inv;
return inv;
}
#define ADT_OPT(n, f, d, fs, cfs, t, p, b... | [
0,
0
] |
Linux Kernel | net/netfilter/xt_set.c | static bool set_match_v4(const struct sk_buff *skb,
struct xt_action_param *par) {
const struct xt_set_info_match_v4 *info = par->matchinfo;
ADT_OPT(opt, xt_family(par), info->match_set.dim, info->match_set.flags,
info->flags, UINT_MAX, info->packets.value, info->bytes.value,
... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_set.c | static int set_target_v0_checkentry(const struct xt_tgchk_param *par) {
struct xt_set_info_target_v0 *info = par->targinfo;
ip_set_id_t index;
if (info->add_set.index != IPSET_INVALID_ID) {
index = ip_set_nfnl_get_byindex(par->net, info->add_set.index);
if (index == IPSET_INVALID_ID) {
pr_info_rate... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_socket.c | static bool socket_mt6_v1_v2_v3(const struct sk_buff *skb,
struct xt_action_param *par) {
const struct xt_socket_mtinfo1 *info =
(struct xt_socket_mtinfo1 *)par->matchinfo;
struct sk_buff *pskb = (struct sk_buff *)skb;
struct sock *sk = skb->sk;
if (sk && !net_eq(xt_net(pa... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_socket.c |
static void __exit socket_mt_exit(void) {
xt_unregister_matches(socket_mt_reg, ARRAY_SIZE(socket_mt_reg));
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_state.c |
static int __init state_mt_init(void) {
return xt_register_match(&state_mt_reg);
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_statistic.c |
static bool statistic_mt(const struct sk_buff *skb,
struct xt_action_param *par) {
const struct xt_statistic_info *info = par->matchinfo;
bool ret = info->flags & XT_STATISTIC_INVERT;
int nval, oval;
switch (info->mode) {
case XT_STATISTIC_MODE_RANDOM:
if ((get_random_u32() & 0x... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_string.c | static int string_mt_check(const struct xt_mtchk_param *par) {
struct xt_string_info *conf = par->matchinfo;
struct ts_config *ts_conf;
int flags = TS_AUTOLOAD;
if (conf->from_offset > conf->to_offset)
return -EINVAL;
if (conf->algo[XT_STRING_MAX_ALGO_NAME_SIZE - 1] != '\0')
return -EINVAL;
if (con... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_string.c |
static int __init string_mt_init(void) {
return xt_register_match(&xt_string_mt_reg);
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_TCPOPTSTRIP.c | static unsigned int tcpoptstrip_mangle_packet(struct sk_buff *skb,
const struct xt_action_param *par,
unsigned int tcphoff) {
const struct xt_tcpoptstrip_target_info *info = par->targinfo;
struct tcphdr *tcph, _th;
unsigne... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_tcpudp.c | static bool tcp_mt(const struct sk_buff *skb, struct xt_action_param *par) {
const struct tcphdr *th;
struct tcphdr _tcph;
const struct xt_tcp *tcpinfo = par->matchinfo;
if (par->fragoff != 0) {
if (par->fragoff == 1) {
pr_debug("Dropping evil TCP offset=1 frag.\n");
par->hotdrop = true;
}... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_tcpudp.c |
static void __exit tcpudp_mt_exit(void) {
xt_unregister_matches(tcpudp_mt_reg, ARRAY_SIZE(tcpudp_mt_reg));
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_time.c | static inline unsigned int localtime_1(struct xtm *r, time64_t time) {
unsigned int v, w;
div_u64_rem(time, SECONDS_PER_DAY, &v);
r->second = v % 60;
w = v / 60;
r->minute = w % 60;
r->hour = w / 60;
return v;
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_time.c | static inline void localtime_2(struct xtm *r, time64_t time) {
r->dse = div_u64(time, SECONDS_PER_DAY);
/*
* 1970-01-01 (w=0) was a Thursday (4).
* -1 and +1 map Sunday properly onto 7.
*/
r->weekday = (4 + r->dse - 1) % 7 + 1;
} | [
1,
0
] |
Linux Kernel | net/netfilter/xt_time.c | static void localtime_3(struct xtm *r, time64_t time) {
unsigned int year, i, w = r->dse;
for (i = 0, year = DSE_FIRST; days_since_epoch[i] > w; ++i, --year)
/* just loop */;
w -= days_since_epoch[i];
/*
* By now we have the current year, and the day of the year.
* r->yearday = w;
*
* On to f... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_time.c |
static int time_mt_check(const struct xt_mtchk_param *par) {
const struct xt_time_info *info = par->matchinfo;
if (info->daytime_start > XT_TIME_MAX_DAYTIME ||
info->daytime_stop > XT_TIME_MAX_DAYTIME) {
pr_info_ratelimited(
"invalid argument - start or stop time greater than 23:59:59\n");
r... | [
0,
0
] |
Linux Kernel | net/netfilter/xt_time.c | static int __init time_mt_init(void) {
int minutes = sys_tz.tz_minuteswest;
if (minutes < 0)
pr_info("kernel timezone is +%02d%02d\n", -minutes / 60, -minutes % 60);
else /* west of Greenwich */
pr_info("kernel timezone is -%02d%02d\n", minutes / 60, minutes % 60);
return xt_register_match(&xt_time_mt... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_TPROXY.c | static unsigned int tproxy_tg4(struct net *net, struct sk_buff *skb,
__be32 laddr, __be16 lport, u_int32_t mark_mask,
u_int32_t mark_value) {
const struct iphdr *iph = ip_hdr(skb);
struct udphdr _hdr, *hp;
struct sock *sk;
hp = skb_header_pointer(sk... | [
1,
0
] |
Linux Kernel | net/netfilter/xt_TPROXY.c |
static unsigned int tproxy_tg4_v0(struct sk_buff *skb,
const struct xt_action_param *par) {
const struct xt_tproxy_target_info *tgi = par->targinfo;
return tproxy_tg4(xt_net(par), skb, tgi->laddr, tgi->lport, tgi->mark_mask,
tgi->mark_value);
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_TRACE.c |
static unsigned int trace_tg(struct sk_buff *skb,
const struct xt_action_param *par) {
skb->nf_trace = 1;
return XT_CONTINUE;
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_TRACE.c |
static int __init trace_tg_init(void) {
return xt_register_target(&trace_tg_reg);
} | [
0,
0
] |
Linux Kernel | net/netfilter/xt_u32.c | static bool u32_match_it(const struct xt_u32 *data, const struct sk_buff *skb) {
const struct xt_u32_test *ct;
unsigned int testind;
unsigned int nnums;
unsigned int nvals;
unsigned int i;
__be32 n;
u_int32_t pos;
u_int32_t val;
u_int32_t at;
for (testind = 0; testind < data->ntests; ++testind) {
... | [
1,
0
] |
Linux Kernel | net/netfilter/x_tables.c |
void xt_unregister_targets(struct xt_target *target, unsigned int n) {
while (n-- > 0)
xt_unregister_target(&target[n]);
} | [
0,
0
] |
Linux Kernel | net/netfilter/x_tables.c |
int xt_register_match(struct xt_match *match) {
u_int8_t af = match->family;
mutex_lock(&xt[af].mutex);
list_add(&match->list, &xt[af].match);
mutex_unlock(&xt[af].mutex);
return 0;
} | [
0,
0
] |
Linux Kernel | net/netfilter/x_tables.c |
int xt_register_matches(struct xt_match *match, unsigned int n) {
unsigned int i;
int err = 0;
for (i = 0; i < n; i++) {
err = xt_register_match(&match[i]);
if (err)
goto err;
}
return err;
err:
if (i > 0)
xt_unregister_matches(match, i);
return err;
} | [
0,
0
] |
Linux Kernel | net/netfilter/x_tables.c | int xt_find_revision(u8 af, const char *name, u8 revision, int target,
int *err) {
int have_rev, best = -1;
if (target == 1)
have_rev = target_revfn(af, name, revision, &best);
else
have_rev = match_revfn(af, name, revision, &best);
if (best == -1) {
*err = -ENOENT;
return... | [
0,
0
] |
Linux Kernel | net/netfilter/x_tables.c | int xt_check_table_hooks(const struct xt_table_info *info,
unsigned int valid_hooks) {
const char *err = "unsorted underflow";
unsigned int i, max_uflow, max_entry;
bool check_hooks = false;
BUILD_BUG_ON(ARRAY_SIZE(info->hook_entry) != ARRAY_SIZE(info->underflow));
max_entry = 0;
... | [
0,
0
] |
Linux Kernel | net/netfilter/x_tables.c | int xt_compat_add_offset(u_int8_t af, unsigned int offset, int delta) {
struct xt_af *xp = &xt[af];
WARN_ON(!mutex_is_locked(&xt[af].compat_mutex));
if (WARN_ON(!xp->compat_tab))
return -ENOMEM;
if (xp->cur >= xp->number)
return -EINVAL;
if (xp->cur)
delta += xp->compat_tab[xp->cur - 1].delta;... | [
1,
0
] |
Linux Kernel | net/netfilter/x_tables.c |
int xt_compat_calc_jump(u_int8_t af, unsigned int offset) {
struct compat_delta *tmp = xt[af].compat_tab;
int mid, left = 0, right = xt[af].cur - 1;
while (left <= right) {
mid = (left + right) >> 1;
if (offset > tmp[mid].offset)
left = mid + 1;
else if (offset < tmp[mid].offset)
right =... | [
0,
0
] |
Linux Kernel | net/netfilter/x_tables.c |
int xt_compat_init_offsets(u8 af, unsigned int number) {
size_t mem;
WARN_ON(!mutex_is_locked(&xt[af].compat_mutex));
if (!number || number > (INT_MAX / sizeof(struct compat_delta)))
return -EINVAL;
if (WARN_ON(xt[af].compat_tab))
return -EINVAL;
mem = sizeof(struct compat_delta) * number;
if (... | [
1,
0
] |
Linux Kernel | net/netfilter/x_tables.c |
int xt_compat_match_offset(const struct xt_match *match) {
u_int16_t csize = match->compatsize ?: match->matchsize;
return XT_ALIGN(match->matchsize) - COMPAT_XT_ALIGN(csize);
} | [
0,
0
] |
Linux Kernel | net/netfilter/x_tables.c |
int xt_compat_match_to_user(const struct xt_entry_match *m,
void __user **dstptr, unsigned int *size) {
const struct xt_match *match = m->u.kernel.match;
struct compat_xt_entry_match __user *cm = *dstptr;
int off = xt_compat_match_offset(match);
u_int16_t msize = m->u.user.match_siz... | [
1,
0
] |
Linux Kernel | net/netfilter/x_tables.c | unsigned int *xt_alloc_entry_offsets(unsigned int size) {
if (size > XT_MAX_TABLE_SIZE / sizeof(unsigned int))
return NULL;
return kvcalloc(size, sizeof(unsigned int), GFP_KERNEL);
} | [
1,
0
] |
Linux Kernel | net/netfilter/x_tables.c | int xt_check_target(struct xt_tgchk_param *par, unsigned int size, u16 proto,
bool inv_proto) {
int ret;
if (XT_ALIGN(par->target->targetsize) != size) {
pr_err_ratelimited(
"%s_tables: %s.%u target: invalid size %u (kernel) != (user) %u\n",
xt_prefix[par->family], par->targ... | [
1,
0
] |
Linux Kernel | net/netfilter/x_tables.c |
void xt_compat_target_from_user(struct xt_entry_target *t, void **dstptr,
unsigned int *size) {
const struct xt_target *target = t->u.kernel.target;
struct compat_xt_entry_target *ct = (struct compat_xt_entry_target *)t;
int off = xt_compat_target_offset(target);
u_int16_t tsize... | [
1,
0
] |
Linux Kernel | net/netfilter/x_tables.c |
void xt_free_table_info(struct xt_table_info *info) {
int cpu;
if (info->jumpstack != NULL) {
for_each_possible_cpu(cpu) kvfree(info->jumpstack[cpu]);
kvfree(info->jumpstack);
}
kvfree(info);
} | [
0,
0
] |
Linux Kernel | net/netfilter/x_tables.c |
struct xt_table *xt_request_find_table_lock(struct net *net, u_int8_t af,
const char *name) {
struct xt_table *t = xt_find_table_lock(net, af, name);
#ifdef CONFIG_MODULES
if (IS_ERR(t)) {
int err = request_module("%stable_%s", xt_prefix[af], name);
if (err < 0)... | [
0,
0
] |
Linux Kernel | net/netfilter/x_tables.c |
void *xt_unregister_table(struct xt_table *table) {
struct xt_table_info *private;
mutex_lock(&xt[table->af].mutex);
private = table->private;
list_del(&table->list);
mutex_unlock(&xt[table->af].mutex);
audit_log_nfcfg(table->name, table->af, private->number,
AUDIT_XT_OP_UNREGISTER, GFP_... | [
0,
0
] |
Linux Kernel | net/netfilter/x_tables.c |
static void *xt_mttg_seq_start(struct seq_file *seq, loff_t *pos,
bool is_target) {
struct nf_mttg_trav *trav = seq->private;
unsigned int j;
trav->class = MTTG_TRAV_INIT;
for (j = 0; j < *pos; ++j)
if (xt_mttg_seq_next(seq, NULL, NULL, is_target) == NULL)
return NULL;... | [
0,
0
] |
Linux Kernel | net/netfilter/x_tables.c |
static void *xt_match_seq_next(struct seq_file *seq, void *v, loff_t *ppos) {
return xt_mttg_seq_next(seq, v, ppos, false);
} | [
0,
0
] |
Linux Kernel | net/netfilter/x_tables.c |
static void *xt_target_seq_next(struct seq_file *seq, void *v, loff_t *ppos) {
return xt_mttg_seq_next(seq, v, ppos, true);
} | [
0,
0
] |
Linux Kernel | net/netfilter/x_tables.c | struct nf_hook_ops *xt_hook_ops_alloc(const struct xt_table *table,
nf_hookfn *fn) {
unsigned int hook_mask = table->valid_hooks;
uint8_t i, num_hooks = hweight32(hook_mask);
uint8_t hooknum;
struct nf_hook_ops *ops;
if (!num_hooks)
return ERR_PTR(-EINVAL);
ops = ... | [
1,
0
] |
Linux Kernel | net/netfilter/x_tables.c | void xt_proto_fini(struct net *net, u_int8_t af) {
#ifdef CONFIG_PROC_FS
char buf[XT_FUNCTION_MAXNAMELEN];
strscpy(buf, xt_prefix[af], sizeof(buf));
strlcat(buf, FORMAT_TABLES, sizeof(buf));
remove_proc_entry(buf, net->proc_net);
strscpy(buf, xt_prefix[af], sizeof(buf));
strlcat(buf, FORMAT_TARGETS, sizeo... | [
1,
0
] |
Linux Kernel | net/netfilter/x_tables.c | bool xt_percpu_counter_alloc(struct xt_percpu_counter_alloc_state *state,
struct xt_counters *counter) {
BUILD_BUG_ON(XT_PCPU_BLOCK_SIZE < (sizeof(*counter) * 2));
if (nr_cpu_ids <= 1)
return true;
if (!state->mem) {
state->mem = __alloc_percpu(XT_PCPU_BLOCK_SIZE, XT_PCPU_BL... | [
1,
0
] |
Linux Kernel | net/netfilter/x_tables.c |
static void __net_exit xt_net_exit(struct net *net) {
struct xt_pernet *xt_net = net_generic(net, xt_pernet_id);
int i;
for (i = 0; i < NFPROTO_NUMPROTO; i++)
WARN_ON_ONCE(!list_empty(&xt_net->tables[i]));
} | [
0,
0
] |
Linux Kernel | net/netlabel/netlabel_addrlist.c | struct netlbl_af4list *netlbl_af4list_search(__be32 addr,
struct list_head *head) {
struct netlbl_af4list *iter;
list_for_each_entry_rcu(iter, head,
list) if (iter->valid && (addr & iter->mask) ==
... | [
0,
0
] |
Linux Kernel | net/netlabel/netlabel_addrlist.c | struct netlbl_af4list *netlbl_af4list_remove(__be32 addr, __be32 mask,
struct list_head *head) {
struct netlbl_af4list *entry;
entry = netlbl_af4list_search_exact(addr, mask, head);
if (entry == NULL)
return NULL;
netlbl_af4list_remove_entry(entry);
return ent... | [
0,
0
] |
Linux Kernel | net/netlabel/netlabel_addrlist.c | struct netlbl_af6list *netlbl_af6list_remove(const struct in6_addr *addr,
const struct in6_addr *mask,
struct list_head *head) {
struct netlbl_af6list *entry;
entry = netlbl_af6list_search_exact(addr, mask, head);
if (entry... | [
0,
0
] |
Linux Kernel | net/netlabel/netlabel_addrlist.h |
static inline struct netlbl_af6list *__af6list_valid(struct list_head *s,
struct list_head *h) {
struct list_head *i = s;
struct netlbl_af6list *n = __af6list_entry(s);
while (i != h && !n->valid) {
i = i->next;
n = __af6list_entry(i);
}
return n;
... | [
1,
0
] |
Linux Kernel | net/netlabel/netlabel_calipso.c | static int netlbl_calipso_add_pass(struct genl_info *info,
struct netlbl_audit *audit_info) {
int ret_val;
struct calipso_doi *doi_def = NULL;
doi_def = kmalloc(sizeof(*doi_def), GFP_KERNEL);
if (!doi_def)
return -ENOMEM;
doi_def->type = CALIPSO_MAP_PASS;
doi_def->doi... | [
0,
0
] |
Linux Kernel | net/netlabel/netlabel_calipso.c | static int netlbl_calipso_listall(struct sk_buff *skb,
struct netlink_callback *cb) {
struct netlbl_calipso_doiwalk_arg cb_arg;
u32 doi_skip = cb->args[0];
cb_arg.nl_cb = cb;
cb_arg.skb = skb;
cb_arg.seq = cb->nlh->nlmsg_seq;
calipso_doi_walk(&doi_skip, netlbl_calipso_lis... | [
0,
0
] |
Linux Kernel | net/netlabel/netlabel_calipso.c | static int netlbl_calipso_remove_cb(struct netlbl_dom_map *entry, void *arg) {
struct netlbl_domhsh_walk_arg *cb_arg = arg;
if (entry->def.type == NETLBL_NLTYPE_CALIPSO &&
entry->def.calipso->doi == cb_arg->doi)
return netlbl_domhsh_remove_entry(entry, cb_arg->audit_info);
return 0;
} | [
1,
0
] |
Linux Kernel | net/netlabel/netlabel_calipso.c | const struct netlbl_calipso_ops *
netlbl_calipso_ops_register(const struct netlbl_calipso_ops *ops) {
return xchg(&calipso_ops, ops);
} | [
0,
0
] |
Linux Kernel | net/netlabel/netlabel_calipso.c | void calipso_doi_free(struct calipso_doi *doi_def) {
const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
if (ops)
ops->doi_free(doi_def);
} | [
0,
0
] |
Linux Kernel | net/netlabel/netlabel_calipso.c | void calipso_doi_putdef(struct calipso_doi *doi_def) {
const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
if (ops)
ops->doi_putdef(doi_def);
} | [
0,
0
] |
Linux Kernel | net/netlabel/netlabel_calipso.c | void calipso_sock_delattr(struct sock *sk) {
const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
if (ops)
ops->sock_delattr(sk);
} | [
0,
0
] |
Linux Kernel | net/netlabel/netlabel_calipso.c | int calipso_req_setattr(struct request_sock *req,
const struct calipso_doi *doi_def,
const struct netlbl_lsm_secattr *secattr) {
int ret_val = -ENOMSG;
const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
if (ops)
ret_val = ops->req_setattr(req, doi... | [
0,
0
] |
Linux Kernel | net/netlabel/netlabel_calipso.c | void calipso_req_delattr(struct request_sock *req) {
const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
if (ops)
ops->req_delattr(req);
} | [
0,
0
] |
Linux Kernel | net/netlabel/netlabel_calipso.c | unsigned char *calipso_optptr(const struct sk_buff *skb) {
unsigned char *ret_val = NULL;
const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
if (ops)
ret_val = ops->skbuff_optptr(skb);
return ret_val;
} | [
1,
0
] |
Linux Kernel | net/netlabel/netlabel_calipso.c | void calipso_cache_invalidate(void) {
const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
if (ops)
ops->cache_invalidate();
} | [
0,
0
] |
Linux Kernel | net/netlabel/netlabel_cipso_v4.c | static int netlbl_cipsov4_add_common(struct genl_info *info,
struct cipso_v4_doi *doi_def) {
struct nlattr *nla;
int nla_rem;
u32 iter = 0;
doi_def->doi = nla_get_u32(info->attrs[NLBL_CIPSOV4_A_DOI]);
if (nla_validate_nested_deprecated(info->attrs[NLBL_CIPSOV4_A_TAGLST],... | [
0,
0
] |
Linux Kernel | net/netlabel/netlabel_cipso_v4.c | static int netlbl_cipsov4_add_local(struct genl_info *info,
struct netlbl_audit *audit_info) {
int ret_val;
struct cipso_v4_doi *doi_def = NULL;
if (!info->attrs[NLBL_CIPSOV4_A_TAGLST])
return -EINVAL;
doi_def = kmalloc(sizeof(*doi_def), GFP_KERNEL);
if (doi_def == NU... | [
0,
0
] |
Linux Kernel | net/netlabel/netlabel_domainhash.c | static struct netlbl_dom_map *netlbl_domhsh_search(const char *domain,
u16 family) {
u32 bkt;
struct list_head *bkt_list;
struct netlbl_dom_map *iter;
if (domain != NULL) {
bkt = netlbl_domhsh_hash(domain);
bkt_list = &netlbl_domhsh_rcu_deref(netlbl_do... | [
0,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.