00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #include <netlink-local.h>
00016 #include <netlink/netfilter/nfnl.h>
00017 #include <netlink/netfilter/log.h>
00018
00019
00020 #define LOG_ATTR_GROUP (1UL << 0)
00021 #define LOG_ATTR_COPY_MODE (1UL << 1)
00022 #define LOG_ATTR_COPY_RANGE (1UL << 3)
00023 #define LOG_ATTR_FLUSH_TIMEOUT (1UL << 4)
00024 #define LOG_ATTR_ALLOC_SIZE (1UL << 5)
00025 #define LOG_ATTR_QUEUE_THRESHOLD (1UL << 6)
00026
00027
00028
00029 static void nfnl_log_dump(struct nl_object *a, struct nl_dump_params *p)
00030 {
00031 struct nfnl_log *log = (struct nfnl_log *) a;
00032 char buf[64];
00033
00034 nl_new_line(p);
00035
00036 if (log->ce_mask & LOG_ATTR_GROUP)
00037 nl_dump(p, "group=%u ", log->log_group);
00038
00039 if (log->ce_mask & LOG_ATTR_COPY_MODE)
00040 nl_dump(p, "copy_mode=%s ",
00041 nfnl_log_copy_mode2str(log->log_copy_mode,
00042 buf, sizeof(buf)));
00043
00044 if (log->ce_mask & LOG_ATTR_COPY_RANGE)
00045 nl_dump(p, "copy_range=%u ", log->log_copy_range);
00046
00047 if (log->ce_mask & LOG_ATTR_FLUSH_TIMEOUT)
00048 nl_dump(p, "flush_timeout=%u ", log->log_flush_timeout);
00049
00050 if (log->ce_mask & LOG_ATTR_ALLOC_SIZE)
00051 nl_dump(p, "alloc_size=%u ", log->log_alloc_size);
00052
00053 if (log->ce_mask & LOG_ATTR_QUEUE_THRESHOLD)
00054 nl_dump(p, "queue_threshold=%u ", log->log_queue_threshold);
00055
00056 nl_dump(p, "\n");
00057 }
00058
00059 static const struct trans_tbl copy_modes[] = {
00060 __ADD(NFNL_LOG_COPY_NONE, none)
00061 __ADD(NFNL_LOG_COPY_META, meta)
00062 __ADD(NFNL_LOG_COPY_PACKET, packet)
00063 };
00064
00065 char *nfnl_log_copy_mode2str(enum nfnl_log_copy_mode copy_mode, char *buf,
00066 size_t len)
00067 {
00068 return __type2str(copy_mode, buf, len, copy_modes,
00069 ARRAY_SIZE(copy_modes));
00070 }
00071
00072 enum nfnl_log_copy_mode nfnl_log_str2copy_mode(const char *name)
00073 {
00074 return __str2type(name, copy_modes, ARRAY_SIZE(copy_modes));
00075 }
00076
00077
00078
00079
00080
00081
00082 struct nfnl_log *nfnl_log_alloc(void)
00083 {
00084 return (struct nfnl_log *) nl_object_alloc(&log_obj_ops);
00085 }
00086
00087 void nfnl_log_get(struct nfnl_log *log)
00088 {
00089 nl_object_get((struct nl_object *) log);
00090 }
00091
00092 void nfnl_log_put(struct nfnl_log *log)
00093 {
00094 nl_object_put((struct nl_object *) log);
00095 }
00096
00097
00098
00099
00100
00101
00102
00103
00104 void nfnl_log_set_group(struct nfnl_log *log, uint16_t group)
00105 {
00106 log->log_group = group;
00107 log->ce_mask |= LOG_ATTR_GROUP;
00108 }
00109
00110 int nfnl_log_test_group(const struct nfnl_log *log)
00111 {
00112 return !!(log->ce_mask & LOG_ATTR_GROUP);
00113 }
00114
00115 uint16_t nfnl_log_get_group(const struct nfnl_log *log)
00116 {
00117 return log->log_group;
00118 }
00119
00120 void nfnl_log_set_copy_mode(struct nfnl_log *log, enum nfnl_log_copy_mode mode)
00121 {
00122 log->log_copy_mode = mode;
00123 log->ce_mask |= LOG_ATTR_COPY_MODE;
00124 }
00125
00126 int nfnl_log_test_copy_mode(const struct nfnl_log *log)
00127 {
00128 return !!(log->ce_mask & LOG_ATTR_COPY_MODE);
00129 }
00130
00131 enum nfnl_log_copy_mode nfnl_log_get_copy_mode(const struct nfnl_log *log)
00132 {
00133 return log->log_copy_mode;
00134 }
00135
00136 void nfnl_log_set_copy_range(struct nfnl_log *log, uint32_t copy_range)
00137 {
00138 log->log_copy_range = copy_range;
00139 log->ce_mask |= LOG_ATTR_COPY_RANGE;
00140 }
00141
00142 int nfnl_log_test_copy_range(const struct nfnl_log *log)
00143 {
00144 return !!(log->ce_mask & LOG_ATTR_COPY_RANGE);
00145 }
00146
00147 uint32_t nfnl_log_get_copy_range(const struct nfnl_log *log)
00148 {
00149 return log->log_copy_range;
00150 }
00151
00152 void nfnl_log_set_flush_timeout(struct nfnl_log *log, uint32_t timeout)
00153 {
00154 log->log_flush_timeout = timeout;
00155 log->ce_mask |= LOG_ATTR_FLUSH_TIMEOUT;
00156 }
00157
00158 int nfnl_log_test_flush_timeout(const struct nfnl_log *log)
00159 {
00160 return !!(log->ce_mask & LOG_ATTR_FLUSH_TIMEOUT);
00161 }
00162
00163 uint32_t nfnl_log_get_flush_timeout(const struct nfnl_log *log)
00164 {
00165 return log->log_flush_timeout;
00166 }
00167
00168 void nfnl_log_set_alloc_size(struct nfnl_log *log, uint32_t alloc_size)
00169 {
00170 log->log_alloc_size = alloc_size;
00171 log->ce_mask |= LOG_ATTR_ALLOC_SIZE;
00172 }
00173
00174 int nfnl_log_test_alloc_size(const struct nfnl_log *log)
00175 {
00176 return !!(log->ce_mask & LOG_ATTR_ALLOC_SIZE);
00177 }
00178
00179 uint32_t nfnl_log_get_alloc_size(const struct nfnl_log *log)
00180 {
00181 return log->log_alloc_size;
00182 }
00183
00184 void nfnl_log_set_queue_threshold(struct nfnl_log *log, uint32_t threshold)
00185 {
00186 log->log_queue_threshold = threshold;
00187 log->ce_mask |= LOG_ATTR_QUEUE_THRESHOLD;
00188 }
00189
00190 int nfnl_log_test_queue_threshold(const struct nfnl_log *log)
00191 {
00192 return !!(log->ce_mask & LOG_ATTR_QUEUE_THRESHOLD);
00193 }
00194
00195 uint32_t nfnl_log_get_queue_threshold(const struct nfnl_log *log)
00196 {
00197 return log->log_queue_threshold;
00198 }
00199
00200
00201
00202
00203
00204
00205 void nfnl_log_set_flags(struct nfnl_log *log, unsigned int flags)
00206 {
00207 log->log_flags |= flags;
00208 log->log_flag_mask |= flags;
00209 }
00210
00211 void nfnl_log_unset_flags(struct nfnl_log *log, unsigned int flags)
00212 {
00213 log->log_flags &= ~flags;
00214 log->log_flag_mask |= flags;
00215 }
00216
00217 static const struct trans_tbl log_flags[] = {
00218 __ADD(NFNL_LOG_FLAG_SEQ, seq)
00219 __ADD(NFNL_LOG_FLAG_SEQ_GLOBAL, seq_global)
00220 };
00221
00222 char *nfnl_log_flags2str(unsigned int flags, char *buf, size_t len)
00223 {
00224 return __flags2str(flags, buf, len, log_flags, ARRAY_SIZE(log_flags));
00225 }
00226
00227 unsigned int nfnl_log_str2flags(const char *name)
00228 {
00229 return __str2flags(name, log_flags, ARRAY_SIZE(log_flags));
00230 }
00231
00232 static int nfnl_log_compare(struct nl_object *_a, struct nl_object *_b,
00233 uint32_t attrs, int flags)
00234 {
00235 struct nfnl_log *a = (struct nfnl_log *) _a;
00236 struct nfnl_log *b = (struct nfnl_log *) _b;
00237 int diff = 0;
00238
00239 #define NFNL_LOG_DIFF(ATTR, EXPR) \
00240 ATTR_DIFF(attrs, LOG_ATTR_##ATTR, a, b, EXPR)
00241 #define NFNL_LOG_DIFF_VAL(ATTR, FIELD) \
00242 NFNL_LOG_DIFF(ATTR, a->FIELD != b->FIELD)
00243
00244 diff |= NFNL_LOG_DIFF_VAL(GROUP, log_group);
00245 diff |= NFNL_LOG_DIFF_VAL(COPY_MODE, log_copy_mode);
00246 diff |= NFNL_LOG_DIFF_VAL(COPY_RANGE, log_copy_range);
00247 diff |= NFNL_LOG_DIFF_VAL(FLUSH_TIMEOUT, log_flush_timeout);
00248 diff |= NFNL_LOG_DIFF_VAL(ALLOC_SIZE, log_alloc_size);
00249 diff |= NFNL_LOG_DIFF_VAL(QUEUE_THRESHOLD, log_queue_threshold);
00250
00251 #undef NFNL_LOG_DIFF
00252 #undef NFNL_LOG_DIFF_VAL
00253
00254 return diff;
00255 }
00256
00257 static const struct trans_tbl nfnl_log_attrs[] = {
00258 __ADD(LOG_ATTR_GROUP, group)
00259 __ADD(LOG_ATTR_COPY_MODE, copy_mode)
00260 __ADD(LOG_ATTR_COPY_RANGE, copy_range)
00261 __ADD(LOG_ATTR_FLUSH_TIMEOUT, flush_timeout)
00262 __ADD(LOG_ATTR_ALLOC_SIZE, alloc_size)
00263 __ADD(LOG_ATTR_QUEUE_THRESHOLD, queue_threshold)
00264 };
00265
00266 static char *nfnl_log_attrs2str(int attrs, char *buf, size_t len)
00267 {
00268 return __flags2str(attrs, buf, len, nfnl_log_attrs,
00269 ARRAY_SIZE(nfnl_log_attrs));
00270 }
00271
00272
00273
00274 struct nl_object_ops log_obj_ops = {
00275 .oo_name = "netfilter/log",
00276 .oo_size = sizeof(struct nfnl_log),
00277 .oo_dump = {
00278 [NL_DUMP_LINE] = nfnl_log_dump,
00279 [NL_DUMP_DETAILS] = nfnl_log_dump,
00280 [NL_DUMP_STATS] = nfnl_log_dump,
00281 },
00282 .oo_compare = nfnl_log_compare,
00283 .oo_attrs2str = nfnl_log_attrs2str,
00284 .oo_id_attrs = LOG_ATTR_GROUP,
00285 };
00286
00287