lib/netfilter/log_obj.c

   1 /*
   2  * lib/netfilter/log_obj.c      Netfilter Log Object
   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-2006 Thomas Graf <tgraf@suug.ch>
  10  * Copyright (c) 2007 Philip Craig <philipc@snapgear.com>
  11  * Copyright (c) 2007 Secure Computing Corporation
  12  */
  13
  14 #include <netlink-local.h>
  15 #include <netlink/netfilter/nfnl.h>
  16 #include <netlink/netfilter/log.h>
  17
  18 /** @cond SKIP */
  19 #define LOG_ATTR_FAMILY                 (1UL << 0)
  20 #define LOG_ATTR_HWPROTO                (1UL << 1)
  21 #define LOG_ATTR_HOOK                   (1UL << 2)
  22 #define LOG_ATTR_MARK                   (1UL << 3)
  23 #define LOG_ATTR_TIMESTAMP              (1UL << 4)
  24 #define LOG_ATTR_INDEV                  (1UL << 5)
  25 #define LOG_ATTR_OUTDEV                 (1UL << 6)
  26 #define LOG_ATTR_PHYSINDEV              (1UL << 7)
  27 #define LOG_ATTR_PHYSOUTDEV             (1UL << 8)
  28 #define LOG_ATTR_HWADDR                 (1UL << 9)
  29 #define LOG_ATTR_PAYLOAD                (1UL << 10)
  30 #define LOG_ATTR_PREFIX                 (1UL << 11)
  31 #define LOG_ATTR_UID                    (1UL << 12)
  32 #define LOG_ATTR_SEQ                    (1UL << 13)
  33 #define LOG_ATTR_SEQ_GLOBAL             (1UL << 14)
  34 /** @endcond */
  35
  36 static void log_free_data(struct nl_object *c)
  37 {
  38         struct nfnl_log *log = (struct nfnl_log *) c;
  39
  40         if (log == NULL)
  41                 return;
  42
  43         free(log->log_payload);
  44         free(log->log_prefix);
  45 }
  46
  47 static int log_clone(struct nl_object *_dst, struct nl_object *_src)
  48 {
  49         struct nfnl_log *dst = (struct nfnl_log *) _dst;
  50         struct nfnl_log *src = (struct nfnl_log *) _src;
  51         int err;
  52
  53         if (src->log_payload) {
  54                 err = nfnl_log_set_payload(dst, src->log_payload,
  55                                            src->log_payload_len);
  56                 if (err < 0)
  57                         goto errout;
  58         }
  59
  60         if (src->log_prefix) {
  61                 err = nfnl_log_set_prefix(dst, src->log_prefix);
  62                 if (err < 0)
  63                         goto errout;
  64         }
  65
  66         return 0;
  67 errout:
  68         return err;
  69 }
  70
  71 static int log_dump(struct nl_object *a, struct nl_dump_params *p)
  72 {
  73         struct nfnl_log *log = (struct nfnl_log *) a;
  74         struct nl_cache *link_cache;
  75         char buf[64];
  76
  77         link_cache = nl_cache_mngt_require("route/link");
  78
  79         if (log->ce_mask & LOG_ATTR_PREFIX)
  80                 dp_dump(p, "%s", log->log_prefix);
  81
  82         if (log->ce_mask & LOG_ATTR_INDEV) {
  83                 if (link_cache)
  84                         dp_dump(p, "IN=%s ",
  85                                 rtnl_link_i2name(link_cache, log->log_indev,
  86                                                  buf, sizeof(buf)));
  87                 else
  88                         dp_dump(p, "IN=%d ", log->log_indev);
  89         }
  90
  91         if (log->ce_mask & LOG_ATTR_PHYSINDEV) {
  92                 if (link_cache)
  93                         dp_dump(p, "PHYSIN=%s ",
  94                                 rtnl_link_i2name(link_cache, log->log_physindev,
  95                                                  buf, sizeof(buf)));
  96                 else
  97                         dp_dump(p, "IN=%d ", log->log_physindev);
  98         }
  99
 100         if (log->ce_mask & LOG_ATTR_OUTDEV) {
 101                 if (link_cache)
 102                         dp_dump(p, "OUT=%s ",
 103                                 rtnl_link_i2name(link_cache, log->log_outdev,
 104                                                  buf, sizeof(buf)));
 105                 else
 106                         dp_dump(p, "OUT=%d ", log->log_outdev);
 107         }
 108
 109         if (log->ce_mask & LOG_ATTR_PHYSOUTDEV) {
 110                 if (link_cache)
 111                         dp_dump(p, "PHYSOUT=%s ",
 112                                 rtnl_link_i2name(link_cache,log->log_physoutdev,
 113                                                  buf, sizeof(buf)));
 114                 else
 115                         dp_dump(p, "PHYSOUT=%d ", log->log_physoutdev);
 116         }
 117
 118         if (log->ce_mask & LOG_ATTR_HWADDR) {
 119                 int i;
 120
 121                 dp_dump(p, "MAC");
 122                 for (i = 0; i < log->log_hwaddr_len; i++)
 123                         dp_dump(p, "%c%02x", i?':':'=', log->log_hwaddr[i]);
 124                 dp_dump(p, " ");
 125         }
 126
 127         /* FIXME: parse the payload to get iptables LOG compatible format */
 128
 129         if (log->ce_mask & LOG_ATTR_FAMILY)
 130                 dp_dump(p, "FAMILY=%s ",
 131                         nl_af2str(log->log_family, buf, sizeof(buf)));
 132
 133         if (log->ce_mask & LOG_ATTR_HWPROTO)
 134                 dp_dump(p, "HWPROTO=%s ",
 135                         nl_ether_proto2str(ntohs(log->log_hwproto),
 136                                            buf, sizeof(buf)));
 137
 138         if (log->ce_mask & LOG_ATTR_HOOK)
 139                 dp_dump(p, "HOOK=%d ", log->log_hook);
 140
 141         if (log->ce_mask & LOG_ATTR_MARK)
 142                 dp_dump(p, "MARK=%d ", log->log_mark);
 143
 144         if (log->ce_mask & LOG_ATTR_PAYLOAD)
 145                 dp_dump(p, "PAYLOADLEN=%d ", log->log_payload_len);
 146
 147         if (log->ce_mask & LOG_ATTR_SEQ)
 148                 dp_dump(p, "SEQ=%d ", log->log_seq);
 149
 150         if (log->ce_mask & LOG_ATTR_SEQ_GLOBAL)
 151                 dp_dump(p, "SEQGLOBAL=%d ", log->log_seq_global);
 152
 153         dp_dump(p, "\n");
 154
 155         return 1;
 156 }
 157
 158 /**
 159  * @name Allocation/Freeing
 160  * @{
 161  */
 162
 163 struct nfnl_log *nfnl_log_alloc(void)
 164 {
 165         return (struct nfnl_log *) nl_object_alloc(&log_obj_ops);
 166 }
 167
 168 void nfnl_log_get(struct nfnl_log *log)
 169 {
 170         nl_object_get((struct nl_object *) log);
 171 }
 172
 173 void nfnl_log_put(struct nfnl_log *log)
 174 {
 175         nl_object_put((struct nl_object *) log);
 176 }
 177
 178 /** @} */
 179
 180 /**
 181  * @name Attributes
 182  * @{
 183  */
 184
 185 void nfnl_log_set_family(struct nfnl_log *log, uint8_t family)
 186 {
 187         log->log_family = family;
 188         log->ce_mask |= LOG_ATTR_FAMILY;
 189 }
 190
 191 uint8_t nfnl_log_get_family(const struct nfnl_log *log)
 192 {
 193         if (log->ce_mask & LOG_ATTR_FAMILY)
 194                 return log->log_family;
 195         else
 196                 return AF_UNSPEC;
 197 }
 198
 199 void nfnl_log_set_hwproto(struct nfnl_log *log, uint16_t hwproto)
 200 {
 201         log->log_hwproto = hwproto;
 202         log->ce_mask |= LOG_ATTR_HWPROTO;
 203 }
 204
 205 int nfnl_log_test_hwproto(const struct nfnl_log *log)
 206 {
 207         return !!(log->ce_mask & LOG_ATTR_HWPROTO);
 208 }
 209
 210 uint16_t nfnl_log_get_hwproto(const struct nfnl_log *log)
 211 {
 212         return log->log_hwproto;
 213 }
 214
 215 void nfnl_log_set_hook(struct nfnl_log *log, uint8_t hook)
 216 {
 217         log->log_hook = hook;
 218         log->ce_mask |= LOG_ATTR_HOOK;
 219 }
 220
 221 int nfnl_log_test_hook(const struct nfnl_log *log)
 222 {
 223         return !!(log->ce_mask & LOG_ATTR_HOOK);
 224 }
 225
 226 uint8_t nfnl_log_get_hook(const struct nfnl_log *log)
 227 {
 228         return log->log_hook;
 229 }
 230
 231 void nfnl_log_set_mark(struct nfnl_log *log, uint32_t mark)
 232 {
 233         log->log_mark = mark;
 234         log->ce_mask |= LOG_ATTR_MARK;
 235 }
 236
 237 int nfnl_log_test_mark(const struct nfnl_log *log)
 238 {
 239         return !!(log->ce_mask & LOG_ATTR_MARK);
 240 }
 241
 242 uint32_t nfnl_log_get_mark(const struct nfnl_log *log)
 243 {
 244         return log->log_mark;
 245 }
 246
 247 void nfnl_log_set_timestamp(struct nfnl_log *log, struct timeval *tv)
 248 {
 249         log->log_timestamp.tv_sec = tv->tv_sec;
 250         log->log_timestamp.tv_usec = tv->tv_usec;
 251         log->ce_mask |= LOG_ATTR_TIMESTAMP;
 252 }
 253
 254 const struct timeval *nfnl_log_get_timestamp(const struct nfnl_log *log)
 255 {
 256         if (!(log->ce_mask & LOG_ATTR_TIMESTAMP))
 257                 return NULL;
 258         return &log->log_timestamp;
 259 }
 260
 261 void nfnl_log_set_indev(struct nfnl_log *log, uint32_t indev)
 262 {
 263         log->log_indev = indev;
 264         log->ce_mask |= LOG_ATTR_INDEV;
 265 }
 266
 267 uint32_t nfnl_log_get_indev(const struct nfnl_log *log)
 268 {
 269         return log->log_indev;
 270 }
 271
 272 void nfnl_log_set_outdev(struct nfnl_log *log, uint32_t outdev)
 273 {
 274         log->log_outdev = outdev;
 275         log->ce_mask |= LOG_ATTR_OUTDEV;
 276 }
 277
 278 uint32_t nfnl_log_get_outdev(const struct nfnl_log *log)
 279 {
 280         return log->log_outdev;
 281 }
 282
 283 void nfnl_log_set_physindev(struct nfnl_log *log, uint32_t physindev)
 284 {
 285         log->log_physindev = physindev;
 286         log->ce_mask |= LOG_ATTR_PHYSINDEV;
 287 }
 288
 289 uint32_t nfnl_log_get_physindev(const struct nfnl_log *log)
 290 {
 291         return log->log_physindev;
 292 }
 293
 294 void nfnl_log_set_physoutdev(struct nfnl_log *log, uint32_t physoutdev)
 295 {
 296         log->log_physoutdev = physoutdev;
 297         log->ce_mask |= LOG_ATTR_PHYSOUTDEV;
 298 }
 299
 300 uint32_t nfnl_log_get_physoutdev(const struct nfnl_log *log)
 301 {
 302         return log->log_physoutdev;
 303 }
 304
 305 void nfnl_log_set_hwaddr(struct nfnl_log *log, uint8_t *hwaddr, int len)
 306 {
 307         if (len > sizeof(log->log_hwaddr))
 308                 len = sizeof(log->log_hwaddr);
 309         log->log_hwaddr_len = len;
 310         memcpy(log->log_hwaddr, hwaddr, len);
 311         log->ce_mask |= LOG_ATTR_HWADDR;
 312 }
 313
 314 const uint8_t *nfnl_log_get_hwaddr(const struct nfnl_log *log, int *len)
 315 {
 316         if (!(log->ce_mask & LOG_ATTR_HWADDR)) {
 317                 *len = 0;
 318                 return NULL;
 319         }
 320
 321         *len = log->log_hwaddr_len;
 322         return log->log_hwaddr;
 323 }
 324
 325 int nfnl_log_set_payload(struct nfnl_log *log, uint8_t *payload, int len)
 326 {
 327         free(log->log_payload);
 328         log->log_payload = malloc(len);
 329         if (!log->log_payload)
 330                 return nl_errno(ENOMEM);
 331
 332         memcpy(log->log_payload, payload, len);
 333         log->log_payload_len = len;
 334         log->ce_mask |= LOG_ATTR_PAYLOAD;
 335         return 0;
 336 }
 337
 338 const void *nfnl_log_get_payload(const struct nfnl_log *log, int *len)
 339 {
 340         if (!(log->ce_mask & LOG_ATTR_PAYLOAD)) {
 341                 *len = 0;
 342                 return NULL;
 343         }
 344
 345         *len = log->log_payload_len;
 346         return log->log_payload;
 347 }
 348
 349 int nfnl_log_set_prefix(struct nfnl_log *log, void *prefix)
 350 {
 351         free(log->log_prefix);
 352         log->log_prefix = strdup(prefix);
 353         if (!log->log_prefix)
 354                 return nl_errno(ENOMEM);
 355
 356         log->ce_mask |= LOG_ATTR_PREFIX;
 357         return 0;
 358 }
 359
 360 const char *nfnl_log_get_prefix(const struct nfnl_log *log)
 361 {
 362         return log->log_prefix;
 363 }
 364
 365 void nfnl_log_set_uid(struct nfnl_log *log, uint32_t uid)
 366 {
 367         log->log_uid = uid;
 368         log->ce_mask |= LOG_ATTR_UID;
 369 }
 370
 371 int nfnl_log_test_uid(const struct nfnl_log *log)
 372 {
 373         return !!(log->ce_mask & LOG_ATTR_UID);
 374 }
 375
 376 uint32_t nfnl_log_get_uid(const struct nfnl_log *log)
 377 {
 378         return log->log_uid;
 379 }
 380
 381 void nfnl_log_set_seq(struct nfnl_log *log, uint32_t seq)
 382 {
 383         log->log_seq = seq;
 384         log->ce_mask |= LOG_ATTR_SEQ;
 385 }
 386
 387 int nfnl_log_test_seq(const struct nfnl_log *log)
 388 {
 389         return !!(log->ce_mask & LOG_ATTR_SEQ);
 390 }
 391
 392 uint32_t nfnl_log_get_seq(const struct nfnl_log *log)
 393 {
 394         return log->log_seq;
 395 }
 396
 397 void nfnl_log_set_seq_global(struct nfnl_log *log, uint32_t seq_global)
 398 {
 399         log->log_seq_global = seq_global;
 400         log->ce_mask |= LOG_ATTR_SEQ_GLOBAL;
 401 }
 402
 403 int nfnl_log_test_seq_global(const struct nfnl_log *log)
 404 {
 405         return !!(log->ce_mask & LOG_ATTR_SEQ_GLOBAL);
 406 }
 407
 408 uint32_t nfnl_log_get_seq_global(const struct nfnl_log *log)
 409 {
 410         return log->log_seq_global;
 411 }
 412
 413 /** @} */
 414
 415 struct nl_object_ops log_obj_ops = {
 416         .oo_name                = "netfilter/log",
 417         .oo_size                = sizeof(struct nfnl_log),
 418         .oo_free_data           = log_free_data,
 419         .oo_clone               = log_clone,
 420         .oo_dump[NL_DUMP_BRIEF] = log_dump,
 421         .oo_dump[NL_DUMP_FULL]  = log_dump,
 422         .oo_dump[NL_DUMP_STATS] = log_dump,
 423 };
 424
 425 /** @} */