linux/net/netfilter/ipset/ip_set_hash_netiface.c

// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (C) 2011-2013 Jozsef Kadlecsik <[email protected]> */

/* Kernel module implementing an IP set type: the hash:net,iface type */

#include <linux/jhash.h>
#include <linux/module.h>
#include <linux/ip.h>
#include <linux/skbuff.h>
#include <linux/errno.h>
#include <linux/random.h>
#include <net/ip.h>
#include <net/ipv6.h>
#include <net/netlink.h>

#include <linux/netfilter.h>
#include <linux/netfilter_bridge.h>
#include <linux/netfilter/ipset/pfxlen.h>
#include <linux/netfilter/ipset/ip_set.h>
#include <linux/netfilter/ipset/ip_set_hash.h>

#define IPSET_TYPE_REV_MIN …
/*				1    nomatch flag support added */
/*				2    /0 support added */
/*				3    Counters support added */
/*				4    Comments support added */
/*				5    Forceadd support added */
/*				6    skbinfo support added */
/*				7    interface wildcard support added */
#define IPSET_TYPE_REV_MAX …

MODULE_LICENSE(…) …;
MODULE_AUTHOR(…) …;
IP_SET_MODULE_DESC(…) …;
MODULE_ALIAS(…) …;

/* Type specific function prefix */
#define HTYPE …
#define IP_SET_HASH_WITH_NETS
#define IP_SET_HASH_WITH_MULTI
#define IP_SET_HASH_WITH_NET0

#define STRSCPY(a, b) …

/* IPv4 variant */

struct hash_netiface4_elem_hashed { … };

/* Member elements */
struct hash_netiface4_elem { … };

/* Common functions */

static bool
hash_netiface4_data_equal(const struct hash_netiface4_elem *ip1,
			  const struct hash_netiface4_elem *ip2,
			  u32 *multi)
{ … }

static int
hash_netiface4_do_data_match(const struct hash_netiface4_elem *elem)
{ … }

static void
hash_netiface4_data_set_flags(struct hash_netiface4_elem *elem, u32 flags)
{ … }

static void
hash_netiface4_data_reset_flags(struct hash_netiface4_elem *elem, u8 *flags)
{ … }

static void
hash_netiface4_data_netmask(struct hash_netiface4_elem *elem, u8 cidr)
{ … }

static bool
hash_netiface4_data_list(struct sk_buff *skb,
			 const struct hash_netiface4_elem *data)
{ … }

static void
hash_netiface4_data_next(struct hash_netiface4_elem *next,
			 const struct hash_netiface4_elem *d)
{ … }

#define MTYPE …
#define HOST_MASK …
#define HKEY_DATALEN …
#include "ip_set_hash_gen.h"

#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
static const char *get_physindev_name(const struct sk_buff *skb, struct net *net)
{ … }

static const char *get_physoutdev_name(const struct sk_buff *skb)
{ … }
#endif

static int
hash_netiface4_kadt(struct ip_set *set, const struct sk_buff *skb,
		    const struct xt_action_param *par,
		    enum ipset_adt adt, struct ip_set_adt_opt *opt)
{ … }

static int
hash_netiface4_uadt(struct ip_set *set, struct nlattr *tb[],
		    enum ipset_adt adt, u32 *lineno, u32 flags, bool retried)
{ … }

/* IPv6 variant */

struct hash_netiface6_elem_hashed { … };

struct hash_netiface6_elem { … };

/* Common functions */

static bool
hash_netiface6_data_equal(const struct hash_netiface6_elem *ip1,
			  const struct hash_netiface6_elem *ip2,
			  u32 *multi)
{ … }

static int
hash_netiface6_do_data_match(const struct hash_netiface6_elem *elem)
{ … }

static void
hash_netiface6_data_set_flags(struct hash_netiface6_elem *elem, u32 flags)
{ … }

static void
hash_netiface6_data_reset_flags(struct hash_netiface6_elem *elem, u8 *flags)
{ … }

static void
hash_netiface6_data_netmask(struct hash_netiface6_elem *elem, u8 cidr)
{ … }

static bool
hash_netiface6_data_list(struct sk_buff *skb,
			 const struct hash_netiface6_elem *data)
{ … }

static void
hash_netiface6_data_next(struct hash_netiface6_elem *next,
			 const struct hash_netiface6_elem *d)
{ … }

#undef MTYPE
#undef HOST_MASK

#define MTYPE …
#define HOST_MASK …
#define HKEY_DATALEN …
#define IP_SET_EMIT_CREATE
#include "ip_set_hash_gen.h"

static int
hash_netiface6_kadt(struct ip_set *set, const struct sk_buff *skb,
		    const struct xt_action_param *par,
		    enum ipset_adt adt, struct ip_set_adt_opt *opt)
{ … }

static int
hash_netiface6_uadt(struct ip_set *set, struct nlattr *tb[],
		    enum ipset_adt adt, u32 *lineno, u32 flags, bool retried)
{ … }

static struct ip_set_type hash_netiface_type __read_mostly = …;

static int __init
hash_netiface_init(void)
{ … }

static void __exit
hash_netiface_fini(void)
{ … }

module_init(…) …;
module_exit(hash_netiface_fini);