1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Copyright (c) 2015 Nicira, Inc.
   4 */
   5
   6#include <linux/module.h>
   7#include <linux/openvswitch.h>
   8#include <linux/tcp.h>
   9#include <linux/udp.h>
  10#include <linux/sctp.h>
  11#include <linux/static_key.h>
 
  12#include <net/ip.h>
  13#include <net/genetlink.h>
  14#include <net/netfilter/nf_conntrack_core.h>
  15#include <net/netfilter/nf_conntrack_count.h>
  16#include <net/netfilter/nf_conntrack_helper.h>
  17#include <net/netfilter/nf_conntrack_labels.h>
  18#include <net/netfilter/nf_conntrack_seqadj.h>
  19#include <net/netfilter/nf_conntrack_timeout.h>
  20#include <net/netfilter/nf_conntrack_zones.h>
  21#include <net/netfilter/ipv6/nf_defrag_ipv6.h>
  22#include <net/ipv6_frag.h>
  23
  24#if IS_ENABLED(CONFIG_NF_NAT)
  25#include <net/netfilter/nf_nat.h>
  26#endif
  27
 
 
  28#include "datapath.h"
 
  29#include "conntrack.h"
  30#include "flow.h"
  31#include "flow_netlink.h"
  32
  33struct ovs_ct_len_tbl {
  34	int maxlen;
  35	int minlen;
  36};
  37
  38/* Metadata mark for masked write to conntrack mark */
  39struct md_mark {
  40	u32 value;
  41	u32 mask;
  42};
  43
  44/* Metadata label for masked write to conntrack label. */
  45struct md_labels {
  46	struct ovs_key_ct_labels value;
  47	struct ovs_key_ct_labels mask;
  48};
  49
  50enum ovs_ct_nat {
  51	OVS_CT_NAT = 1 << 0,     /* NAT for committed connections only. */
  52	OVS_CT_SRC_NAT = 1 << 1, /* Source NAT for NEW connections. */
  53	OVS_CT_DST_NAT = 1 << 2, /* Destination NAT for NEW connections. */
  54};
  55
  56/* Conntrack action context for execution. */
  57struct ovs_conntrack_info {
  58	struct nf_conntrack_helper *helper;
  59	struct nf_conntrack_zone zone;
  60	struct nf_conn *ct;
  61	u8 commit : 1;
  62	u8 nat : 3;                 /* enum ovs_ct_nat */
  63	u8 force : 1;
  64	u8 have_eventmask : 1;
  65	u16 family;
  66	u32 eventmask;              /* Mask of 1 << IPCT_*. */
  67	struct md_mark mark;
  68	struct md_labels labels;
  69	char timeout[CTNL_TIMEOUT_NAME_MAX];
  70	struct nf_ct_timeout *nf_ct_timeout;
  71#if IS_ENABLED(CONFIG_NF_NAT)
  72	struct nf_nat_range2 range;  /* Only present for SRC NAT and DST NAT. */
  73#endif
  74};
  75
  76#if	IS_ENABLED(CONFIG_NETFILTER_CONNCOUNT)
  77#define OVS_CT_LIMIT_UNLIMITED	0
  78#define OVS_CT_LIMIT_DEFAULT OVS_CT_LIMIT_UNLIMITED
  79#define CT_LIMIT_HASH_BUCKETS 512
  80static DEFINE_STATIC_KEY_FALSE(ovs_ct_limit_enabled);
  81
  82struct ovs_ct_limit {
  83	/* Elements in ovs_ct_limit_info->limits hash table */
  84	struct hlist_node hlist_node;
  85	struct rcu_head rcu;
  86	u16 zone;
  87	u32 limit;
  88};
  89
  90struct ovs_ct_limit_info {
  91	u32 default_limit;
  92	struct hlist_head *limits;
  93	struct nf_conncount_data *data;
  94};
  95
  96static const struct nla_policy ct_limit_policy[OVS_CT_LIMIT_ATTR_MAX + 1] = {
  97	[OVS_CT_LIMIT_ATTR_ZONE_LIMIT] = { .type = NLA_NESTED, },
  98};
  99#endif
 100
 101static bool labels_nonzero(const struct ovs_key_ct_labels *labels);
 102
 103static void __ovs_ct_free_action(struct ovs_conntrack_info *ct_info);
 104
 105static u16 key_to_nfproto(const struct sw_flow_key *key)
 106{
 107	switch (ntohs(key->eth.type)) {
 108	case ETH_P_IP:
 109		return NFPROTO_IPV4;
 110	case ETH_P_IPV6:
 111		return NFPROTO_IPV6;
 112	default:
 113		return NFPROTO_UNSPEC;
 114	}
 115}
 116
 117/* Map SKB connection state into the values used by flow definition. */
 118static u8 ovs_ct_get_state(enum ip_conntrack_info ctinfo)
 119{
 120	u8 ct_state = OVS_CS_F_TRACKED;
 121
 122	switch (ctinfo) {
 123	case IP_CT_ESTABLISHED_REPLY:
 124	case IP_CT_RELATED_REPLY:
 125		ct_state |= OVS_CS_F_REPLY_DIR;
 126		break;
 127	default:
 128		break;
 129	}
 130
 131	switch (ctinfo) {
 132	case IP_CT_ESTABLISHED:
 133	case IP_CT_ESTABLISHED_REPLY:
 134		ct_state |= OVS_CS_F_ESTABLISHED;
 135		break;
 136	case IP_CT_RELATED:
 137	case IP_CT_RELATED_REPLY:
 138		ct_state |= OVS_CS_F_RELATED;
 139		break;
 140	case IP_CT_NEW:
 141		ct_state |= OVS_CS_F_NEW;
 142		break;
 143	default:
 144		break;
 145	}
 146
 147	return ct_state;
 148}
 149
 150static u32 ovs_ct_get_mark(const struct nf_conn *ct)
 151{
 152#if IS_ENABLED(CONFIG_NF_CONNTRACK_MARK)
 153	return ct ? ct->mark : 0;
 154#else
 155	return 0;
 156#endif
 157}
 158
 159/* Guard against conntrack labels max size shrinking below 128 bits. */
 160#if NF_CT_LABELS_MAX_SIZE < 16
 161#error NF_CT_LABELS_MAX_SIZE must be at least 16 bytes
 162#endif
 163
 164static void ovs_ct_get_labels(const struct nf_conn *ct,
 165			      struct ovs_key_ct_labels *labels)
 166{
 167	struct nf_conn_labels *cl = ct ? nf_ct_labels_find(ct) : NULL;
 168
 
 
 
 
 
 169	if (cl)
 170		memcpy(labels, cl->bits, OVS_CT_LABELS_LEN);
 171	else
 172		memset(labels, 0, OVS_CT_LABELS_LEN);
 173}
 174
 175static void __ovs_ct_update_key_orig_tp(struct sw_flow_key *key,
 176					const struct nf_conntrack_tuple *orig,
 177					u8 icmp_proto)
 178{
 179	key->ct_orig_proto = orig->dst.protonum;
 180	if (orig->dst.protonum == icmp_proto) {
 181		key->ct.orig_tp.src = htons(orig->dst.u.icmp.type);
 182		key->ct.orig_tp.dst = htons(orig->dst.u.icmp.code);
 183	} else {
 184		key->ct.orig_tp.src = orig->src.u.all;
 185		key->ct.orig_tp.dst = orig->dst.u.all;
 186	}
 187}
 188
 189static void __ovs_ct_update_key(struct sw_flow_key *key, u8 state,
 190				const struct nf_conntrack_zone *zone,
 191				const struct nf_conn *ct)
 192{
 193	key->ct_state = state;
 194	key->ct_zone = zone->id;
 195	key->ct.mark = ovs_ct_get_mark(ct);
 196	ovs_ct_get_labels(ct, &key->ct.labels);
 197
 198	if (ct) {
 199		const struct nf_conntrack_tuple *orig;
 200
 201		/* Use the master if we have one. */
 202		if (ct->master)
 203			ct = ct->master;
 204		orig = &ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple;
 205
 206		/* IP version must match with the master connection. */
 207		if (key->eth.type == htons(ETH_P_IP) &&
 208		    nf_ct_l3num(ct) == NFPROTO_IPV4) {
 209			key->ipv4.ct_orig.src = orig->src.u3.ip;
 210			key->ipv4.ct_orig.dst = orig->dst.u3.ip;
 211			__ovs_ct_update_key_orig_tp(key, orig, IPPROTO_ICMP);
 212			return;
 213		} else if (key->eth.type == htons(ETH_P_IPV6) &&
 214			   !sw_flow_key_is_nd(key) &&
 215			   nf_ct_l3num(ct) == NFPROTO_IPV6) {
 216			key->ipv6.ct_orig.src = orig->src.u3.in6;
 217			key->ipv6.ct_orig.dst = orig->dst.u3.in6;
 218			__ovs_ct_update_key_orig_tp(key, orig, NEXTHDR_ICMP);
 219			return;
 220		}
 221	}
 222	/* Clear 'ct_orig_proto' to mark the non-existence of conntrack
 223	 * original direction key fields.
 224	 */
 225	key->ct_orig_proto = 0;
 226}
 227
 228/* Update 'key' based on skb->_nfct.  If 'post_ct' is true, then OVS has
 229 * previously sent the packet to conntrack via the ct action.  If
 230 * 'keep_nat_flags' is true, the existing NAT flags retained, else they are
 231 * initialized from the connection status.
 232 */
 233static void ovs_ct_update_key(const struct sk_buff *skb,
 234			      const struct ovs_conntrack_info *info,
 235			      struct sw_flow_key *key, bool post_ct,
 236			      bool keep_nat_flags)
 237{
 238	const struct nf_conntrack_zone *zone = &nf_ct_zone_dflt;
 239	enum ip_conntrack_info ctinfo;
 240	struct nf_conn *ct;
 241	u8 state = 0;
 242
 243	ct = nf_ct_get(skb, &ctinfo);
 244	if (ct) {
 245		state = ovs_ct_get_state(ctinfo);
 246		/* All unconfirmed entries are NEW connections. */
 247		if (!nf_ct_is_confirmed(ct))
 248			state |= OVS_CS_F_NEW;
 249		/* OVS persists the related flag for the duration of the
 250		 * connection.
 251		 */
 252		if (ct->master)
 253			state |= OVS_CS_F_RELATED;
 254		if (keep_nat_flags) {
 255			state |= key->ct_state & OVS_CS_F_NAT_MASK;
 256		} else {
 257			if (ct->status & IPS_SRC_NAT)
 258				state |= OVS_CS_F_SRC_NAT;
 259			if (ct->status & IPS_DST_NAT)
 260				state |= OVS_CS_F_DST_NAT;
 261		}
 262		zone = nf_ct_zone(ct);
 263	} else if (post_ct) {
 264		state = OVS_CS_F_TRACKED | OVS_CS_F_INVALID;
 265		if (info)
 266			zone = &info->zone;
 267	}
 268	__ovs_ct_update_key(key, state, zone, ct);
 269}
 270
 271/* This is called to initialize CT key fields possibly coming in from the local
 272 * stack.
 273 */
 274void ovs_ct_fill_key(const struct sk_buff *skb,
 275		     struct sw_flow_key *key,
 276		     bool post_ct)
 277{
 278	ovs_ct_update_key(skb, NULL, key, post_ct, false);
 279}
 280
 281int ovs_ct_put_key(const struct sw_flow_key *swkey,
 282		   const struct sw_flow_key *output, struct sk_buff *skb)
 283{
 284	if (nla_put_u32(skb, OVS_KEY_ATTR_CT_STATE, output->ct_state))
 285		return -EMSGSIZE;
 286
 287	if (IS_ENABLED(CONFIG_NF_CONNTRACK_ZONES) &&
 288	    nla_put_u16(skb, OVS_KEY_ATTR_CT_ZONE, output->ct_zone))
 289		return -EMSGSIZE;
 290
 291	if (IS_ENABLED(CONFIG_NF_CONNTRACK_MARK) &&
 292	    nla_put_u32(skb, OVS_KEY_ATTR_CT_MARK, output->ct.mark))
 293		return -EMSGSIZE;
 294
 295	if (IS_ENABLED(CONFIG_NF_CONNTRACK_LABELS) &&
 296	    nla_put(skb, OVS_KEY_ATTR_CT_LABELS, sizeof(output->ct.labels),
 297		    &output->ct.labels))
 298		return -EMSGSIZE;
 299
 300	if (swkey->ct_orig_proto) {
 301		if (swkey->eth.type == htons(ETH_P_IP)) {
 302			struct ovs_key_ct_tuple_ipv4 orig;
 303
 304			memset(&orig, 0, sizeof(orig));
 305			orig.ipv4_src = output->ipv4.ct_orig.src;
 306			orig.ipv4_dst = output->ipv4.ct_orig.dst;
 307			orig.src_port = output->ct.orig_tp.src;
 308			orig.dst_port = output->ct.orig_tp.dst;
 309			orig.ipv4_proto = output->ct_orig_proto;
 310
 311			if (nla_put(skb, OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4,
 312				    sizeof(orig), &orig))
 313				return -EMSGSIZE;
 314		} else if (swkey->eth.type == htons(ETH_P_IPV6)) {
 315			struct ovs_key_ct_tuple_ipv6 orig;
 316
 317			memset(&orig, 0, sizeof(orig));
 318			memcpy(orig.ipv6_src, output->ipv6.ct_orig.src.s6_addr32,
 319			       sizeof(orig.ipv6_src));
 320			memcpy(orig.ipv6_dst, output->ipv6.ct_orig.dst.s6_addr32,
 321			       sizeof(orig.ipv6_dst));
 322			orig.src_port = output->ct.orig_tp.src;
 323			orig.dst_port = output->ct.orig_tp.dst;
 324			orig.ipv6_proto = output->ct_orig_proto;
 325
 326			if (nla_put(skb, OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6,
 327				    sizeof(orig), &orig))
 328				return -EMSGSIZE;
 329		}
 330	}
 331
 332	return 0;
 333}
 334
 335static int ovs_ct_set_mark(struct nf_conn *ct, struct sw_flow_key *key,
 336			   u32 ct_mark, u32 mask)
 337{
 338#if IS_ENABLED(CONFIG_NF_CONNTRACK_MARK)
 339	u32 new_mark;
 340
 341	new_mark = ct_mark | (ct->mark & ~(mask));
 342	if (ct->mark != new_mark) {
 343		ct->mark = new_mark;
 344		if (nf_ct_is_confirmed(ct))
 345			nf_conntrack_event_cache(IPCT_MARK, ct);
 346		key->ct.mark = new_mark;
 347	}
 348
 349	return 0;
 350#else
 351	return -ENOTSUPP;
 352#endif
 353}
 354
 355static struct nf_conn_labels *ovs_ct_get_conn_labels(struct nf_conn *ct)
 356{
 357	struct nf_conn_labels *cl;
 358
 359	cl = nf_ct_labels_find(ct);
 360	if (!cl) {
 361		nf_ct_labels_ext_add(ct);
 362		cl = nf_ct_labels_find(ct);
 363	}
 364
 365	return cl;
 366}
 367
 368/* Initialize labels for a new, yet to be committed conntrack entry.  Note that
 369 * since the new connection is not yet confirmed, and thus no-one else has
 370 * access to it's labels, we simply write them over.
 371 */
 372static int ovs_ct_init_labels(struct nf_conn *ct, struct sw_flow_key *key,
 373			      const struct ovs_key_ct_labels *labels,
 374			      const struct ovs_key_ct_labels *mask)
 375{
 376	struct nf_conn_labels *cl, *master_cl;
 377	bool have_mask = labels_nonzero(mask);
 378
 379	/* Inherit master's labels to the related connection? */
 380	master_cl = ct->master ? nf_ct_labels_find(ct->master) : NULL;
 381
 382	if (!master_cl && !have_mask)
 383		return 0;   /* Nothing to do. */
 384
 385	cl = ovs_ct_get_conn_labels(ct);
 386	if (!cl)
 387		return -ENOSPC;
 388
 389	/* Inherit the master's labels, if any. */
 390	if (master_cl)
 391		*cl = *master_cl;
 392
 393	if (have_mask) {
 394		u32 *dst = (u32 *)cl->bits;
 395		int i;
 396
 397		for (i = 0; i < OVS_CT_LABELS_LEN_32; i++)
 398			dst[i] = (dst[i] & ~mask->ct_labels_32[i]) |
 399				(labels->ct_labels_32[i]
 400				 & mask->ct_labels_32[i]);
 401	}
 402
 403	/* Labels are included in the IPCTNL_MSG_CT_NEW event only if the
 404	 * IPCT_LABEL bit is set in the event cache.
 405	 */
 406	nf_conntrack_event_cache(IPCT_LABEL, ct);
 407
 408	memcpy(&key->ct.labels, cl->bits, OVS_CT_LABELS_LEN);
 409
 410	return 0;
 411}
 412
 413static int ovs_ct_set_labels(struct nf_conn *ct, struct sw_flow_key *key,
 414			     const struct ovs_key_ct_labels *labels,
 415			     const struct ovs_key_ct_labels *mask)
 416{
 417	struct nf_conn_labels *cl;
 418	int err;
 419
 420	cl = ovs_ct_get_conn_labels(ct);
 421	if (!cl)
 422		return -ENOSPC;
 423
 424	err = nf_connlabels_replace(ct, labels->ct_labels_32,
 425				    mask->ct_labels_32,
 426				    OVS_CT_LABELS_LEN_32);
 427	if (err)
 428		return err;
 429
 430	memcpy(&key->ct.labels, cl->bits, OVS_CT_LABELS_LEN);
 431
 432	return 0;
 433}
 434
 435/* 'skb' should already be pulled to nh_ofs. */
 436static int ovs_ct_helper(struct sk_buff *skb, u16 proto)
 437{
 438	const struct nf_conntrack_helper *helper;
 439	const struct nf_conn_help *help;
 440	enum ip_conntrack_info ctinfo;
 441	unsigned int protoff;
 442	struct nf_conn *ct;
 443	int err;
 444
 445	ct = nf_ct_get(skb, &ctinfo);
 446	if (!ct || ctinfo == IP_CT_RELATED_REPLY)
 447		return NF_ACCEPT;
 448
 449	help = nfct_help(ct);
 450	if (!help)
 451		return NF_ACCEPT;
 452
 453	helper = rcu_dereference(help->helper);
 454	if (!helper)
 455		return NF_ACCEPT;
 456
 457	switch (proto) {
 458	case NFPROTO_IPV4:
 459		protoff = ip_hdrlen(skb);
 460		break;
 461	case NFPROTO_IPV6: {
 462		u8 nexthdr = ipv6_hdr(skb)->nexthdr;
 463		__be16 frag_off;
 464		int ofs;
 465
 466		ofs = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr,
 467				       &frag_off);
 468		if (ofs < 0 || (frag_off & htons(~0x7)) != 0) {
 469			pr_debug("proto header not found\n");
 470			return NF_ACCEPT;
 471		}
 472		protoff = ofs;
 473		break;
 474	}
 475	default:
 476		WARN_ONCE(1, "helper invoked on non-IP family!");
 477		return NF_DROP;
 478	}
 479
 480	err = helper->help(skb, protoff, ct, ctinfo);
 481	if (err != NF_ACCEPT)
 482		return err;
 483
 484	/* Adjust seqs after helper.  This is needed due to some helpers (e.g.,
 485	 * FTP with NAT) adusting the TCP payload size when mangling IP
 486	 * addresses and/or port numbers in the text-based control connection.
 487	 */
 488	if (test_bit(IPS_SEQ_ADJUST_BIT, &ct->status) &&
 489	    !nf_ct_seq_adjust(skb, ct, ctinfo, protoff))
 490		return NF_DROP;
 491	return NF_ACCEPT;
 492}
 493
 494/* Returns 0 on success, -EINPROGRESS if 'skb' is stolen, or other nonzero
 495 * value if 'skb' is freed.
 496 */
 497static int handle_fragments(struct net *net, struct sw_flow_key *key,
 498			    u16 zone, struct sk_buff *skb)
 499{
 500	struct ovs_skb_cb ovs_cb = *OVS_CB(skb);
 501	int err;
 502
 503	if (key->eth.type == htons(ETH_P_IP)) {
 504		enum ip_defrag_users user = IP_DEFRAG_CONNTRACK_IN + zone;
 505
 506		memset(IPCB(skb), 0, sizeof(struct inet_skb_parm));
 507		err = ip_defrag(net, skb, user);
 508		if (err)
 509			return err;
 510
 511		ovs_cb.mru = IPCB(skb)->frag_max_size;
 512#if IS_ENABLED(CONFIG_NF_DEFRAG_IPV6)
 513	} else if (key->eth.type == htons(ETH_P_IPV6)) {
 514		enum ip6_defrag_users user = IP6_DEFRAG_CONNTRACK_IN + zone;
 515
 516		memset(IP6CB(skb), 0, sizeof(struct inet6_skb_parm));
 517		err = nf_ct_frag6_gather(net, skb, user);
 518		if (err) {
 519			if (err != -EINPROGRESS)
 520				kfree_skb(skb);
 521			return err;
 522		}
 523
 524		key->ip.proto = ipv6_hdr(skb)->nexthdr;
 525		ovs_cb.mru = IP6CB(skb)->frag_max_size;
 526#endif
 527	} else {
 528		kfree_skb(skb);
 529		return -EPFNOSUPPORT;
 530	}
 531
 532	/* The key extracted from the fragment that completed this datagram
 533	 * likely didn't have an L4 header, so regenerate it.
 534	 */
 535	ovs_flow_key_update_l3l4(skb, key);
 536
 537	key->ip.frag = OVS_FRAG_TYPE_NONE;
 538	skb_clear_hash(skb);
 539	skb->ignore_df = 1;
 540	*OVS_CB(skb) = ovs_cb;
 541
 542	return 0;
 543}
 544
 545static struct nf_conntrack_expect *
 546ovs_ct_expect_find(struct net *net, const struct nf_conntrack_zone *zone,
 547		   u16 proto, const struct sk_buff *skb)
 548{
 549	struct nf_conntrack_tuple tuple;
 550	struct nf_conntrack_expect *exp;
 551
 552	if (!nf_ct_get_tuplepr(skb, skb_network_offset(skb), proto, net, &tuple))
 553		return NULL;
 554
 555	exp = __nf_ct_expect_find(net, zone, &tuple);
 556	if (exp) {
 557		struct nf_conntrack_tuple_hash *h;
 558
 559		/* Delete existing conntrack entry, if it clashes with the
 560		 * expectation.  This can happen since conntrack ALGs do not
 561		 * check for clashes between (new) expectations and existing
 562		 * conntrack entries.  nf_conntrack_in() will check the
 563		 * expectations only if a conntrack entry can not be found,
 564		 * which can lead to OVS finding the expectation (here) in the
 565		 * init direction, but which will not be removed by the
 566		 * nf_conntrack_in() call, if a matching conntrack entry is
 567		 * found instead.  In this case all init direction packets
 568		 * would be reported as new related packets, while reply
 569		 * direction packets would be reported as un-related
 570		 * established packets.
 571		 */
 572		h = nf_conntrack_find_get(net, zone, &tuple);
 573		if (h) {
 574			struct nf_conn *ct = nf_ct_tuplehash_to_ctrack(h);
 575
 576			nf_ct_delete(ct, 0, 0);
 577			nf_conntrack_put(&ct->ct_general);
 578		}
 579	}
 580
 581	return exp;
 582}
 583
 584/* This replicates logic from nf_conntrack_core.c that is not exported. */
 585static enum ip_conntrack_info
 586ovs_ct_get_info(const struct nf_conntrack_tuple_hash *h)
 587{
 588	const struct nf_conn *ct = nf_ct_tuplehash_to_ctrack(h);
 589
 590	if (NF_CT_DIRECTION(h) == IP_CT_DIR_REPLY)
 591		return IP_CT_ESTABLISHED_REPLY;
 592	/* Once we've had two way comms, always ESTABLISHED. */
 593	if (test_bit(IPS_SEEN_REPLY_BIT, &ct->status))
 594		return IP_CT_ESTABLISHED;
 595	if (test_bit(IPS_EXPECTED_BIT, &ct->status))
 596		return IP_CT_RELATED;
 597	return IP_CT_NEW;
 598}
 599
 600/* Find an existing connection which this packet belongs to without
 601 * re-attributing statistics or modifying the connection state.  This allows an
 602 * skb->_nfct lost due to an upcall to be recovered during actions execution.
 603 *
 604 * Must be called with rcu_read_lock.
 605 *
 606 * On success, populates skb->_nfct and returns the connection.  Returns NULL
 607 * if there is no existing entry.
 608 */
 609static struct nf_conn *
 610ovs_ct_find_existing(struct net *net, const struct nf_conntrack_zone *zone,
 611		     u8 l3num, struct sk_buff *skb, bool natted)
 612{
 613	struct nf_conntrack_tuple tuple;
 614	struct nf_conntrack_tuple_hash *h;
 615	struct nf_conn *ct;
 616
 617	if (!nf_ct_get_tuplepr(skb, skb_network_offset(skb), l3num,
 618			       net, &tuple)) {
 619		pr_debug("ovs_ct_find_existing: Can't get tuple\n");
 620		return NULL;
 621	}
 622
 623	/* Must invert the tuple if skb has been transformed by NAT. */
 624	if (natted) {
 625		struct nf_conntrack_tuple inverse;
 626
 627		if (!nf_ct_invert_tuple(&inverse, &tuple)) {
 628			pr_debug("ovs_ct_find_existing: Inversion failed!\n");
 629			return NULL;
 630		}
 631		tuple = inverse;
 632	}
 633
 634	/* look for tuple match */
 635	h = nf_conntrack_find_get(net, zone, &tuple);
 636	if (!h)
 637		return NULL;   /* Not found. */
 638
 639	ct = nf_ct_tuplehash_to_ctrack(h);
 640
 641	/* Inverted packet tuple matches the reverse direction conntrack tuple,
 642	 * select the other tuplehash to get the right 'ctinfo' bits for this
 643	 * packet.
 644	 */
 645	if (natted)
 646		h = &ct->tuplehash[!h->tuple.dst.dir];
 647
 648	nf_ct_set(skb, ct, ovs_ct_get_info(h));
 649	return ct;
 650}
 651
 652static
 653struct nf_conn *ovs_ct_executed(struct net *net,
 654				const struct sw_flow_key *key,
 655				const struct ovs_conntrack_info *info,
 656				struct sk_buff *skb,
 657				bool *ct_executed)
 658{
 659	struct nf_conn *ct = NULL;
 660
 661	/* If no ct, check if we have evidence that an existing conntrack entry
 662	 * might be found for this skb.  This happens when we lose a skb->_nfct
 663	 * due to an upcall, or if the direction is being forced.  If the
 664	 * connection was not confirmed, it is not cached and needs to be run
 665	 * through conntrack again.
 666	 */
 667	*ct_executed = (key->ct_state & OVS_CS_F_TRACKED) &&
 668		       !(key->ct_state & OVS_CS_F_INVALID) &&
 669		       (key->ct_zone == info->zone.id);
 670
 671	if (*ct_executed || (!key->ct_state && info->force)) {
 672		ct = ovs_ct_find_existing(net, &info->zone, info->family, skb,
 673					  !!(key->ct_state &
 674					  OVS_CS_F_NAT_MASK));
 675	}
 676
 677	return ct;
 678}
 679
 680/* Determine whether skb->_nfct is equal to the result of conntrack lookup. */
 681static bool skb_nfct_cached(struct net *net,
 682			    const struct sw_flow_key *key,
 683			    const struct ovs_conntrack_info *info,
 684			    struct sk_buff *skb)
 685{
 686	enum ip_conntrack_info ctinfo;
 687	struct nf_conn *ct;
 688	bool ct_executed = true;
 689
 690	ct = nf_ct_get(skb, &ctinfo);
 691	if (!ct)
 692		ct = ovs_ct_executed(net, key, info, skb, &ct_executed);
 693
 694	if (ct)
 695		nf_ct_get(skb, &ctinfo);
 696	else
 697		return false;
 698
 699	if (!net_eq(net, read_pnet(&ct->ct_net)))
 700		return false;
 701	if (!nf_ct_zone_equal_any(info->ct, nf_ct_zone(ct)))
 702		return false;
 703	if (info->helper) {
 704		struct nf_conn_help *help;
 705
 706		help = nf_ct_ext_find(ct, NF_CT_EXT_HELPER);
 707		if (help && rcu_access_pointer(help->helper) != info->helper)
 708			return false;
 709	}
 710	if (info->nf_ct_timeout) {
 711		struct nf_conn_timeout *timeout_ext;
 712
 713		timeout_ext = nf_ct_timeout_find(ct);
 714		if (!timeout_ext || info->nf_ct_timeout !=
 715		    rcu_dereference(timeout_ext->timeout))
 716			return false;
 717	}
 718	/* Force conntrack entry direction to the current packet? */
 719	if (info->force && CTINFO2DIR(ctinfo) != IP_CT_DIR_ORIGINAL) {
 720		/* Delete the conntrack entry if confirmed, else just release
 721		 * the reference.
 722		 */
 723		if (nf_ct_is_confirmed(ct))
 724			nf_ct_delete(ct, 0, 0);
 725
 726		nf_conntrack_put(&ct->ct_general);
 727		nf_ct_set(skb, NULL, 0);
 728		return false;
 729	}
 730
 731	return ct_executed;
 732}
 733
 734#if IS_ENABLED(CONFIG_NF_NAT)
 735/* Modelled after nf_nat_ipv[46]_fn().
 736 * range is only used for new, uninitialized NAT state.
 737 * Returns either NF_ACCEPT or NF_DROP.
 738 */
 739static int ovs_ct_nat_execute(struct sk_buff *skb, struct nf_conn *ct,
 740			      enum ip_conntrack_info ctinfo,
 741			      const struct nf_nat_range2 *range,
 742			      enum nf_nat_manip_type maniptype)
 743{
 744	int hooknum, nh_off, err = NF_ACCEPT;
 745
 746	nh_off = skb_network_offset(skb);
 747	skb_pull_rcsum(skb, nh_off);
 748
 749	/* See HOOK2MANIP(). */
 750	if (maniptype == NF_NAT_MANIP_SRC)
 751		hooknum = NF_INET_LOCAL_IN; /* Source NAT */
 752	else
 753		hooknum = NF_INET_LOCAL_OUT; /* Destination NAT */
 754
 755	switch (ctinfo) {
 756	case IP_CT_RELATED:
 757	case IP_CT_RELATED_REPLY:
 758		if (IS_ENABLED(CONFIG_NF_NAT) &&
 759		    skb->protocol == htons(ETH_P_IP) &&
 760		    ip_hdr(skb)->protocol == IPPROTO_ICMP) {
 761			if (!nf_nat_icmp_reply_translation(skb, ct, ctinfo,
 762							   hooknum))
 763				err = NF_DROP;
 764			goto push;
 765		} else if (IS_ENABLED(CONFIG_IPV6) &&
 766			   skb->protocol == htons(ETH_P_IPV6)) {
 767			__be16 frag_off;
 768			u8 nexthdr = ipv6_hdr(skb)->nexthdr;
 769			int hdrlen = ipv6_skip_exthdr(skb,
 770						      sizeof(struct ipv6hdr),
 771						      &nexthdr, &frag_off);
 772
 773			if (hdrlen >= 0 && nexthdr == IPPROTO_ICMPV6) {
 774				if (!nf_nat_icmpv6_reply_translation(skb, ct,
 775								     ctinfo,
 776								     hooknum,
 777								     hdrlen))
 778					err = NF_DROP;
 779				goto push;
 780			}
 781		}
 782		/* Non-ICMP, fall thru to initialize if needed. */
 783		fallthrough;
 784	case IP_CT_NEW:
 785		/* Seen it before?  This can happen for loopback, retrans,
 786		 * or local packets.
 787		 */
 788		if (!nf_nat_initialized(ct, maniptype)) {
 789			/* Initialize according to the NAT action. */
 790			err = (range && range->flags & NF_NAT_RANGE_MAP_IPS)
 791				/* Action is set up to establish a new
 792				 * mapping.
 793				 */
 794				? nf_nat_setup_info(ct, range, maniptype)
 795				: nf_nat_alloc_null_binding(ct, hooknum);
 796			if (err != NF_ACCEPT)
 797				goto push;
 798		}
 799		break;
 800
 801	case IP_CT_ESTABLISHED:
 802	case IP_CT_ESTABLISHED_REPLY:
 803		break;
 804
 805	default:
 806		err = NF_DROP;
 807		goto push;
 808	}
 809
 810	err = nf_nat_packet(ct, ctinfo, hooknum, skb);
 811push:
 812	skb_push_rcsum(skb, nh_off);
 813
 814	return err;
 815}
 816
 817static void ovs_nat_update_key(struct sw_flow_key *key,
 818			       const struct sk_buff *skb,
 819			       enum nf_nat_manip_type maniptype)
 820{
 821	if (maniptype == NF_NAT_MANIP_SRC) {
 822		__be16 src;
 823
 824		key->ct_state |= OVS_CS_F_SRC_NAT;
 825		if (key->eth.type == htons(ETH_P_IP))
 826			key->ipv4.addr.src = ip_hdr(skb)->saddr;
 827		else if (key->eth.type == htons(ETH_P_IPV6))
 828			memcpy(&key->ipv6.addr.src, &ipv6_hdr(skb)->saddr,
 829			       sizeof(key->ipv6.addr.src));
 830		else
 831			return;
 832
 833		if (key->ip.proto == IPPROTO_UDP)
 834			src = udp_hdr(skb)->source;
 835		else if (key->ip.proto == IPPROTO_TCP)
 836			src = tcp_hdr(skb)->source;
 837		else if (key->ip.proto == IPPROTO_SCTP)
 838			src = sctp_hdr(skb)->source;
 839		else
 840			return;
 841
 842		key->tp.src = src;
 843	} else {
 844		__be16 dst;
 845
 846		key->ct_state |= OVS_CS_F_DST_NAT;
 847		if (key->eth.type == htons(ETH_P_IP))
 848			key->ipv4.addr.dst = ip_hdr(skb)->daddr;
 849		else if (key->eth.type == htons(ETH_P_IPV6))
 850			memcpy(&key->ipv6.addr.dst, &ipv6_hdr(skb)->daddr,
 851			       sizeof(key->ipv6.addr.dst));
 852		else
 853			return;
 854
 855		if (key->ip.proto == IPPROTO_UDP)
 856			dst = udp_hdr(skb)->dest;
 857		else if (key->ip.proto == IPPROTO_TCP)
 858			dst = tcp_hdr(skb)->dest;
 859		else if (key->ip.proto == IPPROTO_SCTP)
 860			dst = sctp_hdr(skb)->dest;
 861		else
 862			return;
 863
 864		key->tp.dst = dst;
 865	}
 866}
 867
 868/* Returns NF_DROP if the packet should be dropped, NF_ACCEPT otherwise. */
 869static int ovs_ct_nat(struct net *net, struct sw_flow_key *key,
 870		      const struct ovs_conntrack_info *info,
 871		      struct sk_buff *skb, struct nf_conn *ct,
 872		      enum ip_conntrack_info ctinfo)
 873{
 874	enum nf_nat_manip_type maniptype;
 875	int err;
 876
 877	/* Add NAT extension if not confirmed yet. */
 878	if (!nf_ct_is_confirmed(ct) && !nf_ct_nat_ext_add(ct))
 879		return NF_ACCEPT;   /* Can't NAT. */
 880
 881	/* Determine NAT type.
 882	 * Check if the NAT type can be deduced from the tracked connection.
 883	 * Make sure new expected connections (IP_CT_RELATED) are NATted only
 884	 * when committing.
 885	 */
 886	if (info->nat & OVS_CT_NAT && ctinfo != IP_CT_NEW &&
 887	    ct->status & IPS_NAT_MASK &&
 888	    (ctinfo != IP_CT_RELATED || info->commit)) {
 889		/* NAT an established or related connection like before. */
 890		if (CTINFO2DIR(ctinfo) == IP_CT_DIR_REPLY)
 891			/* This is the REPLY direction for a connection
 892			 * for which NAT was applied in the forward
 893			 * direction.  Do the reverse NAT.
 894			 */
 895			maniptype = ct->status & IPS_SRC_NAT
 896				? NF_NAT_MANIP_DST : NF_NAT_MANIP_SRC;
 897		else
 898			maniptype = ct->status & IPS_SRC_NAT
 899				? NF_NAT_MANIP_SRC : NF_NAT_MANIP_DST;
 900	} else if (info->nat & OVS_CT_SRC_NAT) {
 901		maniptype = NF_NAT_MANIP_SRC;
 902	} else if (info->nat & OVS_CT_DST_NAT) {
 903		maniptype = NF_NAT_MANIP_DST;
 904	} else {
 905		return NF_ACCEPT; /* Connection is not NATed. */
 906	}
 907	err = ovs_ct_nat_execute(skb, ct, ctinfo, &info->range, maniptype);
 908
 909	if (err == NF_ACCEPT && ct->status & IPS_DST_NAT) {
 910		if (ct->status & IPS_SRC_NAT) {
 911			if (maniptype == NF_NAT_MANIP_SRC)
 912				maniptype = NF_NAT_MANIP_DST;
 913			else
 914				maniptype = NF_NAT_MANIP_SRC;
 915
 916			err = ovs_ct_nat_execute(skb, ct, ctinfo, &info->range,
 917						 maniptype);
 918		} else if (CTINFO2DIR(ctinfo) == IP_CT_DIR_ORIGINAL) {
 919			err = ovs_ct_nat_execute(skb, ct, ctinfo, NULL,
 920						 NF_NAT_MANIP_SRC);
 921		}
 922	}
 923
 924	/* Mark NAT done if successful and update the flow key. */
 925	if (err == NF_ACCEPT)
 926		ovs_nat_update_key(key, skb, maniptype);
 
 927
 928	return err;
 929}
 930#else /* !CONFIG_NF_NAT */
 931static int ovs_ct_nat(struct net *net, struct sw_flow_key *key,
 932		      const struct ovs_conntrack_info *info,
 933		      struct sk_buff *skb, struct nf_conn *ct,
 934		      enum ip_conntrack_info ctinfo)
 935{
 936	return NF_ACCEPT;
 937}
 938#endif
 939
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 940/* Pass 'skb' through conntrack in 'net', using zone configured in 'info', if
 941 * not done already.  Update key with new CT state after passing the packet
 942 * through conntrack.
 943 * Note that if the packet is deemed invalid by conntrack, skb->_nfct will be
 944 * set to NULL and 0 will be returned.
 945 */
 946static int __ovs_ct_lookup(struct net *net, struct sw_flow_key *key,
 947			   const struct ovs_conntrack_info *info,
 948			   struct sk_buff *skb)
 949{
 950	/* If we are recirculating packets to match on conntrack fields and
 951	 * committing with a separate conntrack action,  then we don't need to
 952	 * actually run the packet through conntrack twice unless it's for a
 953	 * different zone.
 954	 */
 955	bool cached = skb_nfct_cached(net, key, info, skb);
 956	enum ip_conntrack_info ctinfo;
 957	struct nf_conn *ct;
 958
 959	if (!cached) {
 960		struct nf_hook_state state = {
 961			.hook = NF_INET_PRE_ROUTING,
 962			.pf = info->family,
 963			.net = net,
 964		};
 965		struct nf_conn *tmpl = info->ct;
 966		int err;
 967
 968		/* Associate skb with specified zone. */
 969		if (tmpl) {
 970			nf_conntrack_put(skb_nfct(skb));
 
 971			nf_conntrack_get(&tmpl->ct_general);
 972			nf_ct_set(skb, tmpl, IP_CT_NEW);
 973		}
 974
 975		err = nf_conntrack_in(skb, &state);
 976		if (err != NF_ACCEPT)
 977			return -ENOENT;
 978
 979		/* Clear CT state NAT flags to mark that we have not yet done
 980		 * NAT after the nf_conntrack_in() call.  We can actually clear
 981		 * the whole state, as it will be re-initialized below.
 982		 */
 983		key->ct_state = 0;
 984
 985		/* Update the key, but keep the NAT flags. */
 986		ovs_ct_update_key(skb, info, key, true, true);
 987	}
 988
 989	ct = nf_ct_get(skb, &ctinfo);
 990	if (ct) {
 991		bool add_helper = false;
 992
 993		/* Packets starting a new connection must be NATted before the
 994		 * helper, so that the helper knows about the NAT.  We enforce
 995		 * this by delaying both NAT and helper calls for unconfirmed
 996		 * connections until the committing CT action.  For later
 997		 * packets NAT and Helper may be called in either order.
 998		 *
 999		 * NAT will be done only if the CT action has NAT, and only
1000		 * once per packet (per zone), as guarded by the NAT bits in
1001		 * the key->ct_state.
1002		 */
1003		if (info->nat && !(key->ct_state & OVS_CS_F_NAT_MASK) &&
1004		    (nf_ct_is_confirmed(ct) || info->commit) &&
1005		    ovs_ct_nat(net, key, info, skb, ct, ctinfo) != NF_ACCEPT) {
1006			return -EINVAL;
 
 
 
1007		}
1008
1009		/* Userspace may decide to perform a ct lookup without a helper
1010		 * specified followed by a (recirculate and) commit with one,
1011		 * or attach a helper in a later commit.  Therefore, for
1012		 * connections which we will commit, we may need to attach
1013		 * the helper here.
1014		 */
1015		if (info->commit && info->helper && !nfct_help(ct)) {
 
1016			int err = __nf_ct_try_assign_helper(ct, info->ct,
1017							    GFP_ATOMIC);
1018			if (err)
1019				return err;
1020			add_helper = true;
1021
1022			/* helper installed, add seqadj if NAT is required */
1023			if (info->nat && !nfct_seqadj(ct)) {
1024				if (!nfct_seqadj_ext_add(ct))
1025					return -EINVAL;
1026			}
1027		}
1028
1029		/* Call the helper only if:
1030		 * - nf_conntrack_in() was executed above ("!cached") or a
1031		 *   helper was just attached ("add_helper") for a confirmed
1032		 *   connection, or
1033		 * - When committing an unconfirmed connection.
1034		 */
1035		if ((nf_ct_is_confirmed(ct) ? !cached || add_helper :
1036					      info->commit) &&
1037		    ovs_ct_helper(skb, info->family) != NF_ACCEPT) {
1038			return -EINVAL;
 
 
 
1039		}
1040
1041		if (nf_ct_protonum(ct) == IPPROTO_TCP &&
1042		    nf_ct_is_confirmed(ct) && nf_conntrack_tcp_established(ct)) {
1043			/* Be liberal for tcp packets so that out-of-window
1044			 * packets are not marked invalid.
1045			 */
1046			nf_ct_set_tcp_be_liberal(ct);
1047		}
 
 
1048	}
1049
1050	return 0;
1051}
1052
1053/* Lookup connection and read fields into key. */
1054static int ovs_ct_lookup(struct net *net, struct sw_flow_key *key,
1055			 const struct ovs_conntrack_info *info,
1056			 struct sk_buff *skb)
1057{
1058	struct nf_conntrack_expect *exp;
1059
1060	/* If we pass an expected packet through nf_conntrack_in() the
1061	 * expectation is typically removed, but the packet could still be
1062	 * lost in upcall processing.  To prevent this from happening we
1063	 * perform an explicit expectation lookup.  Expected connections are
1064	 * always new, and will be passed through conntrack only when they are
1065	 * committed, as it is OK to remove the expectation at that time.
1066	 */
1067	exp = ovs_ct_expect_find(net, &info->zone, info->family, skb);
1068	if (exp) {
1069		u8 state;
1070
1071		/* NOTE: New connections are NATted and Helped only when
1072		 * committed, so we are not calling into NAT here.
1073		 */
1074		state = OVS_CS_F_TRACKED | OVS_CS_F_NEW | OVS_CS_F_RELATED;
1075		__ovs_ct_update_key(key, state, &info->zone, exp->master);
1076	} else {
1077		struct nf_conn *ct;
1078		int err;
1079
1080		err = __ovs_ct_lookup(net, key, info, skb);
1081		if (err)
1082			return err;
1083
1084		ct = (struct nf_conn *)skb_nfct(skb);
1085		if (ct)
1086			nf_ct_deliver_cached_events(ct);
1087	}
1088
1089	return 0;
1090}
1091
1092static bool labels_nonzero(const struct ovs_key_ct_labels *labels)
1093{
1094	size_t i;
1095
1096	for (i = 0; i < OVS_CT_LABELS_LEN_32; i++)
1097		if (labels->ct_labels_32[i])
1098			return true;
1099
1100	return false;
1101}
1102
1103#if	IS_ENABLED(CONFIG_NETFILTER_CONNCOUNT)
1104static struct hlist_head *ct_limit_hash_bucket(
1105	const struct ovs_ct_limit_info *info, u16 zone)
1106{
1107	return &info->limits[zone & (CT_LIMIT_HASH_BUCKETS - 1)];
1108}
1109
1110/* Call with ovs_mutex */
1111static void ct_limit_set(const struct ovs_ct_limit_info *info,
1112			 struct ovs_ct_limit *new_ct_limit)
1113{
1114	struct ovs_ct_limit *ct_limit;
1115	struct hlist_head *head;
1116
1117	head = ct_limit_hash_bucket(info, new_ct_limit->zone);
1118	hlist_for_each_entry_rcu(ct_limit, head, hlist_node) {
1119		if (ct_limit->zone == new_ct_limit->zone) {
1120			hlist_replace_rcu(&ct_limit->hlist_node,
1121					  &new_ct_limit->hlist_node);
1122			kfree_rcu(ct_limit, rcu);
1123			return;
1124		}
1125	}
1126
1127	hlist_add_head_rcu(&new_ct_limit->hlist_node, head);
1128}
1129
1130/* Call with ovs_mutex */
1131static void ct_limit_del(const struct ovs_ct_limit_info *info, u16 zone)
1132{
1133	struct ovs_ct_limit *ct_limit;
1134	struct hlist_head *head;
1135	struct hlist_node *n;
1136
1137	head = ct_limit_hash_bucket(info, zone);
1138	hlist_for_each_entry_safe(ct_limit, n, head, hlist_node) {
1139		if (ct_limit->zone == zone) {
1140			hlist_del_rcu(&ct_limit->hlist_node);
1141			kfree_rcu(ct_limit, rcu);
1142			return;
1143		}
1144	}
1145}
1146
1147/* Call with RCU read lock */
1148static u32 ct_limit_get(const struct ovs_ct_limit_info *info, u16 zone)
1149{
1150	struct ovs_ct_limit *ct_limit;
1151	struct hlist_head *head;
1152
1153	head = ct_limit_hash_bucket(info, zone);
1154	hlist_for_each_entry_rcu(ct_limit, head, hlist_node) {
1155		if (ct_limit->zone == zone)
1156			return ct_limit->limit;
1157	}
1158
1159	return info->default_limit;
1160}
1161
1162static int ovs_ct_check_limit(struct net *net,
1163			      const struct ovs_conntrack_info *info,
1164			      const struct nf_conntrack_tuple *tuple)
1165{
1166	struct ovs_net *ovs_net = net_generic(net, ovs_net_id);
1167	const struct ovs_ct_limit_info *ct_limit_info = ovs_net->ct_limit_info;
1168	u32 per_zone_limit, connections;
1169	u32 conncount_key;
1170
1171	conncount_key = info->zone.id;
1172
1173	per_zone_limit = ct_limit_get(ct_limit_info, info->zone.id);
1174	if (per_zone_limit == OVS_CT_LIMIT_UNLIMITED)
1175		return 0;
1176
1177	connections = nf_conncount_count(net, ct_limit_info->data,
1178					 &conncount_key, tuple, &info->zone);
1179	if (connections > per_zone_limit)
1180		return -ENOMEM;
1181
1182	return 0;
1183}
1184#endif
1185
1186/* Lookup connection and confirm if unconfirmed. */
1187static int ovs_ct_commit(struct net *net, struct sw_flow_key *key,
1188			 const struct ovs_conntrack_info *info,
1189			 struct sk_buff *skb)
1190{
1191	enum ip_conntrack_info ctinfo;
1192	struct nf_conn *ct;
1193	int err;
1194
1195	err = __ovs_ct_lookup(net, key, info, skb);
1196	if (err)
1197		return err;
1198
1199	/* The connection could be invalid, in which case this is a no-op.*/
1200	ct = nf_ct_get(skb, &ctinfo);
1201	if (!ct)
1202		return 0;
1203
1204#if	IS_ENABLED(CONFIG_NETFILTER_CONNCOUNT)
1205	if (static_branch_unlikely(&ovs_ct_limit_enabled)) {
1206		if (!nf_ct_is_confirmed(ct)) {
1207			err = ovs_ct_check_limit(net, info,
1208				&ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple);
1209			if (err) {
1210				net_warn_ratelimited("openvswitch: zone: %u "
1211					"exceeds conntrack limit\n",
1212					info->zone.id);
1213				return err;
1214			}
1215		}
1216	}
1217#endif
1218
1219	/* Set the conntrack event mask if given.  NEW and DELETE events have
1220	 * their own groups, but the NFNLGRP_CONNTRACK_UPDATE group listener
1221	 * typically would receive many kinds of updates.  Setting the event
1222	 * mask allows those events to be filtered.  The set event mask will
1223	 * remain in effect for the lifetime of the connection unless changed
1224	 * by a further CT action with both the commit flag and the eventmask
1225	 * option. */
1226	if (info->have_eventmask) {
1227		struct nf_conntrack_ecache *cache = nf_ct_ecache_find(ct);
1228
1229		if (cache)
1230			cache->ctmask = info->eventmask;
1231	}
1232
1233	/* Apply changes before confirming the connection so that the initial
1234	 * conntrack NEW netlink event carries the values given in the CT
1235	 * action.
1236	 */
1237	if (info->mark.mask) {
1238		err = ovs_ct_set_mark(ct, key, info->mark.value,
1239				      info->mark.mask);
1240		if (err)
1241			return err;
1242	}
1243	if (!nf_ct_is_confirmed(ct)) {
1244		err = ovs_ct_init_labels(ct, key, &info->labels.value,
1245					 &info->labels.mask);
1246		if (err)
1247			return err;
 
 
1248	} else if (IS_ENABLED(CONFIG_NF_CONNTRACK_LABELS) &&
1249		   labels_nonzero(&info->labels.mask)) {
1250		err = ovs_ct_set_labels(ct, key, &info->labels.value,
1251					&info->labels.mask);
1252		if (err)
1253			return err;
1254	}
1255	/* This will take care of sending queued events even if the connection
1256	 * is already confirmed.
1257	 */
1258	if (nf_conntrack_confirm(skb) != NF_ACCEPT)
1259		return -EINVAL;
1260
1261	return 0;
1262}
1263
1264/* Trim the skb to the length specified by the IP/IPv6 header,
1265 * removing any trailing lower-layer padding. This prepares the skb
1266 * for higher-layer processing that assumes skb->len excludes padding
1267 * (such as nf_ip_checksum). The caller needs to pull the skb to the
1268 * network header, and ensure ip_hdr/ipv6_hdr points to valid data.
1269 */
1270static int ovs_skb_network_trim(struct sk_buff *skb)
1271{
1272	unsigned int len;
1273	int err;
1274
1275	switch (skb->protocol) {
1276	case htons(ETH_P_IP):
1277		len = ntohs(ip_hdr(skb)->tot_len);
1278		break;
1279	case htons(ETH_P_IPV6):
1280		len = sizeof(struct ipv6hdr)
1281			+ ntohs(ipv6_hdr(skb)->payload_len);
1282		break;
1283	default:
1284		len = skb->len;
1285	}
1286
1287	err = pskb_trim_rcsum(skb, len);
1288	if (err)
1289		kfree_skb(skb);
1290
1291	return err;
1292}
1293
1294/* Returns 0 on success, -EINPROGRESS if 'skb' is stolen, or other nonzero
1295 * value if 'skb' is freed.
1296 */
1297int ovs_ct_execute(struct net *net, struct sk_buff *skb,
1298		   struct sw_flow_key *key,
1299		   const struct ovs_conntrack_info *info)
1300{
1301	int nh_ofs;
1302	int err;
1303
1304	/* The conntrack module expects to be working at L3. */
1305	nh_ofs = skb_network_offset(skb);
1306	skb_pull_rcsum(skb, nh_ofs);
1307
1308	err = ovs_skb_network_trim(skb);
1309	if (err)
 
1310		return err;
 
1311
1312	if (key->ip.frag != OVS_FRAG_TYPE_NONE) {
1313		err = handle_fragments(net, key, info->zone.id, skb);
 
1314		if (err)
1315			return err;
1316	}
1317
1318	if (info->commit)
1319		err = ovs_ct_commit(net, key, info, skb);
1320	else
1321		err = ovs_ct_lookup(net, key, info, skb);
1322
 
 
 
 
1323	skb_push_rcsum(skb, nh_ofs);
1324	if (err)
1325		kfree_skb(skb);
1326	return err;
1327}
1328
1329int ovs_ct_clear(struct sk_buff *skb, struct sw_flow_key *key)
1330{
1331	nf_conntrack_put(skb_nfct(skb));
1332	nf_ct_set(skb, NULL, IP_CT_UNTRACKED);
1333	ovs_ct_fill_key(skb, key, false);
1334
1335	return 0;
1336}
1337
1338static int ovs_ct_add_helper(struct ovs_conntrack_info *info, const char *name,
1339			     const struct sw_flow_key *key, bool log)
1340{
1341	struct nf_conntrack_helper *helper;
1342	struct nf_conn_help *help;
1343	int ret = 0;
1344
1345	helper = nf_conntrack_helper_try_module_get(name, info->family,
1346						    key->ip.proto);
1347	if (!helper) {
1348		OVS_NLERR(log, "Unknown helper \"%s\"", name);
1349		return -EINVAL;
1350	}
1351
1352	help = nf_ct_helper_ext_add(info->ct, GFP_KERNEL);
1353	if (!help) {
1354		nf_conntrack_helper_put(helper);
1355		return -ENOMEM;
1356	}
1357
1358#if IS_ENABLED(CONFIG_NF_NAT)
1359	if (info->nat) {
1360		ret = nf_nat_helper_try_module_get(name, info->family,
1361						   key->ip.proto);
1362		if (ret) {
1363			nf_conntrack_helper_put(helper);
1364			OVS_NLERR(log, "Failed to load \"%s\" NAT helper, error: %d",
1365				  name, ret);
1366			return ret;
1367		}
1368	}
1369#endif
1370	rcu_assign_pointer(help->helper, helper);
1371	info->helper = helper;
1372	return ret;
1373}
1374
1375#if IS_ENABLED(CONFIG_NF_NAT)
1376static int parse_nat(const struct nlattr *attr,
1377		     struct ovs_conntrack_info *info, bool log)
1378{
1379	struct nlattr *a;
1380	int rem;
1381	bool have_ip_max = false;
1382	bool have_proto_max = false;
1383	bool ip_vers = (info->family == NFPROTO_IPV6);
1384
1385	nla_for_each_nested(a, attr, rem) {
1386		static const int ovs_nat_attr_lens[OVS_NAT_ATTR_MAX + 1][2] = {
1387			[OVS_NAT_ATTR_SRC] = {0, 0},
1388			[OVS_NAT_ATTR_DST] = {0, 0},
1389			[OVS_NAT_ATTR_IP_MIN] = {sizeof(struct in_addr),
1390						 sizeof(struct in6_addr)},
1391			[OVS_NAT_ATTR_IP_MAX] = {sizeof(struct in_addr),
1392						 sizeof(struct in6_addr)},
1393			[OVS_NAT_ATTR_PROTO_MIN] = {sizeof(u16), sizeof(u16)},
1394			[OVS_NAT_ATTR_PROTO_MAX] = {sizeof(u16), sizeof(u16)},
1395			[OVS_NAT_ATTR_PERSISTENT] = {0, 0},
1396			[OVS_NAT_ATTR_PROTO_HASH] = {0, 0},
1397			[OVS_NAT_ATTR_PROTO_RANDOM] = {0, 0},
1398		};
1399		int type = nla_type(a);
1400
1401		if (type > OVS_NAT_ATTR_MAX) {
1402			OVS_NLERR(log, "Unknown NAT attribute (type=%d, max=%d)",
1403				  type, OVS_NAT_ATTR_MAX);
1404			return -EINVAL;
1405		}
1406
1407		if (nla_len(a) != ovs_nat_attr_lens[type][ip_vers]) {
1408			OVS_NLERR(log, "NAT attribute type %d has unexpected length (%d != %d)",
1409				  type, nla_len(a),
1410				  ovs_nat_attr_lens[type][ip_vers]);
1411			return -EINVAL;
1412		}
1413
1414		switch (type) {
1415		case OVS_NAT_ATTR_SRC:
1416		case OVS_NAT_ATTR_DST:
1417			if (info->nat) {
1418				OVS_NLERR(log, "Only one type of NAT may be specified");
1419				return -ERANGE;
1420			}
1421			info->nat |= OVS_CT_NAT;
1422			info->nat |= ((type == OVS_NAT_ATTR_SRC)
1423					? OVS_CT_SRC_NAT : OVS_CT_DST_NAT);
1424			break;
1425
1426		case OVS_NAT_ATTR_IP_MIN:
1427			nla_memcpy(&info->range.min_addr, a,
1428				   sizeof(info->range.min_addr));
1429			info->range.flags |= NF_NAT_RANGE_MAP_IPS;
1430			break;
1431
1432		case OVS_NAT_ATTR_IP_MAX:
1433			have_ip_max = true;
1434			nla_memcpy(&info->range.max_addr, a,
1435				   sizeof(info->range.max_addr));
1436			info->range.flags |= NF_NAT_RANGE_MAP_IPS;
1437			break;
1438
1439		case OVS_NAT_ATTR_PROTO_MIN:
1440			info->range.min_proto.all = htons(nla_get_u16(a));
1441			info->range.flags |= NF_NAT_RANGE_PROTO_SPECIFIED;
1442			break;
1443
1444		case OVS_NAT_ATTR_PROTO_MAX:
1445			have_proto_max = true;
1446			info->range.max_proto.all = htons(nla_get_u16(a));
1447			info->range.flags |= NF_NAT_RANGE_PROTO_SPECIFIED;
1448			break;
1449
1450		case OVS_NAT_ATTR_PERSISTENT:
1451			info->range.flags |= NF_NAT_RANGE_PERSISTENT;
1452			break;
1453
1454		case OVS_NAT_ATTR_PROTO_HASH:
1455			info->range.flags |= NF_NAT_RANGE_PROTO_RANDOM;
1456			break;
1457
1458		case OVS_NAT_ATTR_PROTO_RANDOM:
1459			info->range.flags |= NF_NAT_RANGE_PROTO_RANDOM_FULLY;
1460			break;
1461
1462		default:
1463			OVS_NLERR(log, "Unknown nat attribute (%d)", type);
1464			return -EINVAL;
1465		}
1466	}
1467
1468	if (rem > 0) {
1469		OVS_NLERR(log, "NAT attribute has %d unknown bytes", rem);
1470		return -EINVAL;
1471	}
1472	if (!info->nat) {
1473		/* Do not allow flags if no type is given. */
1474		if (info->range.flags) {
1475			OVS_NLERR(log,
1476				  "NAT flags may be given only when NAT range (SRC or DST) is also specified."
1477				  );
1478			return -EINVAL;
1479		}
1480		info->nat = OVS_CT_NAT;   /* NAT existing connections. */
1481	} else if (!info->commit) {
1482		OVS_NLERR(log,
1483			  "NAT attributes may be specified only when CT COMMIT flag is also specified."
1484			  );
1485		return -EINVAL;
1486	}
1487	/* Allow missing IP_MAX. */
1488	if (info->range.flags & NF_NAT_RANGE_MAP_IPS && !have_ip_max) {
1489		memcpy(&info->range.max_addr, &info->range.min_addr,
1490		       sizeof(info->range.max_addr));
1491	}
1492	/* Allow missing PROTO_MAX. */
1493	if (info->range.flags & NF_NAT_RANGE_PROTO_SPECIFIED &&
1494	    !have_proto_max) {
1495		info->range.max_proto.all = info->range.min_proto.all;
1496	}
1497	return 0;
1498}
1499#endif
1500
1501static const struct ovs_ct_len_tbl ovs_ct_attr_lens[OVS_CT_ATTR_MAX + 1] = {
1502	[OVS_CT_ATTR_COMMIT]	= { .minlen = 0, .maxlen = 0 },
1503	[OVS_CT_ATTR_FORCE_COMMIT]	= { .minlen = 0, .maxlen = 0 },
1504	[OVS_CT_ATTR_ZONE]	= { .minlen = sizeof(u16),
1505				    .maxlen = sizeof(u16) },
1506	[OVS_CT_ATTR_MARK]	= { .minlen = sizeof(struct md_mark),
1507				    .maxlen = sizeof(struct md_mark) },
1508	[OVS_CT_ATTR_LABELS]	= { .minlen = sizeof(struct md_labels),
1509				    .maxlen = sizeof(struct md_labels) },
1510	[OVS_CT_ATTR_HELPER]	= { .minlen = 1,
1511				    .maxlen = NF_CT_HELPER_NAME_LEN },
1512#if IS_ENABLED(CONFIG_NF_NAT)
1513	/* NAT length is checked when parsing the nested attributes. */
1514	[OVS_CT_ATTR_NAT]	= { .minlen = 0, .maxlen = INT_MAX },
1515#endif
1516	[OVS_CT_ATTR_EVENTMASK]	= { .minlen = sizeof(u32),
1517				    .maxlen = sizeof(u32) },
1518	[OVS_CT_ATTR_TIMEOUT] = { .minlen = 1,
1519				  .maxlen = CTNL_TIMEOUT_NAME_MAX },
1520};
1521
1522static int parse_ct(const struct nlattr *attr, struct ovs_conntrack_info *info,
1523		    const char **helper, bool log)
1524{
1525	struct nlattr *a;
1526	int rem;
1527
1528	nla_for_each_nested(a, attr, rem) {
1529		int type = nla_type(a);
1530		int maxlen;
1531		int minlen;
1532
1533		if (type > OVS_CT_ATTR_MAX) {
1534			OVS_NLERR(log,
1535				  "Unknown conntrack attr (type=%d, max=%d)",
1536				  type, OVS_CT_ATTR_MAX);
1537			return -EINVAL;
1538		}
1539
1540		maxlen = ovs_ct_attr_lens[type].maxlen;
1541		minlen = ovs_ct_attr_lens[type].minlen;
1542		if (nla_len(a) < minlen || nla_len(a) > maxlen) {
1543			OVS_NLERR(log,
1544				  "Conntrack attr type has unexpected length (type=%d, length=%d, expected=%d)",
1545				  type, nla_len(a), maxlen);
1546			return -EINVAL;
1547		}
1548
1549		switch (type) {
1550		case OVS_CT_ATTR_FORCE_COMMIT:
1551			info->force = true;
1552			fallthrough;
1553		case OVS_CT_ATTR_COMMIT:
1554			info->commit = true;
1555			break;
1556#ifdef CONFIG_NF_CONNTRACK_ZONES
1557		case OVS_CT_ATTR_ZONE:
1558			info->zone.id = nla_get_u16(a);
1559			break;
1560#endif
1561#ifdef CONFIG_NF_CONNTRACK_MARK
1562		case OVS_CT_ATTR_MARK: {
1563			struct md_mark *mark = nla_data(a);
1564
1565			if (!mark->mask) {
1566				OVS_NLERR(log, "ct_mark mask cannot be 0");
1567				return -EINVAL;
1568			}
1569			info->mark = *mark;
1570			break;
1571		}
1572#endif
1573#ifdef CONFIG_NF_CONNTRACK_LABELS
1574		case OVS_CT_ATTR_LABELS: {
1575			struct md_labels *labels = nla_data(a);
1576
1577			if (!labels_nonzero(&labels->mask)) {
1578				OVS_NLERR(log, "ct_labels mask cannot be 0");
1579				return -EINVAL;
1580			}
1581			info->labels = *labels;
1582			break;
1583		}
1584#endif
1585		case OVS_CT_ATTR_HELPER:
1586			*helper = nla_data(a);
1587			if (!memchr(*helper, '\0', nla_len(a))) {
1588				OVS_NLERR(log, "Invalid conntrack helper");
1589				return -EINVAL;
1590			}
1591			break;
1592#if IS_ENABLED(CONFIG_NF_NAT)
1593		case OVS_CT_ATTR_NAT: {
1594			int err = parse_nat(a, info, log);
1595
1596			if (err)
1597				return err;
1598			break;
1599		}
1600#endif
1601		case OVS_CT_ATTR_EVENTMASK:
1602			info->have_eventmask = true;
1603			info->eventmask = nla_get_u32(a);
1604			break;
1605#ifdef CONFIG_NF_CONNTRACK_TIMEOUT
1606		case OVS_CT_ATTR_TIMEOUT:
1607			memcpy(info->timeout, nla_data(a), nla_len(a));
1608			if (!memchr(info->timeout, '\0', nla_len(a))) {
1609				OVS_NLERR(log, "Invalid conntrack timeout");
1610				return -EINVAL;
1611			}
1612			break;
1613#endif
1614
1615		default:
1616			OVS_NLERR(log, "Unknown conntrack attr (%d)",
1617				  type);
1618			return -EINVAL;
1619		}
1620	}
1621
1622#ifdef CONFIG_NF_CONNTRACK_MARK
1623	if (!info->commit && info->mark.mask) {
1624		OVS_NLERR(log,
1625			  "Setting conntrack mark requires 'commit' flag.");
1626		return -EINVAL;
1627	}
1628#endif
1629#ifdef CONFIG_NF_CONNTRACK_LABELS
1630	if (!info->commit && labels_nonzero(&info->labels.mask)) {
1631		OVS_NLERR(log,
1632			  "Setting conntrack labels requires 'commit' flag.");
1633		return -EINVAL;
1634	}
1635#endif
1636	if (rem > 0) {
1637		OVS_NLERR(log, "Conntrack attr has %d unknown bytes", rem);
1638		return -EINVAL;
1639	}
1640
1641	return 0;
1642}
1643
1644bool ovs_ct_verify(struct net *net, enum ovs_key_attr attr)
1645{
1646	if (attr == OVS_KEY_ATTR_CT_STATE)
1647		return true;
1648	if (IS_ENABLED(CONFIG_NF_CONNTRACK_ZONES) &&
1649	    attr == OVS_KEY_ATTR_CT_ZONE)
1650		return true;
1651	if (IS_ENABLED(CONFIG_NF_CONNTRACK_MARK) &&
1652	    attr == OVS_KEY_ATTR_CT_MARK)
1653		return true;
1654	if (IS_ENABLED(CONFIG_NF_CONNTRACK_LABELS) &&
1655	    attr == OVS_KEY_ATTR_CT_LABELS) {
1656		struct ovs_net *ovs_net = net_generic(net, ovs_net_id);
1657
1658		return ovs_net->xt_label;
1659	}
1660
1661	return false;
1662}
1663
1664int ovs_ct_copy_action(struct net *net, const struct nlattr *attr,
1665		       const struct sw_flow_key *key,
1666		       struct sw_flow_actions **sfa,  bool log)
1667{
 
1668	struct ovs_conntrack_info ct_info;
1669	const char *helper = NULL;
1670	u16 family;
1671	int err;
1672
1673	family = key_to_nfproto(key);
1674	if (family == NFPROTO_UNSPEC) {
1675		OVS_NLERR(log, "ct family unspecified");
1676		return -EINVAL;
1677	}
1678
1679	memset(&ct_info, 0, sizeof(ct_info));
1680	ct_info.family = family;
1681
1682	nf_ct_zone_init(&ct_info.zone, NF_CT_DEFAULT_ZONE_ID,
1683			NF_CT_DEFAULT_ZONE_DIR, 0);
1684
1685	err = parse_ct(attr, &ct_info, &helper, log);
1686	if (err)
1687		return err;
1688
1689	/* Set up template for tracking connections in specific zones. */
1690	ct_info.ct = nf_ct_tmpl_alloc(net, &ct_info.zone, GFP_KERNEL);
1691	if (!ct_info.ct) {
1692		OVS_NLERR(log, "Failed to allocate conntrack template");
1693		return -ENOMEM;
1694	}
1695
 
 
 
 
 
 
1696	if (ct_info.timeout[0]) {
1697		if (nf_ct_set_timeout(net, ct_info.ct, family, key->ip.proto,
1698				      ct_info.timeout))
1699			pr_info_ratelimited("Failed to associated timeout "
1700					    "policy `%s'\n", ct_info.timeout);
 
1701		else
1702			ct_info.nf_ct_timeout = rcu_dereference(
1703				nf_ct_timeout_find(ct_info.ct)->timeout);
1704
1705	}
1706
1707	if (helper) {
1708		err = ovs_ct_add_helper(&ct_info, helper, key, log);
1709		if (err)
 
 
1710			goto err_free_ct;
 
1711	}
1712
1713	err = ovs_nla_add_action(sfa, OVS_ACTION_ATTR_CT, &ct_info,
1714				 sizeof(ct_info), log);
1715	if (err)
1716		goto err_free_ct;
1717
1718	__set_bit(IPS_CONFIRMED_BIT, &ct_info.ct->status);
1719	nf_conntrack_get(&ct_info.ct->ct_general);
1720	return 0;
1721err_free_ct:
1722	__ovs_ct_free_action(&ct_info);
1723	return err;
1724}
1725
1726#if IS_ENABLED(CONFIG_NF_NAT)
1727static bool ovs_ct_nat_to_attr(const struct ovs_conntrack_info *info,
1728			       struct sk_buff *skb)
1729{
1730	struct nlattr *start;
1731
1732	start = nla_nest_start_noflag(skb, OVS_CT_ATTR_NAT);
1733	if (!start)
1734		return false;
1735
1736	if (info->nat & OVS_CT_SRC_NAT) {
1737		if (nla_put_flag(skb, OVS_NAT_ATTR_SRC))
1738			return false;
1739	} else if (info->nat & OVS_CT_DST_NAT) {
1740		if (nla_put_flag(skb, OVS_NAT_ATTR_DST))
1741			return false;
1742	} else {
1743		goto out;
1744	}
1745
1746	if (info->range.flags & NF_NAT_RANGE_MAP_IPS) {
1747		if (IS_ENABLED(CONFIG_NF_NAT) &&
1748		    info->family == NFPROTO_IPV4) {
1749			if (nla_put_in_addr(skb, OVS_NAT_ATTR_IP_MIN,
1750					    info->range.min_addr.ip) ||
1751			    (info->range.max_addr.ip
1752			     != info->range.min_addr.ip &&
1753			     (nla_put_in_addr(skb, OVS_NAT_ATTR_IP_MAX,
1754					      info->range.max_addr.ip))))
1755				return false;
1756		} else if (IS_ENABLED(CONFIG_IPV6) &&
1757			   info->family == NFPROTO_IPV6) {
1758			if (nla_put_in6_addr(skb, OVS_NAT_ATTR_IP_MIN,
1759					     &info->range.min_addr.in6) ||
1760			    (memcmp(&info->range.max_addr.in6,
1761				    &info->range.min_addr.in6,
1762				    sizeof(info->range.max_addr.in6)) &&
1763			     (nla_put_in6_addr(skb, OVS_NAT_ATTR_IP_MAX,
1764					       &info->range.max_addr.in6))))
1765				return false;
1766		} else {
1767			return false;
1768		}
1769	}
1770	if (info->range.flags & NF_NAT_RANGE_PROTO_SPECIFIED &&
1771	    (nla_put_u16(skb, OVS_NAT_ATTR_PROTO_MIN,
1772			 ntohs(info->range.min_proto.all)) ||
1773	     (info->range.max_proto.all != info->range.min_proto.all &&
1774	      nla_put_u16(skb, OVS_NAT_ATTR_PROTO_MAX,
1775			  ntohs(info->range.max_proto.all)))))
1776		return false;
1777
1778	if (info->range.flags & NF_NAT_RANGE_PERSISTENT &&
1779	    nla_put_flag(skb, OVS_NAT_ATTR_PERSISTENT))
1780		return false;
1781	if (info->range.flags & NF_NAT_RANGE_PROTO_RANDOM &&
1782	    nla_put_flag(skb, OVS_NAT_ATTR_PROTO_HASH))
1783		return false;
1784	if (info->range.flags & NF_NAT_RANGE_PROTO_RANDOM_FULLY &&
1785	    nla_put_flag(skb, OVS_NAT_ATTR_PROTO_RANDOM))
1786		return false;
1787out:
1788	nla_nest_end(skb, start);
1789
1790	return true;
1791}
1792#endif
1793
1794int ovs_ct_action_to_attr(const struct ovs_conntrack_info *ct_info,
1795			  struct sk_buff *skb)
1796{
1797	struct nlattr *start;
1798
1799	start = nla_nest_start_noflag(skb, OVS_ACTION_ATTR_CT);
1800	if (!start)
1801		return -EMSGSIZE;
1802
1803	if (ct_info->commit && nla_put_flag(skb, ct_info->force
1804					    ? OVS_CT_ATTR_FORCE_COMMIT
1805					    : OVS_CT_ATTR_COMMIT))
1806		return -EMSGSIZE;
1807	if (IS_ENABLED(CONFIG_NF_CONNTRACK_ZONES) &&
1808	    nla_put_u16(skb, OVS_CT_ATTR_ZONE, ct_info->zone.id))
1809		return -EMSGSIZE;
1810	if (IS_ENABLED(CONFIG_NF_CONNTRACK_MARK) && ct_info->mark.mask &&
1811	    nla_put(skb, OVS_CT_ATTR_MARK, sizeof(ct_info->mark),
1812		    &ct_info->mark))
1813		return -EMSGSIZE;
1814	if (IS_ENABLED(CONFIG_NF_CONNTRACK_LABELS) &&
1815	    labels_nonzero(&ct_info->labels.mask) &&
1816	    nla_put(skb, OVS_CT_ATTR_LABELS, sizeof(ct_info->labels),
1817		    &ct_info->labels))
1818		return -EMSGSIZE;
1819	if (ct_info->helper) {
1820		if (nla_put_string(skb, OVS_CT_ATTR_HELPER,
1821				   ct_info->helper->name))
1822			return -EMSGSIZE;
1823	}
1824	if (ct_info->have_eventmask &&
1825	    nla_put_u32(skb, OVS_CT_ATTR_EVENTMASK, ct_info->eventmask))
1826		return -EMSGSIZE;
1827	if (ct_info->timeout[0]) {
1828		if (nla_put_string(skb, OVS_CT_ATTR_TIMEOUT, ct_info->timeout))
1829			return -EMSGSIZE;
1830	}
1831
1832#if IS_ENABLED(CONFIG_NF_NAT)
1833	if (ct_info->nat && !ovs_ct_nat_to_attr(ct_info, skb))
1834		return -EMSGSIZE;
1835#endif
1836	nla_nest_end(skb, start);
1837
1838	return 0;
1839}
1840
1841void ovs_ct_free_action(const struct nlattr *a)
1842{
1843	struct ovs_conntrack_info *ct_info = nla_data(a);
1844
1845	__ovs_ct_free_action(ct_info);
1846}
1847
1848static void __ovs_ct_free_action(struct ovs_conntrack_info *ct_info)
1849{
1850	if (ct_info->helper) {
1851#if IS_ENABLED(CONFIG_NF_NAT)
1852		if (ct_info->nat)
1853			nf_nat_helper_put(ct_info->helper);
1854#endif
1855		nf_conntrack_helper_put(ct_info->helper);
1856	}
1857	if (ct_info->ct) {
1858		if (ct_info->timeout[0])
1859			nf_ct_destroy_timeout(ct_info->ct);
 
1860		nf_ct_tmpl_free(ct_info->ct);
1861	}
1862}
1863
1864#if	IS_ENABLED(CONFIG_NETFILTER_CONNCOUNT)
1865static int ovs_ct_limit_init(struct net *net, struct ovs_net *ovs_net)
1866{
1867	int i, err;
1868
1869	ovs_net->ct_limit_info = kmalloc(sizeof(*ovs_net->ct_limit_info),
1870					 GFP_KERNEL);
1871	if (!ovs_net->ct_limit_info)
1872		return -ENOMEM;
1873
1874	ovs_net->ct_limit_info->default_limit = OVS_CT_LIMIT_DEFAULT;
1875	ovs_net->ct_limit_info->limits =
1876		kmalloc_array(CT_LIMIT_HASH_BUCKETS, sizeof(struct hlist_head),
1877			      GFP_KERNEL);
1878	if (!ovs_net->ct_limit_info->limits) {
1879		kfree(ovs_net->ct_limit_info);
1880		return -ENOMEM;
1881	}
1882
1883	for (i = 0; i < CT_LIMIT_HASH_BUCKETS; i++)
1884		INIT_HLIST_HEAD(&ovs_net->ct_limit_info->limits[i]);
1885
1886	ovs_net->ct_limit_info->data =
1887		nf_conncount_init(net, NFPROTO_INET, sizeof(u32));
1888
1889	if (IS_ERR(ovs_net->ct_limit_info->data)) {
1890		err = PTR_ERR(ovs_net->ct_limit_info->data);
1891		kfree(ovs_net->ct_limit_info->limits);
1892		kfree(ovs_net->ct_limit_info);
1893		pr_err("openvswitch: failed to init nf_conncount %d\n", err);
1894		return err;
1895	}
1896	return 0;
1897}
1898
1899static void ovs_ct_limit_exit(struct net *net, struct ovs_net *ovs_net)
1900{
1901	const struct ovs_ct_limit_info *info = ovs_net->ct_limit_info;
1902	int i;
1903
1904	nf_conncount_destroy(net, NFPROTO_INET, info->data);
1905	for (i = 0; i < CT_LIMIT_HASH_BUCKETS; ++i) {
1906		struct hlist_head *head = &info->limits[i];
1907		struct ovs_ct_limit *ct_limit;
 
1908
1909		hlist_for_each_entry_rcu(ct_limit, head, hlist_node,
1910					 lockdep_ovsl_is_held())
1911			kfree_rcu(ct_limit, rcu);
1912	}
1913	kfree(info->limits);
1914	kfree(info);
1915}
1916
1917static struct sk_buff *
1918ovs_ct_limit_cmd_reply_start(struct genl_info *info, u8 cmd,
1919			     struct ovs_header **ovs_reply_header)
1920{
1921	struct ovs_header *ovs_header = info->userhdr;
1922	struct sk_buff *skb;
1923
1924	skb = genlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1925	if (!skb)
1926		return ERR_PTR(-ENOMEM);
1927
1928	*ovs_reply_header = genlmsg_put(skb, info->snd_portid,
1929					info->snd_seq,
1930					&dp_ct_limit_genl_family, 0, cmd);
1931
1932	if (!*ovs_reply_header) {
1933		nlmsg_free(skb);
1934		return ERR_PTR(-EMSGSIZE);
1935	}
1936	(*ovs_reply_header)->dp_ifindex = ovs_header->dp_ifindex;
1937
1938	return skb;
1939}
1940
1941static bool check_zone_id(int zone_id, u16 *pzone)
1942{
1943	if (zone_id >= 0 && zone_id <= 65535) {
1944		*pzone = (u16)zone_id;
1945		return true;
1946	}
1947	return false;
1948}
1949
1950static int ovs_ct_limit_set_zone_limit(struct nlattr *nla_zone_limit,
1951				       struct ovs_ct_limit_info *info)
1952{
1953	struct ovs_zone_limit *zone_limit;
1954	int rem;
1955	u16 zone;
1956
1957	rem = NLA_ALIGN(nla_len(nla_zone_limit));
1958	zone_limit = (struct ovs_zone_limit *)nla_data(nla_zone_limit);
1959
1960	while (rem >= sizeof(*zone_limit)) {
1961		if (unlikely(zone_limit->zone_id ==
1962				OVS_ZONE_LIMIT_DEFAULT_ZONE)) {
1963			ovs_lock();
1964			info->default_limit = zone_limit->limit;
1965			ovs_unlock();
1966		} else if (unlikely(!check_zone_id(
1967				zone_limit->zone_id, &zone))) {
1968			OVS_NLERR(true, "zone id is out of range");
1969		} else {
1970			struct ovs_ct_limit *ct_limit;
1971
1972			ct_limit = kmalloc(sizeof(*ct_limit), GFP_KERNEL);
 
1973			if (!ct_limit)
1974				return -ENOMEM;
1975
1976			ct_limit->zone = zone;
1977			ct_limit->limit = zone_limit->limit;
1978
1979			ovs_lock();
1980			ct_limit_set(info, ct_limit);
1981			ovs_unlock();
1982		}
1983		rem -= NLA_ALIGN(sizeof(*zone_limit));
1984		zone_limit = (struct ovs_zone_limit *)((u8 *)zone_limit +
1985				NLA_ALIGN(sizeof(*zone_limit)));
1986	}
1987
1988	if (rem)
1989		OVS_NLERR(true, "set zone limit has %d unknown bytes", rem);
1990
1991	return 0;
1992}
1993
1994static int ovs_ct_limit_del_zone_limit(struct nlattr *nla_zone_limit,
1995				       struct ovs_ct_limit_info *info)
1996{
1997	struct ovs_zone_limit *zone_limit;
1998	int rem;
1999	u16 zone;
2000
2001	rem = NLA_ALIGN(nla_len(nla_zone_limit));
2002	zone_limit = (struct ovs_zone_limit *)nla_data(nla_zone_limit);
2003
2004	while (rem >= sizeof(*zone_limit)) {
2005		if (unlikely(zone_limit->zone_id ==
2006				OVS_ZONE_LIMIT_DEFAULT_ZONE)) {
2007			ovs_lock();
2008			info->default_limit = OVS_CT_LIMIT_DEFAULT;
2009			ovs_unlock();
2010		} else if (unlikely(!check_zone_id(
2011				zone_limit->zone_id, &zone))) {
2012			OVS_NLERR(true, "zone id is out of range");
2013		} else {
2014			ovs_lock();
2015			ct_limit_del(info, zone);
2016			ovs_unlock();
2017		}
2018		rem -= NLA_ALIGN(sizeof(*zone_limit));
2019		zone_limit = (struct ovs_zone_limit *)((u8 *)zone_limit +
2020				NLA_ALIGN(sizeof(*zone_limit)));
2021	}
2022
2023	if (rem)
2024		OVS_NLERR(true, "del zone limit has %d unknown bytes", rem);
2025
2026	return 0;
2027}
2028
2029static int ovs_ct_limit_get_default_limit(struct ovs_ct_limit_info *info,
2030					  struct sk_buff *reply)
2031{
2032	struct ovs_zone_limit zone_limit = {
2033		.zone_id = OVS_ZONE_LIMIT_DEFAULT_ZONE,
2034		.limit   = info->default_limit,
2035	};
2036
2037	return nla_put_nohdr(reply, sizeof(zone_limit), &zone_limit);
2038}
2039
2040static int __ovs_ct_limit_get_zone_limit(struct net *net,
2041					 struct nf_conncount_data *data,
2042					 u16 zone_id, u32 limit,
2043					 struct sk_buff *reply)
2044{
2045	struct nf_conntrack_zone ct_zone;
2046	struct ovs_zone_limit zone_limit;
2047	u32 conncount_key = zone_id;
2048
2049	zone_limit.zone_id = zone_id;
2050	zone_limit.limit = limit;
2051	nf_ct_zone_init(&ct_zone, zone_id, NF_CT_DEFAULT_ZONE_DIR, 0);
2052
2053	zone_limit.count = nf_conncount_count(net, data, &conncount_key, NULL,
2054					      &ct_zone);
2055	return nla_put_nohdr(reply, sizeof(zone_limit), &zone_limit);
2056}
2057
2058static int ovs_ct_limit_get_zone_limit(struct net *net,
2059				       struct nlattr *nla_zone_limit,
2060				       struct ovs_ct_limit_info *info,
2061				       struct sk_buff *reply)
2062{
2063	struct ovs_zone_limit *zone_limit;
2064	int rem, err;
2065	u32 limit;
2066	u16 zone;
2067
2068	rem = NLA_ALIGN(nla_len(nla_zone_limit));
2069	zone_limit = (struct ovs_zone_limit *)nla_data(nla_zone_limit);
2070
2071	while (rem >= sizeof(*zone_limit)) {
2072		if (unlikely(zone_limit->zone_id ==
2073				OVS_ZONE_LIMIT_DEFAULT_ZONE)) {
2074			err = ovs_ct_limit_get_default_limit(info, reply);
2075			if (err)
2076				return err;
2077		} else if (unlikely(!check_zone_id(zone_limit->zone_id,
2078							&zone))) {
2079			OVS_NLERR(true, "zone id is out of range");
2080		} else {
2081			rcu_read_lock();
2082			limit = ct_limit_get(info, zone);
2083			rcu_read_unlock();
2084
2085			err = __ovs_ct_limit_get_zone_limit(
2086				net, info->data, zone, limit, reply);
2087			if (err)
2088				return err;
2089		}
2090		rem -= NLA_ALIGN(sizeof(*zone_limit));
2091		zone_limit = (struct ovs_zone_limit *)((u8 *)zone_limit +
2092				NLA_ALIGN(sizeof(*zone_limit)));
2093	}
2094
2095	if (rem)
2096		OVS_NLERR(true, "get zone limit has %d unknown bytes", rem);
2097
2098	return 0;
2099}
2100
2101static int ovs_ct_limit_get_all_zone_limit(struct net *net,
2102					   struct ovs_ct_limit_info *info,
2103					   struct sk_buff *reply)
2104{
2105	struct ovs_ct_limit *ct_limit;
2106	struct hlist_head *head;
2107	int i, err = 0;
2108
2109	err = ovs_ct_limit_get_default_limit(info, reply);
2110	if (err)
2111		return err;
2112
2113	rcu_read_lock();
2114	for (i = 0; i < CT_LIMIT_HASH_BUCKETS; ++i) {
2115		head = &info->limits[i];
2116		hlist_for_each_entry_rcu(ct_limit, head, hlist_node) {
2117			err = __ovs_ct_limit_get_zone_limit(net, info->data,
2118				ct_limit->zone, ct_limit->limit, reply);
2119			if (err)
2120				goto exit_err;
2121		}
2122	}
2123
2124exit_err:
2125	rcu_read_unlock();
2126	return err;
2127}
2128
2129static int ovs_ct_limit_cmd_set(struct sk_buff *skb, struct genl_info *info)
2130{
2131	struct nlattr **a = info->attrs;
2132	struct sk_buff *reply;
2133	struct ovs_header *ovs_reply_header;
2134	struct ovs_net *ovs_net = net_generic(sock_net(skb->sk), ovs_net_id);
2135	struct ovs_ct_limit_info *ct_limit_info = ovs_net->ct_limit_info;
2136	int err;
2137
2138	reply = ovs_ct_limit_cmd_reply_start(info, OVS_CT_LIMIT_CMD_SET,
2139					     &ovs_reply_header);
2140	if (IS_ERR(reply))
2141		return PTR_ERR(reply);
2142
2143	if (!a[OVS_CT_LIMIT_ATTR_ZONE_LIMIT]) {
2144		err = -EINVAL;
2145		goto exit_err;
2146	}
2147
2148	err = ovs_ct_limit_set_zone_limit(a[OVS_CT_LIMIT_ATTR_ZONE_LIMIT],
2149					  ct_limit_info);
2150	if (err)
2151		goto exit_err;
2152
2153	static_branch_enable(&ovs_ct_limit_enabled);
2154
2155	genlmsg_end(reply, ovs_reply_header);
2156	return genlmsg_reply(reply, info);
2157
2158exit_err:
2159	nlmsg_free(reply);
2160	return err;
2161}
2162
2163static int ovs_ct_limit_cmd_del(struct sk_buff *skb, struct genl_info *info)
2164{
2165	struct nlattr **a = info->attrs;
2166	struct sk_buff *reply;
2167	struct ovs_header *ovs_reply_header;
2168	struct ovs_net *ovs_net = net_generic(sock_net(skb->sk), ovs_net_id);
2169	struct ovs_ct_limit_info *ct_limit_info = ovs_net->ct_limit_info;
2170	int err;
2171
2172	reply = ovs_ct_limit_cmd_reply_start(info, OVS_CT_LIMIT_CMD_DEL,
2173					     &ovs_reply_header);
2174	if (IS_ERR(reply))
2175		return PTR_ERR(reply);
2176
2177	if (!a[OVS_CT_LIMIT_ATTR_ZONE_LIMIT]) {
2178		err = -EINVAL;
2179		goto exit_err;
2180	}
2181
2182	err = ovs_ct_limit_del_zone_limit(a[OVS_CT_LIMIT_ATTR_ZONE_LIMIT],
2183					  ct_limit_info);
2184	if (err)
2185		goto exit_err;
2186
2187	genlmsg_end(reply, ovs_reply_header);
2188	return genlmsg_reply(reply, info);
2189
2190exit_err:
2191	nlmsg_free(reply);
2192	return err;
2193}
2194
2195static int ovs_ct_limit_cmd_get(struct sk_buff *skb, struct genl_info *info)
2196{
2197	struct nlattr **a = info->attrs;
2198	struct nlattr *nla_reply;
2199	struct sk_buff *reply;
2200	struct ovs_header *ovs_reply_header;
2201	struct net *net = sock_net(skb->sk);
2202	struct ovs_net *ovs_net = net_generic(net, ovs_net_id);
2203	struct ovs_ct_limit_info *ct_limit_info = ovs_net->ct_limit_info;
2204	int err;
2205
2206	reply = ovs_ct_limit_cmd_reply_start(info, OVS_CT_LIMIT_CMD_GET,
2207					     &ovs_reply_header);
2208	if (IS_ERR(reply))
2209		return PTR_ERR(reply);
2210
2211	nla_reply = nla_nest_start_noflag(reply, OVS_CT_LIMIT_ATTR_ZONE_LIMIT);
2212	if (!nla_reply) {
2213		err = -EMSGSIZE;
2214		goto exit_err;
2215	}
2216
2217	if (a[OVS_CT_LIMIT_ATTR_ZONE_LIMIT]) {
2218		err = ovs_ct_limit_get_zone_limit(
2219			net, a[OVS_CT_LIMIT_ATTR_ZONE_LIMIT], ct_limit_info,
2220			reply);
2221		if (err)
2222			goto exit_err;
2223	} else {
2224		err = ovs_ct_limit_get_all_zone_limit(net, ct_limit_info,
2225						      reply);
2226		if (err)
2227			goto exit_err;
2228	}
2229
2230	nla_nest_end(reply, nla_reply);
2231	genlmsg_end(reply, ovs_reply_header);
2232	return genlmsg_reply(reply, info);
2233
2234exit_err:
2235	nlmsg_free(reply);
2236	return err;
2237}
2238
2239static const struct genl_small_ops ct_limit_genl_ops[] = {
2240	{ .cmd = OVS_CT_LIMIT_CMD_SET,
2241		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
2242		.flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN
2243					   * privilege. */
 
2244		.doit = ovs_ct_limit_cmd_set,
2245	},
2246	{ .cmd = OVS_CT_LIMIT_CMD_DEL,
2247		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
2248		.flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN
2249					   * privilege. */
 
2250		.doit = ovs_ct_limit_cmd_del,
2251	},
2252	{ .cmd = OVS_CT_LIMIT_CMD_GET,
2253		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
2254		.flags = 0,		  /* OK for unprivileged users. */
2255		.doit = ovs_ct_limit_cmd_get,
2256	},
2257};
2258
2259static const struct genl_multicast_group ovs_ct_limit_multicast_group = {
2260	.name = OVS_CT_LIMIT_MCGROUP,
2261};
2262
2263struct genl_family dp_ct_limit_genl_family __ro_after_init = {
2264	.hdrsize = sizeof(struct ovs_header),
2265	.name = OVS_CT_LIMIT_FAMILY,
2266	.version = OVS_CT_LIMIT_VERSION,
2267	.maxattr = OVS_CT_LIMIT_ATTR_MAX,
2268	.policy = ct_limit_policy,
2269	.netnsok = true,
2270	.parallel_ops = true,
2271	.small_ops = ct_limit_genl_ops,
2272	.n_small_ops = ARRAY_SIZE(ct_limit_genl_ops),
 
2273	.mcgrps = &ovs_ct_limit_multicast_group,
2274	.n_mcgrps = 1,
2275	.module = THIS_MODULE,
2276};
2277#endif
2278
2279int ovs_ct_init(struct net *net)
2280{
2281	unsigned int n_bits = sizeof(struct ovs_key_ct_labels) * BITS_PER_BYTE;
2282	struct ovs_net *ovs_net = net_generic(net, ovs_net_id);
2283
2284	if (nf_connlabels_get(net, n_bits - 1)) {
2285		ovs_net->xt_label = false;
2286		OVS_NLERR(true, "Failed to set connlabel length");
2287	} else {
2288		ovs_net->xt_label = true;
2289	}
2290
2291#if	IS_ENABLED(CONFIG_NETFILTER_CONNCOUNT)
2292	return ovs_ct_limit_init(net, ovs_net);
2293#else
2294	return 0;
2295#endif
2296}
2297
2298void ovs_ct_exit(struct net *net)
2299{
 
2300	struct ovs_net *ovs_net = net_generic(net, ovs_net_id);
2301
2302#if	IS_ENABLED(CONFIG_NETFILTER_CONNCOUNT)
2303	ovs_ct_limit_exit(net, ovs_net);
2304#endif
2305
2306	if (ovs_net->xt_label)
2307		nf_connlabels_put(net);
2308}