← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libnl3/trusty

« back to all changes in this revision

Viewing changes to lib/netfilter/log.c

  • Committer: Bazaar Package Importer
  • Author(s): Heiko Stuebner
  • Date: 2011-05-21 19:25:13 UTC
  • Revision ID: james.westby@ubuntu.com-20110521192513-1ieyu9w9kym4bt16
Tags: upstream-3.0
Import upstream version 3.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/netfilter/log.c
 
1
/*
 
2
 * lib/netfilter/log.c  Netfilter Log
 
3
 *
 
4
 *      This library is free software; you can redistribute it and/or
 
5
 *      modify it under the terms of the GNU Lesser General Public
 
6
 *      License as published by the Free Software Foundation version 2.1
 
7
 *      of the License.
 
8
 *
 
9
 * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
 
10
 * Copyright (c) 2007 Philip Craig <philipc@snapgear.com>
 
11
 * Copyright (c) 2007 Secure Computing Corporation
 
12
 */
 
13
 
 
14
/**
 
15
 * @ingroup nfnl
 
16
 * @defgroup log Log
 
17
 * @brief
 
18
 * @{
 
19
 */
 
20
 
 
21
#include <sys/types.h>
 
22
#include <linux/netfilter/nfnetlink_log.h>
 
23
 
 
24
#include <netlink-local.h>
 
25
#include <netlink/attr.h>
 
26
#include <netlink/netfilter/nfnl.h>
 
27
#include <netlink/netfilter/log.h>
 
28
 
 
29
/**
 
30
 * @name Log Commands
 
31
 * @{
 
32
 */
 
33
 
 
34
static int build_log_cmd_request(uint8_t family, uint16_t queuenum,
 
35
                                 uint8_t command, struct nl_msg **result)
 
36
{
 
37
        struct nl_msg *msg;
 
38
        struct nfulnl_msg_config_cmd cmd;
 
39
 
 
40
        msg = nfnlmsg_alloc_simple(NFNL_SUBSYS_ULOG, NFULNL_MSG_CONFIG, 0,
 
41
                                   family, queuenum);
 
42
        if (msg == NULL)
 
43
                return -NLE_NOMEM;
 
44
 
 
45
        cmd.command = command;
 
46
        if (nla_put(msg, NFULA_CFG_CMD, sizeof(cmd), &cmd) < 0)
 
47
                goto nla_put_failure;
 
48
 
 
49
        *result = msg;
 
50
        return 0;
 
51
 
 
52
nla_put_failure:
 
53
        nlmsg_free(msg);
 
54
        return -NLE_MSGSIZE;
 
55
}
 
56
 
 
57
static int send_log_request(struct nl_sock *sk, struct nl_msg *msg)
 
58
{
 
59
        int err;
 
60
 
 
61
        err = nl_send_auto_complete(sk, msg);
 
62
        nlmsg_free(msg);
 
63
        if (err < 0)
 
64
                return err;
 
65
 
 
66
        return wait_for_ack(sk);
 
67
}
 
68
 
 
69
int nfnl_log_build_pf_bind(uint8_t pf, struct nl_msg **result)
 
70
{
 
71
        return build_log_cmd_request(pf, 0, NFULNL_CFG_CMD_PF_BIND, result);
 
72
}
 
73
 
 
74
int nfnl_log_pf_bind(struct nl_sock *nlh, uint8_t pf)
 
75
{
 
76
        struct nl_msg *msg;
 
77
        int err;
 
78
 
 
79
        if ((err = nfnl_log_build_pf_bind(pf, &msg)) < 0)
 
80
                return err;
 
81
 
 
82
        return send_log_request(nlh, msg);
 
83
}
 
84
 
 
85
int nfnl_log_build_pf_unbind(uint8_t pf, struct nl_msg **result)
 
86
{
 
87
        return build_log_cmd_request(pf, 0, NFULNL_CFG_CMD_PF_UNBIND, result);
 
88
}
 
89
 
 
90
int nfnl_log_pf_unbind(struct nl_sock *nlh, uint8_t pf)
 
91
{
 
92
        struct nl_msg *msg;
 
93
        int err;
 
94
 
 
95
        if ((err = nfnl_log_build_pf_unbind(pf, &msg)) < 0)
 
96
                return err;
 
97
 
 
98
        return send_log_request(nlh, msg);
 
99
}
 
100
 
 
101
static int nfnl_log_build_request(const struct nfnl_log *log,
 
102
                                  struct nl_msg **result)
 
103
{
 
104
        struct nl_msg *msg;
 
105
 
 
106
        if (!nfnl_log_test_group(log))
 
107
                return -NLE_MISSING_ATTR;
 
108
 
 
109
        msg = nfnlmsg_alloc_simple(NFNL_SUBSYS_ULOG, NFULNL_MSG_CONFIG, 0,
 
110
                                   0, nfnl_log_get_group(log));
 
111
        if (msg == NULL)
 
112
                return -NLE_NOMEM;
 
113
 
 
114
        /* This sucks. The nfnetlink_log interface always expects both
 
115
         * parameters to be present. Needs to be done properly.
 
116
         */
 
117
        if (nfnl_log_test_copy_mode(log)) {
 
118
                struct nfulnl_msg_config_mode mode;
 
119
 
 
120
                switch (nfnl_log_get_copy_mode(log)) {
 
121
                case NFNL_LOG_COPY_NONE:
 
122
                        mode.copy_mode = NFULNL_COPY_NONE;
 
123
                        break;
 
124
                case NFNL_LOG_COPY_META:
 
125
                        mode.copy_mode = NFULNL_COPY_META;
 
126
                        break;
 
127
                case NFNL_LOG_COPY_PACKET:
 
128
                        mode.copy_mode = NFULNL_COPY_PACKET;
 
129
                        break;
 
130
                }
 
131
                mode.copy_range = htonl(nfnl_log_get_copy_range(log));
 
132
                mode._pad = 0;
 
133
 
 
134
                if (nla_put(msg, NFULA_CFG_MODE, sizeof(mode), &mode) < 0)
 
135
                        goto nla_put_failure;
 
136
        }
 
137
 
 
138
        if (nfnl_log_test_flush_timeout(log) &&
 
139
            nla_put_u32(msg, NFULA_CFG_TIMEOUT,
 
140
                        htonl(nfnl_log_get_flush_timeout(log))) < 0)
 
141
                goto nla_put_failure;
 
142
 
 
143
        if (nfnl_log_test_alloc_size(log) &&
 
144
            nla_put_u32(msg, NFULA_CFG_NLBUFSIZ,
 
145
                        htonl(nfnl_log_get_alloc_size(log))) < 0)
 
146
                goto nla_put_failure;
 
147
 
 
148
        if (nfnl_log_test_queue_threshold(log) &&
 
149
            nla_put_u32(msg, NFULA_CFG_QTHRESH,
 
150
                        htonl(nfnl_log_get_queue_threshold(log))) < 0)
 
151
                goto nla_put_failure;
 
152
 
 
153
        *result = msg;
 
154
        return 0;
 
155
 
 
156
nla_put_failure:
 
157
        nlmsg_free(msg);
 
158
        return -NLE_MSGSIZE;
 
159
}
 
160
 
 
161
int nfnl_log_build_create_request(const struct nfnl_log *log,
 
162
                                  struct nl_msg **result)
 
163
{
 
164
        struct nfulnl_msg_config_cmd cmd;
 
165
        int err;
 
166
 
 
167
        if ((err = nfnl_log_build_request(log, result)) < 0)
 
168
                return err;
 
169
 
 
170
        cmd.command = NFULNL_CFG_CMD_BIND;
 
171
 
 
172
        if (nla_put(*result, NFULA_CFG_CMD, sizeof(cmd), &cmd) < 0)
 
173
                goto nla_put_failure;
 
174
 
 
175
        return 0;
 
176
 
 
177
nla_put_failure:
 
178
        nlmsg_free(*result);
 
179
        return -NLE_MSGSIZE;
 
180
}
 
181
 
 
182
int nfnl_log_create(struct nl_sock *nlh, const struct nfnl_log *log)
 
183
{
 
184
        struct nl_msg *msg;
 
185
        int err;
 
186
 
 
187
        if ((err = nfnl_log_build_create_request(log, &msg)) < 0)
 
188
                return err;
 
189
 
 
190
        return send_log_request(nlh, msg);
 
191
}
 
192
 
 
193
int nfnl_log_build_change_request(const struct nfnl_log *log,
 
194
                                  struct nl_msg **result)
 
195
{
 
196
        return nfnl_log_build_request(log, result);
 
197
}
 
198
 
 
199
int nfnl_log_change(struct nl_sock *nlh, const struct nfnl_log *log)
 
200
{
 
201
        struct nl_msg *msg;
 
202
        int err;
 
203
 
 
204
        if ((err = nfnl_log_build_change_request(log, &msg)) < 0)
 
205
                return err;
 
206
 
 
207
        return send_log_request(nlh, msg);
 
208
}
 
209
 
 
210
int nfnl_log_build_delete_request(const struct nfnl_log *log,
 
211
                                  struct nl_msg **result)
 
212
{
 
213
        if (!nfnl_log_test_group(log))
 
214
                return -NLE_MISSING_ATTR;
 
215
 
 
216
        return build_log_cmd_request(0, nfnl_log_get_group(log),
 
217
                                     NFULNL_CFG_CMD_UNBIND, result);
 
218
}
 
219
 
 
220
int nfnl_log_delete(struct nl_sock *nlh, const struct nfnl_log *log)
 
221
{
 
222
        struct nl_msg *msg;
 
223
        int err;
 
224
 
 
225
        if ((err = nfnl_log_build_delete_request(log, &msg)) < 0)
 
226
                return err;
 
227
 
 
228
        return send_log_request(nlh, msg);
 
229
}
 
230
 
 
231
/** @} */
 
232
 
 
233
static struct nl_cache_ops nfnl_log_ops = {
 
234
        .co_name                = "netfilter/log",
 
235
        .co_obj_ops             = &log_obj_ops,
 
236
        .co_msgtypes            = {
 
237
                END_OF_MSGTYPES_LIST,
 
238
        },
 
239
};
 
240
 
 
241
static void __init log_init(void)
 
242
{
 
243
        nl_cache_mngt_register(&nfnl_log_ops);
 
244
}
 
245
 
 
246
static void __exit log_exit(void)
 
247
{
 
248
        nl_cache_mngt_unregister(&nfnl_log_ops);
 
249
}
 
250
 
 
251
/** @} */