1/*
2 * Copyright (c) 2008-2009 Patrick McHardy <kaber@trash.net>
3 * Copyright (c) 2012-2014 Pablo Neira Ayuso <pablo@netfilter.org>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 *
9 * Development of this code funded by Astaro AG (http://www.astaro.com/)
10 */
11
12#include <linux/kernel.h>
13#include <linux/init.h>
14#include <linux/module.h>
15#include <linux/netlink.h>
16#include <linux/netfilter.h>
17#include <linux/netfilter/nf_tables.h>
18#include <net/netfilter/nf_tables.h>
19#include <net/netfilter/nf_log.h>
20#include <linux/netdevice.h>
21
22static const char *nft_log_null_prefix = "";
23
24struct nft_log {
25	struct nf_loginfo	loginfo;
26	char			*prefix;
27};
28
29static void nft_log_eval(const struct nft_expr *expr,
30			 struct nft_regs *regs,
31			 const struct nft_pktinfo *pkt)
32{
33	const struct nft_log *priv = nft_expr_priv(expr);
34	struct net *net = dev_net(pkt->in ? pkt->in : pkt->out);
35
36	nf_log_packet(net, pkt->ops->pf, pkt->ops->hooknum, pkt->skb, pkt->in,
37		      pkt->out, &priv->loginfo, "%s", priv->prefix);
38}
39
40static const struct nla_policy nft_log_policy[NFTA_LOG_MAX + 1] = {
41	[NFTA_LOG_GROUP]	= { .type = NLA_U16 },
42	[NFTA_LOG_PREFIX]	= { .type = NLA_STRING },
43	[NFTA_LOG_SNAPLEN]	= { .type = NLA_U32 },
44	[NFTA_LOG_QTHRESHOLD]	= { .type = NLA_U16 },
45	[NFTA_LOG_LEVEL]	= { .type = NLA_U32 },
46	[NFTA_LOG_FLAGS]	= { .type = NLA_U32 },
47};
48
49static int nft_log_init(const struct nft_ctx *ctx,
50			const struct nft_expr *expr,
51			const struct nlattr * const tb[])
52{
53	struct nft_log *priv = nft_expr_priv(expr);
54	struct nf_loginfo *li = &priv->loginfo;
55	const struct nlattr *nla;
56	int ret;
57
58	nla = tb[NFTA_LOG_PREFIX];
59	if (nla != NULL) {
60		priv->prefix = kmalloc(nla_len(nla) + 1, GFP_KERNEL);
61		if (priv->prefix == NULL)
62			return -ENOMEM;
63		nla_strlcpy(priv->prefix, nla, nla_len(nla) + 1);
64	} else {
65		priv->prefix = (char *)nft_log_null_prefix;
66	}
67
68	li->type = NF_LOG_TYPE_LOG;
69	if (tb[NFTA_LOG_LEVEL] != NULL &&
70	    tb[NFTA_LOG_GROUP] != NULL)
71		return -EINVAL;
72	if (tb[NFTA_LOG_GROUP] != NULL)
73		li->type = NF_LOG_TYPE_ULOG;
74
75	switch (li->type) {
76	case NF_LOG_TYPE_LOG:
77		if (tb[NFTA_LOG_LEVEL] != NULL) {
78			li->u.log.level =
79				ntohl(nla_get_be32(tb[NFTA_LOG_LEVEL]));
80		} else {
81			li->u.log.level = LOGLEVEL_WARNING;
82		}
83		if (tb[NFTA_LOG_FLAGS] != NULL) {
84			li->u.log.logflags =
85				ntohl(nla_get_be32(tb[NFTA_LOG_FLAGS]));
86		}
87		break;
88	case NF_LOG_TYPE_ULOG:
89		li->u.ulog.group = ntohs(nla_get_be16(tb[NFTA_LOG_GROUP]));
90		if (tb[NFTA_LOG_SNAPLEN] != NULL) {
91			li->u.ulog.copy_len =
92				ntohl(nla_get_be32(tb[NFTA_LOG_SNAPLEN]));
93		}
94		if (tb[NFTA_LOG_QTHRESHOLD] != NULL) {
95			li->u.ulog.qthreshold =
96				ntohs(nla_get_be16(tb[NFTA_LOG_QTHRESHOLD]));
97		}
98		break;
99	}
100
101	if (ctx->afi->family == NFPROTO_INET) {
102		ret = nf_logger_find_get(NFPROTO_IPV4, li->type);
103		if (ret < 0)
104			return ret;
105
106		ret = nf_logger_find_get(NFPROTO_IPV6, li->type);
107		if (ret < 0) {
108			nf_logger_put(NFPROTO_IPV4, li->type);
109			return ret;
110		}
111		return 0;
112	}
113
114	return nf_logger_find_get(ctx->afi->family, li->type);
115}
116
117static void nft_log_destroy(const struct nft_ctx *ctx,
118			    const struct nft_expr *expr)
119{
120	struct nft_log *priv = nft_expr_priv(expr);
121	struct nf_loginfo *li = &priv->loginfo;
122
123	if (priv->prefix != nft_log_null_prefix)
124		kfree(priv->prefix);
125
126	if (ctx->afi->family == NFPROTO_INET) {
127		nf_logger_put(NFPROTO_IPV4, li->type);
128		nf_logger_put(NFPROTO_IPV6, li->type);
129	} else {
130		nf_logger_put(ctx->afi->family, li->type);
131	}
132}
133
134static int nft_log_dump(struct sk_buff *skb, const struct nft_expr *expr)
135{
136	const struct nft_log *priv = nft_expr_priv(expr);
137	const struct nf_loginfo *li = &priv->loginfo;
138
139	if (priv->prefix != nft_log_null_prefix)
140		if (nla_put_string(skb, NFTA_LOG_PREFIX, priv->prefix))
141			goto nla_put_failure;
142	switch (li->type) {
143	case NF_LOG_TYPE_LOG:
144		if (nla_put_be32(skb, NFTA_LOG_LEVEL, htonl(li->u.log.level)))
145			goto nla_put_failure;
146
147		if (li->u.log.logflags) {
148			if (nla_put_be32(skb, NFTA_LOG_FLAGS,
149					 htonl(li->u.log.logflags)))
150				goto nla_put_failure;
151		}
152		break;
153	case NF_LOG_TYPE_ULOG:
154		if (nla_put_be16(skb, NFTA_LOG_GROUP, htons(li->u.ulog.group)))
155			goto nla_put_failure;
156
157		if (li->u.ulog.copy_len) {
158			if (nla_put_be32(skb, NFTA_LOG_SNAPLEN,
159					 htonl(li->u.ulog.copy_len)))
160				goto nla_put_failure;
161		}
162		if (li->u.ulog.qthreshold) {
163			if (nla_put_be16(skb, NFTA_LOG_QTHRESHOLD,
164					 htons(li->u.ulog.qthreshold)))
165				goto nla_put_failure;
166		}
167		break;
168	}
169	return 0;
170
171nla_put_failure:
172	return -1;
173}
174
175static struct nft_expr_type nft_log_type;
176static const struct nft_expr_ops nft_log_ops = {
177	.type		= &nft_log_type,
178	.size		= NFT_EXPR_SIZE(sizeof(struct nft_log)),
179	.eval		= nft_log_eval,
180	.init		= nft_log_init,
181	.destroy	= nft_log_destroy,
182	.dump		= nft_log_dump,
183};
184
185static struct nft_expr_type nft_log_type __read_mostly = {
186	.name		= "log",
187	.ops		= &nft_log_ops,
188	.policy		= nft_log_policy,
189	.maxattr	= NFTA_LOG_MAX,
190	.owner		= THIS_MODULE,
191};
192
193static int __init nft_log_module_init(void)
194{
195	return nft_register_expr(&nft_log_type);
196}
197
198static void __exit nft_log_module_exit(void)
199{
200	nft_unregister_expr(&nft_log_type);
201}
202
203module_init(nft_log_module_init);
204module_exit(nft_log_module_exit);
205
206MODULE_LICENSE("GPL");
207MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
208MODULE_ALIAS_NFT_EXPR("log");
209