SAFE public projects git trees. - safe/jmp/linux-2.6/blob - net/netfilter/nfnetlink_log.c

   1 /*
   2  * This is a module which is used for logging packets to userspace via
   3  * nfetlink.
   4  *
   5  * (C) 2005 by Harald Welte <laforge@netfilter.org>
   6  *
   7  * Based on the old ipv4-only ipt_ULOG.c:
   8  * (C) 2000-2004 by Harald Welte <laforge@netfilter.org>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13  */
  14 #include <linux/module.h>
  15 #include <linux/skbuff.h>
  16 #include <linux/init.h>
  17 #include <linux/ip.h>
  18 #include <linux/ipv6.h>
  19 #include <linux/netdevice.h>
  20 #include <linux/netfilter.h>
  21 #include <linux/netlink.h>
  22 #include <linux/netfilter/nfnetlink.h>
  23 #include <linux/netfilter/nfnetlink_log.h>
  24 #include <linux/spinlock.h>
  25 #include <linux/sysctl.h>
  26 #include <linux/proc_fs.h>
  27 #include <linux/security.h>
  28 #include <linux/list.h>
  29 #include <linux/jhash.h>
  30 #include <linux/random.h>
  31 #include <net/sock.h>
  32 #include <net/netfilter/nf_log.h>
  33
  34 #include <asm/atomic.h>
  35
  36 #ifdef CONFIG_BRIDGE_NETFILTER
  37 #include "../bridge/br_private.h"
  38 #endif
  39
  40 #define NFULNL_NLBUFSIZ_DEFAULT NLMSG_GOODSIZE
  41 #define NFULNL_TIMEOUT_DEFAULT  HZ      /* every second */
  42 #define NFULNL_QTHRESH_DEFAULT  100     /* 100 packets */
  43 #define NFULNL_COPY_RANGE_MAX   0xFFFF  /* max packet size is limited by 16-bit struct nfattr nfa_len field */
  44
  45 #define PRINTR(x, args...)      do { if (net_ratelimit()) \
  46                                      printk(x, ## args); } while (0);
  47
  48 struct nfulnl_instance {
  49         struct hlist_node hlist;        /* global list of instances */
  50         spinlock_t lock;
  51         atomic_t use;                   /* use count */
  52
  53         unsigned int qlen;              /* number of nlmsgs in skb */
  54         struct sk_buff *skb;            /* pre-allocatd skb */
  55         struct timer_list timer;
  56         int peer_pid;                   /* PID of the peer process */
  57
  58         /* configurable parameters */
  59         unsigned int flushtimeout;      /* timeout until queue flush */
  60         unsigned int nlbufsiz;          /* netlink buffer allocation size */
  61         unsigned int qthreshold;        /* threshold of the queue */
  62         u_int32_t copy_range;
  63         u_int32_t seq;                  /* instance-local sequential counter */
  64         u_int16_t group_num;            /* number of this queue */
  65         u_int16_t flags;
  66         u_int8_t copy_mode;
  67 };
  68
  69 static DEFINE_RWLOCK(instances_lock);
  70 static atomic_t global_seq;
  71
  72 #define INSTANCE_BUCKETS        16
  73 static struct hlist_head instance_table[INSTANCE_BUCKETS];
  74 static unsigned int hash_init;
  75
  76 static inline u_int8_t instance_hashfn(u_int16_t group_num)
  77 {
  78         return ((group_num & 0xff) % INSTANCE_BUCKETS);
  79 }
  80
  81 static struct nfulnl_instance *
  82 __instance_lookup(u_int16_t group_num)
  83 {
  84         struct hlist_head *head;
  85         struct hlist_node *pos;
  86         struct nfulnl_instance *inst;
  87
  88         head = &instance_table[instance_hashfn(group_num)];
  89         hlist_for_each_entry(inst, pos, head, hlist) {
  90                 if (inst->group_num == group_num)
  91                         return inst;
  92         }
  93         return NULL;
  94 }
  95
  96 static inline void
  97 instance_get(struct nfulnl_instance *inst)
  98 {
  99         atomic_inc(&inst->use);
 100 }
 101
 102 static struct nfulnl_instance *
 103 instance_lookup_get(u_int16_t group_num)
 104 {
 105         struct nfulnl_instance *inst;
 106
 107         read_lock_bh(&instances_lock);
 108         inst = __instance_lookup(group_num);
 109         if (inst)
 110                 instance_get(inst);
 111         read_unlock_bh(&instances_lock);
 112
 113         return inst;
 114 }
 115
 116 static void
 117 instance_put(struct nfulnl_instance *inst)
 118 {
 119         if (inst && atomic_dec_and_test(&inst->use)) {
 120                 kfree(inst);
 121                 module_put(THIS_MODULE);
 122         }
 123 }
 124
 125 static void nfulnl_timer(unsigned long data);
 126
 127 static struct nfulnl_instance *
 128 instance_create(u_int16_t group_num, int pid)
 129 {
 130         struct nfulnl_instance *inst;
 131
 132         write_lock_bh(&instances_lock);
 133         if (__instance_lookup(group_num)) {
 134                 inst = NULL;
 135                 goto out_unlock;
 136         }
 137
 138         inst = kzalloc(sizeof(*inst), GFP_ATOMIC);
 139         if (!inst)
 140                 goto out_unlock;
 141
 142         if (!try_module_get(THIS_MODULE)) {
 143                 kfree(inst);
 144                 goto out_unlock;
 145         }
 146
 147         INIT_HLIST_NODE(&inst->hlist);
 148         spin_lock_init(&inst->lock);
 149         /* needs to be two, since we _put() after creation */
 150         atomic_set(&inst->use, 2);
 151
 152         setup_timer(&inst->timer, nfulnl_timer, (unsigned long)inst);
 153
 154         inst->peer_pid = pid;
 155         inst->group_num = group_num;
 156
 157         inst->qthreshold        = NFULNL_QTHRESH_DEFAULT;
 158         inst->flushtimeout      = NFULNL_TIMEOUT_DEFAULT;
 159         inst->nlbufsiz          = NFULNL_NLBUFSIZ_DEFAULT;
 160         inst->copy_mode         = NFULNL_COPY_PACKET;
 161         inst->copy_range        = NFULNL_COPY_RANGE_MAX;
 162
 163         hlist_add_head(&inst->hlist,
 164                        &instance_table[instance_hashfn(group_num)]);
 165
 166         write_unlock_bh(&instances_lock);
 167
 168         return inst;
 169
 170 out_unlock:
 171         write_unlock_bh(&instances_lock);
 172         return NULL;
 173 }
 174
 175 static void __nfulnl_flush(struct nfulnl_instance *inst);
 176
 177 static void
 178 __instance_destroy(struct nfulnl_instance *inst)
 179 {
 180         /* first pull it out of the global list */
 181         hlist_del(&inst->hlist);
 182
 183         /* then flush all pending packets from skb */
 184
 185         spin_lock_bh(&inst->lock);
 186         if (inst->skb)
 187                 __nfulnl_flush(inst);
 188         spin_unlock_bh(&inst->lock);
 189
 190         /* and finally put the refcount */
 191         instance_put(inst);
 192 }
 193
 194 static inline void
 195 instance_destroy(struct nfulnl_instance *inst)
 196 {
 197         write_lock_bh(&instances_lock);
 198         __instance_destroy(inst);
 199         write_unlock_bh(&instances_lock);
 200 }
 201
 202 static int
 203 nfulnl_set_mode(struct nfulnl_instance *inst, u_int8_t mode,
 204                   unsigned int range)
 205 {
 206         int status = 0;
 207
 208         spin_lock_bh(&inst->lock);
 209
 210         switch (mode) {
 211         case NFULNL_COPY_NONE:
 212         case NFULNL_COPY_META:
 213                 inst->copy_mode = mode;
 214                 inst->copy_range = 0;
 215                 break;
 216
 217         case NFULNL_COPY_PACKET:
 218                 inst->copy_mode = mode;
 219                 inst->copy_range = min_t(unsigned int,
 220                                          range, NFULNL_COPY_RANGE_MAX);
 221                 break;
 222
 223         default:
 224                 status = -EINVAL;
 225                 break;
 226         }
 227
 228         spin_unlock_bh(&inst->lock);
 229
 230         return status;
 231 }
 232
 233 static int
 234 nfulnl_set_nlbufsiz(struct nfulnl_instance *inst, u_int32_t nlbufsiz)
 235 {
 236         int status;
 237
 238         spin_lock_bh(&inst->lock);
 239         if (nlbufsiz < NFULNL_NLBUFSIZ_DEFAULT)
 240                 status = -ERANGE;
 241         else if (nlbufsiz > 131072)
 242                 status = -ERANGE;
 243         else {
 244                 inst->nlbufsiz = nlbufsiz;
 245                 status = 0;
 246         }
 247         spin_unlock_bh(&inst->lock);
 248
 249         return status;
 250 }
 251
 252 static int
 253 nfulnl_set_timeout(struct nfulnl_instance *inst, u_int32_t timeout)
 254 {
 255         spin_lock_bh(&inst->lock);
 256         inst->flushtimeout = timeout;
 257         spin_unlock_bh(&inst->lock);
 258
 259         return 0;
 260 }
 261
 262 static int
 263 nfulnl_set_qthresh(struct nfulnl_instance *inst, u_int32_t qthresh)
 264 {
 265         spin_lock_bh(&inst->lock);
 266         inst->qthreshold = qthresh;
 267         spin_unlock_bh(&inst->lock);
 268
 269         return 0;
 270 }
 271
 272 static int
 273 nfulnl_set_flags(struct nfulnl_instance *inst, u_int16_t flags)
 274 {
 275         spin_lock_bh(&inst->lock);
 276         inst->flags = flags;
 277         spin_unlock_bh(&inst->lock);
 278
 279         return 0;
 280 }
 281
 282 static struct sk_buff *
 283 nfulnl_alloc_skb(unsigned int inst_size, unsigned int pkt_size)
 284 {
 285         struct sk_buff *skb;
 286         unsigned int n;
 287
 288         /* alloc skb which should be big enough for a whole multipart
 289          * message.  WARNING: has to be <= 128k due to slab restrictions */
 290
 291         n = max(inst_size, pkt_size);
 292         skb = alloc_skb(n, GFP_ATOMIC);
 293         if (!skb) {
 294                 PRINTR("nfnetlink_log: can't alloc whole buffer (%u bytes)\n",
 295                         inst_size);
 296
 297                 if (n > pkt_size) {
 298                         /* try to allocate only as much as we need for current
 299                          * packet */
 300
 301                         skb = alloc_skb(pkt_size, GFP_ATOMIC);
 302                         if (!skb)
 303                                 PRINTR("nfnetlink_log: can't even alloc %u "
 304                                        "bytes\n", pkt_size);
 305                 }
 306         }
 307
 308         return skb;
 309 }
 310
 311 static int
 312 __nfulnl_send(struct nfulnl_instance *inst)
 313 {
 314         int status = -1;
 315
 316         if (inst->qlen > 1)
 317                 NLMSG_PUT(inst->skb, 0, 0,
 318                           NLMSG_DONE,
 319                           sizeof(struct nfgenmsg));
 320
 321         status = nfnetlink_unicast(inst->skb, inst->peer_pid, MSG_DONTWAIT);
 322
 323         inst->qlen = 0;
 324         inst->skb = NULL;
 325
 326 nlmsg_failure:
 327         return status;
 328 }
 329
 330 static void
 331 __nfulnl_flush(struct nfulnl_instance *inst)
 332 {
 333         /* timer holds a reference */
 334         if (del_timer(&inst->timer))
 335                 instance_put(inst);
 336         if (inst->skb)
 337                 __nfulnl_send(inst);
 338 }
 339
 340 static void
 341 nfulnl_timer(unsigned long data)
 342 {
 343         struct nfulnl_instance *inst = (struct nfulnl_instance *)data;
 344
 345         spin_lock_bh(&inst->lock);
 346         if (inst->skb)
 347                 __nfulnl_send(inst);
 348         spin_unlock_bh(&inst->lock);
 349         instance_put(inst);
 350 }
 351
 352 /* This is an inline function, we don't really care about a long
 353  * list of arguments */
 354 static inline int
 355 __build_packet_message(struct nfulnl_instance *inst,
 356                         const struct sk_buff *skb,
 357                         unsigned int data_len,
 358                         unsigned int pf,
 359                         unsigned int hooknum,
 360                         const struct net_device *indev,
 361                         const struct net_device *outdev,
 362                         const struct nf_loginfo *li,
 363                         const char *prefix, unsigned int plen)
 364 {
 365         struct nfulnl_msg_packet_hdr pmsg;
 366         struct nlmsghdr *nlh;
 367         struct nfgenmsg *nfmsg;
 368         __be32 tmp_uint;
 369         sk_buff_data_t old_tail = inst->skb->tail;
 370
 371         nlh = NLMSG_PUT(inst->skb, 0, 0,
 372                         NFNL_SUBSYS_ULOG << 8 | NFULNL_MSG_PACKET,
 373                         sizeof(struct nfgenmsg));
 374         nfmsg = NLMSG_DATA(nlh);
 375         nfmsg->nfgen_family = pf;
 376         nfmsg->version = NFNETLINK_V0;
 377         nfmsg->res_id = htons(inst->group_num);
 378
 379         pmsg.hw_protocol        = skb->protocol;
 380         pmsg.hook               = hooknum;
 381
 382         NLA_PUT(inst->skb, NFULA_PACKET_HDR, sizeof(pmsg), &pmsg);
 383
 384         if (prefix)
 385                 NLA_PUT(inst->skb, NFULA_PREFIX, plen, prefix);
 386
 387         if (indev) {
 388                 tmp_uint = htonl(indev->ifindex);
 389 #ifndef CONFIG_BRIDGE_NETFILTER
 390                 NLA_PUT(inst->skb, NFULA_IFINDEX_INDEV, sizeof(tmp_uint),
 391                         &tmp_uint);
 392 #else
 393                 if (pf == PF_BRIDGE) {
 394                         /* Case 1: outdev is physical input device, we need to
 395                          * look for bridge group (when called from
 396                          * netfilter_bridge) */
 397                         NLA_PUT(inst->skb, NFULA_IFINDEX_PHYSINDEV,
 398                                 sizeof(tmp_uint), &tmp_uint);
 399                         /* this is the bridge group "brX" */
 400                         tmp_uint = htonl(indev->br_port->br->dev->ifindex);
 401                         NLA_PUT(inst->skb, NFULA_IFINDEX_INDEV,
 402                                 sizeof(tmp_uint), &tmp_uint);
 403                 } else {
 404                         /* Case 2: indev is bridge group, we need to look for
 405                          * physical device (when called from ipv4) */
 406                         NLA_PUT(inst->skb, NFULA_IFINDEX_INDEV,
 407                                 sizeof(tmp_uint), &tmp_uint);
 408                         if (skb->nf_bridge && skb->nf_bridge->physindev) {
 409                                 tmp_uint =
 410                                     htonl(skb->nf_bridge->physindev->ifindex);
 411                                 NLA_PUT(inst->skb, NFULA_IFINDEX_PHYSINDEV,
 412                                         sizeof(tmp_uint), &tmp_uint);
 413                         }
 414                 }
 415 #endif
 416         }
 417
 418         if (outdev) {
 419                 tmp_uint = htonl(outdev->ifindex);
 420 #ifndef CONFIG_BRIDGE_NETFILTER
 421                 NLA_PUT(inst->skb, NFULA_IFINDEX_OUTDEV, sizeof(tmp_uint),
 422                         &tmp_uint);
 423 #else
 424                 if (pf == PF_BRIDGE) {
 425                         /* Case 1: outdev is physical output device, we need to
 426                          * look for bridge group (when called from
 427                          * netfilter_bridge) */
 428                         NLA_PUT(inst->skb, NFULA_IFINDEX_PHYSOUTDEV,
 429                                 sizeof(tmp_uint), &tmp_uint);
 430                         /* this is the bridge group "brX" */
 431                         tmp_uint = htonl(outdev->br_port->br->dev->ifindex);
 432                         NLA_PUT(inst->skb, NFULA_IFINDEX_OUTDEV,
 433                                 sizeof(tmp_uint), &tmp_uint);
 434                 } else {
 435                         /* Case 2: indev is a bridge group, we need to look
 436                          * for physical device (when called from ipv4) */
 437                         NLA_PUT(inst->skb, NFULA_IFINDEX_OUTDEV,
 438                                 sizeof(tmp_uint), &tmp_uint);
 439                         if (skb->nf_bridge && skb->nf_bridge->physoutdev) {
 440                                 tmp_uint =
 441                                     htonl(skb->nf_bridge->physoutdev->ifindex);
 442                                 NLA_PUT(inst->skb, NFULA_IFINDEX_PHYSOUTDEV,
 443                                         sizeof(tmp_uint), &tmp_uint);
 444                         }
 445                 }
 446 #endif
 447         }
 448
 449         if (skb->mark) {
 450                 tmp_uint = htonl(skb->mark);
 451                 NLA_PUT(inst->skb, NFULA_MARK, sizeof(tmp_uint), &tmp_uint);
 452         }
 453
 454         if (indev && skb->dev) {
 455                 struct nfulnl_msg_packet_hw phw;
 456                 int len = dev_parse_header(skb, phw.hw_addr);
 457                 if (len > 0) {
 458                         phw.hw_addrlen = htons(len);
 459                         NLA_PUT(inst->skb, NFULA_HWADDR, sizeof(phw), &phw);
 460                 }
 461         }
 462
 463         if (skb->tstamp.tv64) {
 464                 struct nfulnl_msg_packet_timestamp ts;
 465                 struct timeval tv = ktime_to_timeval(skb->tstamp);
 466                 ts.sec = cpu_to_be64(tv.tv_sec);
 467                 ts.usec = cpu_to_be64(tv.tv_usec);
 468
 469                 NLA_PUT(inst->skb, NFULA_TIMESTAMP, sizeof(ts), &ts);
 470         }
 471
 472         /* UID */
 473         if (skb->sk) {
 474                 read_lock_bh(&skb->sk->sk_callback_lock);
 475                 if (skb->sk->sk_socket && skb->sk->sk_socket->file) {
 476                         __be32 uid = htonl(skb->sk->sk_socket->file->f_uid);
 477                         /* need to unlock here since NLA_PUT may goto */
 478                         read_unlock_bh(&skb->sk->sk_callback_lock);
 479                         NLA_PUT(inst->skb, NFULA_UID, sizeof(uid), &uid);
 480                 } else
 481                         read_unlock_bh(&skb->sk->sk_callback_lock);
 482         }
 483
 484         /* local sequence number */
 485         if (inst->flags & NFULNL_CFG_F_SEQ) {
 486                 tmp_uint = htonl(inst->seq++);
 487                 NLA_PUT(inst->skb, NFULA_SEQ, sizeof(tmp_uint), &tmp_uint);
 488         }
 489         /* global sequence number */
 490         if (inst->flags & NFULNL_CFG_F_SEQ_GLOBAL) {
 491                 tmp_uint = htonl(atomic_inc_return(&global_seq));
 492                 NLA_PUT(inst->skb, NFULA_SEQ_GLOBAL, sizeof(tmp_uint), &tmp_uint);
 493         }
 494
 495         if (data_len) {
 496                 struct nlattr *nla;
 497                 int size = nla_attr_size(data_len);
 498
 499                 if (skb_tailroom(inst->skb) < nla_total_size(data_len)) {
 500                         printk(KERN_WARNING "nfnetlink_log: no tailroom!\n");
 501                         goto nlmsg_failure;
 502                 }
 503
 504                 nla = (struct nlattr *)skb_put(inst->skb, nla_total_size(data_len));
 505                 nla->nla_type = NFULA_PAYLOAD;
 506                 nla->nla_len = size;
 507
 508                 if (skb_copy_bits(skb, 0, nla_data(nla), data_len))
 509                         BUG();
 510         }
 511
 512         nlh->nlmsg_len = inst->skb->tail - old_tail;
 513         return 0;
 514
 515 nlmsg_failure:
 516 nla_put_failure:
 517         PRINTR(KERN_ERR "nfnetlink_log: error creating log nlmsg\n");
 518         return -1;
 519 }
 520
 521 #define RCV_SKB_FAIL(err) do { netlink_ack(skb, nlh, (err)); return; } while (0)
 522
 523 static struct nf_loginfo default_loginfo = {
 524         .type =         NF_LOG_TYPE_ULOG,
 525         .u = {
 526                 .ulog = {
 527                         .copy_len       = 0xffff,
 528                         .group          = 0,
 529                         .qthreshold     = 1,
 530                 },
 531         },
 532 };
 533
 534 /* log handler for internal netfilter logging api */
 535 static void
 536 nfulnl_log_packet(unsigned int pf,
 537                   unsigned int hooknum,
 538                   const struct sk_buff *skb,
 539                   const struct net_device *in,
 540                   const struct net_device *out,
 541                   const struct nf_loginfo *li_user,
 542                   const char *prefix)
 543 {
 544         unsigned int size, data_len;
 545         struct nfulnl_instance *inst;
 546         const struct nf_loginfo *li;
 547         unsigned int qthreshold;
 548         unsigned int plen;
 549
 550         if (li_user && li_user->type == NF_LOG_TYPE_ULOG)
 551                 li = li_user;
 552         else
 553                 li = &default_loginfo;
 554
 555         inst = instance_lookup_get(li->u.ulog.group);
 556         if (!inst)
 557                 return;
 558
 559         plen = 0;
 560         if (prefix)
 561                 plen = strlen(prefix) + 1;
 562
 563         /* FIXME: do we want to make the size calculation conditional based on
 564          * what is actually present?  way more branches and checks, but more
 565          * memory efficient... */
 566         size =    NLMSG_ALIGN(sizeof(struct nfgenmsg))
 567                 + nla_total_size(sizeof(struct nfulnl_msg_packet_hdr))
 568                 + nla_total_size(sizeof(u_int32_t))     /* ifindex */
 569                 + nla_total_size(sizeof(u_int32_t))     /* ifindex */
 570 #ifdef CONFIG_BRIDGE_NETFILTER
 571                 + nla_total_size(sizeof(u_int32_t))     /* ifindex */
 572                 + nla_total_size(sizeof(u_int32_t))     /* ifindex */
 573 #endif
 574                 + nla_total_size(sizeof(u_int32_t))     /* mark */
 575                 + nla_total_size(sizeof(u_int32_t))     /* uid */
 576                 + nla_total_size(plen)                  /* prefix */
 577                 + nla_total_size(sizeof(struct nfulnl_msg_packet_hw))
 578                 + nla_total_size(sizeof(struct nfulnl_msg_packet_timestamp));
 579
 580         spin_lock_bh(&inst->lock);
 581
 582         if (inst->flags & NFULNL_CFG_F_SEQ)
 583                 size += nla_total_size(sizeof(u_int32_t));
 584         if (inst->flags & NFULNL_CFG_F_SEQ_GLOBAL)
 585                 size += nla_total_size(sizeof(u_int32_t));
 586
 587         qthreshold = inst->qthreshold;
 588         /* per-rule qthreshold overrides per-instance */
 589         if (qthreshold > li->u.ulog.qthreshold)
 590                 qthreshold = li->u.ulog.qthreshold;
 591
 592         switch (inst->copy_mode) {
 593         case NFULNL_COPY_META:
 594         case NFULNL_COPY_NONE:
 595                 data_len = 0;
 596                 break;
 597
 598         case NFULNL_COPY_PACKET:
 599                 if (inst->copy_range == 0
 600                     || inst->copy_range > skb->len)
 601                         data_len = skb->len;
 602                 else
 603                         data_len = inst->copy_range;
 604
 605                 size += nla_total_size(data_len);
 606                 break;
 607
 608         default:
 609                 goto unlock_and_release;
 610         }
 611
 612         if (inst->skb &&
 613             size > skb_tailroom(inst->skb) - sizeof(struct nfgenmsg)) {
 614                 /* either the queue len is too high or we don't have
 615                  * enough room in the skb left. flush to userspace. */
 616                 __nfulnl_flush(inst);
 617         }
 618
 619         if (!inst->skb) {
 620                 inst->skb = nfulnl_alloc_skb(inst->nlbufsiz, size);
 621                 if (!inst->skb)
 622                         goto alloc_failure;
 623         }
 624
 625         inst->qlen++;
 626
 627         __build_packet_message(inst, skb, data_len, pf,
 628                                 hooknum, in, out, li, prefix, plen);
 629
 630         if (inst->qlen >= qthreshold)
 631                 __nfulnl_flush(inst);
 632         /* timer_pending always called within inst->lock, so there
 633          * is no chance of a race here */
 634         else if (!timer_pending(&inst->timer)) {
 635                 instance_get(inst);
 636                 inst->timer.expires = jiffies + (inst->flushtimeout*HZ/100);
 637                 add_timer(&inst->timer);
 638         }
 639
 640 unlock_and_release:
 641         spin_unlock_bh(&inst->lock);
 642         instance_put(inst);
 643         return;
 644
 645 alloc_failure:
 646         /* FIXME: statistics */
 647         goto unlock_and_release;
 648 }
 649
 650 static int
 651 nfulnl_rcv_nl_event(struct notifier_block *this,
 652                    unsigned long event, void *ptr)
 653 {
 654         struct netlink_notify *n = ptr;
 655
 656         if (event == NETLINK_URELEASE &&
 657             n->protocol == NETLINK_NETFILTER && n->pid) {
 658                 int i;
 659
 660                 /* destroy all instances for this pid */
 661                 write_lock_bh(&instances_lock);
 662                 for  (i = 0; i < INSTANCE_BUCKETS; i++) {
 663                         struct hlist_node *tmp, *t2;
 664                         struct nfulnl_instance *inst;
 665                         struct hlist_head *head = &instance_table[i];
 666
 667                         hlist_for_each_entry_safe(inst, tmp, t2, head, hlist) {
 668                                 if ((n->net == &init_net) &&
 669                                     (n->pid == inst->peer_pid))
 670                                         __instance_destroy(inst);
 671                         }
 672                 }
 673                 write_unlock_bh(&instances_lock);
 674         }
 675         return NOTIFY_DONE;
 676 }
 677
 678 static struct notifier_block nfulnl_rtnl_notifier = {
 679         .notifier_call  = nfulnl_rcv_nl_event,
 680 };
 681
 682 static int
 683 nfulnl_recv_unsupp(struct sock *ctnl, struct sk_buff *skb,
 684                   struct nlmsghdr *nlh, struct nlattr *nfqa[])
 685 {
 686         return -ENOTSUPP;
 687 }
 688
 689 static const struct nf_logger nfulnl_logger = {
 690         .name   = "nfnetlink_log",
 691         .logfn  = &nfulnl_log_packet,
 692         .me     = THIS_MODULE,
 693 };
 694
 695 static const struct nla_policy nfula_cfg_policy[NFULA_CFG_MAX+1] = {
 696         [NFULA_CFG_CMD]         = { .len = sizeof(struct nfulnl_msg_config_cmd) },
 697         [NFULA_CFG_MODE]        = { .len = sizeof(struct nfulnl_msg_config_mode) },
 698         [NFULA_CFG_TIMEOUT]     = { .type = NLA_U32 },
 699         [NFULA_CFG_QTHRESH]     = { .type = NLA_U32 },
 700         [NFULA_CFG_NLBUFSIZ]    = { .type = NLA_U32 },
 701         [NFULA_CFG_FLAGS]       = { .type = NLA_U16 },
 702 };
 703
 704 static int
 705 nfulnl_recv_config(struct sock *ctnl, struct sk_buff *skb,
 706                    struct nlmsghdr *nlh, struct nlattr *nfula[])
 707 {
 708         struct nfgenmsg *nfmsg = NLMSG_DATA(nlh);
 709         u_int16_t group_num = ntohs(nfmsg->res_id);
 710         struct nfulnl_instance *inst;
 711         int ret = 0;
 712
 713         inst = instance_lookup_get(group_num);
 714         if (inst && inst->peer_pid != NETLINK_CB(skb).pid) {
 715                 ret = -EPERM;
 716                 goto out_put;
 717         }
 718
 719         if (nfula[NFULA_CFG_CMD]) {
 720                 u_int8_t pf = nfmsg->nfgen_family;
 721                 struct nfulnl_msg_config_cmd *cmd;
 722
 723                 cmd = nla_data(nfula[NFULA_CFG_CMD]);
 724
 725                 switch (cmd->command) {
 726                 case NFULNL_CFG_CMD_BIND:
 727                         if (inst) {
 728                                 ret = -EBUSY;
 729                                 goto out_put;
 730                         }
 731
 732                         inst = instance_create(group_num,
 733                                                NETLINK_CB(skb).pid);
 734                         if (!inst) {
 735                                 ret = -EINVAL;
 736                                 goto out;
 737                         }
 738                         break;
 739                 case NFULNL_CFG_CMD_UNBIND:
 740                         if (!inst) {
 741                                 ret = -ENODEV;
 742                                 goto out;
 743                         }
 744
 745                         instance_destroy(inst);
 746                         goto out;
 747                 case NFULNL_CFG_CMD_PF_BIND:
 748                         ret = nf_log_register(pf, &nfulnl_logger);
 749                         break;
 750                 case NFULNL_CFG_CMD_PF_UNBIND:
 751                         /* This is a bug and a feature.  We cannot unregister
 752                          * other handlers, like nfnetlink_inst can */
 753                         nf_log_unregister_pf(pf);
 754                         break;
 755                 default:
 756                         ret = -ENOTSUPP;
 757                         break;
 758                 }
 759         }
 760
 761         if (nfula[NFULA_CFG_MODE]) {
 762                 struct nfulnl_msg_config_mode *params;
 763                 params = nla_data(nfula[NFULA_CFG_MODE]);
 764
 765                 if (!inst) {
 766                         ret = -ENODEV;
 767                         goto out;
 768                 }
 769                 nfulnl_set_mode(inst, params->copy_mode,
 770                                 ntohl(params->copy_range));
 771         }
 772
 773         if (nfula[NFULA_CFG_TIMEOUT]) {
 774                 __be32 timeout =
 775                         *(__be32 *)nla_data(nfula[NFULA_CFG_TIMEOUT]);
 776
 777                 if (!inst) {
 778                         ret = -ENODEV;
 779                         goto out;
 780                 }
 781                 nfulnl_set_timeout(inst, ntohl(timeout));
 782         }
 783
 784         if (nfula[NFULA_CFG_NLBUFSIZ]) {
 785                 __be32 nlbufsiz =
 786                         *(__be32 *)nla_data(nfula[NFULA_CFG_NLBUFSIZ]);
 787
 788                 if (!inst) {
 789                         ret = -ENODEV;
 790                         goto out;
 791                 }
 792                 nfulnl_set_nlbufsiz(inst, ntohl(nlbufsiz));
 793         }
 794
 795         if (nfula[NFULA_CFG_QTHRESH]) {
 796                 __be32 qthresh =
 797                         *(__be32 *)nla_data(nfula[NFULA_CFG_QTHRESH]);
 798
 799                 if (!inst) {
 800                         ret = -ENODEV;
 801                         goto out;
 802                 }
 803                 nfulnl_set_qthresh(inst, ntohl(qthresh));
 804         }
 805
 806         if (nfula[NFULA_CFG_FLAGS]) {
 807                 __be16 flags =
 808                         *(__be16 *)nla_data(nfula[NFULA_CFG_FLAGS]);
 809
 810                 if (!inst) {
 811                         ret = -ENODEV;
 812                         goto out;
 813                 }
 814                 nfulnl_set_flags(inst, ntohs(flags));
 815         }
 816
 817 out_put:
 818         instance_put(inst);
 819 out:
 820         return ret;
 821 }
 822
 823 static const struct nfnl_callback nfulnl_cb[NFULNL_MSG_MAX] = {
 824         [NFULNL_MSG_PACKET]     = { .call = nfulnl_recv_unsupp,
 825                                     .attr_count = NFULA_MAX, },
 826         [NFULNL_MSG_CONFIG]     = { .call = nfulnl_recv_config,
 827                                     .attr_count = NFULA_CFG_MAX,
 828                                     .policy = nfula_cfg_policy },
 829 };
 830
 831 static const struct nfnetlink_subsystem nfulnl_subsys = {
 832         .name           = "log",
 833         .subsys_id      = NFNL_SUBSYS_ULOG,
 834         .cb_count       = NFULNL_MSG_MAX,
 835         .cb             = nfulnl_cb,
 836 };
 837
 838 #ifdef CONFIG_PROC_FS
 839 struct iter_state {
 840         unsigned int bucket;
 841 };
 842
 843 static struct hlist_node *get_first(struct iter_state *st)
 844 {
 845         if (!st)
 846                 return NULL;
 847
 848         for (st->bucket = 0; st->bucket < INSTANCE_BUCKETS; st->bucket++) {
 849                 if (!hlist_empty(&instance_table[st->bucket]))
 850                         return instance_table[st->bucket].first;
 851         }
 852         return NULL;
 853 }
 854
 855 static struct hlist_node *get_next(struct iter_state *st, struct hlist_node *h)
 856 {
 857         h = h->next;
 858         while (!h) {
 859                 if (++st->bucket >= INSTANCE_BUCKETS)
 860                         return NULL;
 861
 862                 h = instance_table[st->bucket].first;
 863         }
 864         return h;
 865 }
 866
 867 static struct hlist_node *get_idx(struct iter_state *st, loff_t pos)
 868 {
 869         struct hlist_node *head;
 870         head = get_first(st);
 871
 872         if (head)
 873                 while (pos && (head = get_next(st, head)))
 874                         pos--;
 875         return pos ? NULL : head;
 876 }
 877
 878 static void *seq_start(struct seq_file *seq, loff_t *pos)
 879 {
 880         read_lock_bh(&instances_lock);
 881         return get_idx(seq->private, *pos);
 882 }
 883
 884 static void *seq_next(struct seq_file *s, void *v, loff_t *pos)
 885 {
 886         (*pos)++;
 887         return get_next(s->private, v);
 888 }
 889
 890 static void seq_stop(struct seq_file *s, void *v)
 891 {
 892         read_unlock_bh(&instances_lock);
 893 }
 894
 895 static int seq_show(struct seq_file *s, void *v)
 896 {
 897         const struct nfulnl_instance *inst = v;
 898
 899         return seq_printf(s, "%5d %6d %5d %1d %5d %6d %2d\n",
 900                           inst->group_num,
 901                           inst->peer_pid, inst->qlen,
 902                           inst->copy_mode, inst->copy_range,
 903                           inst->flushtimeout, atomic_read(&inst->use));
 904 }
 905
 906 static const struct seq_operations nful_seq_ops = {
 907         .start  = seq_start,
 908         .next   = seq_next,
 909         .stop   = seq_stop,
 910         .show   = seq_show,
 911 };
 912
 913 static int nful_open(struct inode *inode, struct file *file)
 914 {
 915         return seq_open_private(file, &nful_seq_ops,
 916                         sizeof(struct iter_state));
 917 }
 918
 919 static const struct file_operations nful_file_ops = {
 920         .owner   = THIS_MODULE,
 921         .open    = nful_open,
 922         .read    = seq_read,
 923         .llseek  = seq_lseek,
 924         .release = seq_release_private,
 925 };
 926
 927 #endif /* PROC_FS */
 928
 929 static int __init nfnetlink_log_init(void)
 930 {
 931         int i, status = -ENOMEM;
 932 #ifdef CONFIG_PROC_FS
 933         struct proc_dir_entry *proc_nful;
 934 #endif
 935
 936         for (i = 0; i < INSTANCE_BUCKETS; i++)
 937                 INIT_HLIST_HEAD(&instance_table[i]);
 938
 939         /* it's not really all that important to have a random value, so
 940          * we can do this from the init function, even if there hasn't
 941          * been that much entropy yet */
 942         get_random_bytes(&hash_init, sizeof(hash_init));
 943
 944         netlink_register_notifier(&nfulnl_rtnl_notifier);
 945         status = nfnetlink_subsys_register(&nfulnl_subsys);
 946         if (status < 0) {
 947                 printk(KERN_ERR "log: failed to create netlink socket\n");
 948                 goto cleanup_netlink_notifier;
 949         }
 950
 951 #ifdef CONFIG_PROC_FS
 952         proc_nful = create_proc_entry("nfnetlink_log", 0440,
 953                                       proc_net_netfilter);
 954         if (!proc_nful)
 955                 goto cleanup_subsys;
 956         proc_nful->proc_fops = &nful_file_ops;
 957 #endif
 958         return status;
 959
 960 #ifdef CONFIG_PROC_FS
 961 cleanup_subsys:
 962         nfnetlink_subsys_unregister(&nfulnl_subsys);
 963 #endif
 964 cleanup_netlink_notifier:
 965         netlink_unregister_notifier(&nfulnl_rtnl_notifier);
 966         return status;
 967 }
 968
 969 static void __exit nfnetlink_log_fini(void)
 970 {
 971         nf_log_unregister(&nfulnl_logger);
 972 #ifdef CONFIG_PROC_FS
 973         remove_proc_entry("nfnetlink_log", proc_net_netfilter);
 974 #endif
 975         nfnetlink_subsys_unregister(&nfulnl_subsys);
 976         netlink_unregister_notifier(&nfulnl_rtnl_notifier);
 977 }
 978
 979 MODULE_DESCRIPTION("netfilter userspace logging");
 980 MODULE_AUTHOR("Harald Welte <laforge@netfilter.org>");
 981 MODULE_LICENSE("GPL");
 982 MODULE_ALIAS_NFNL_SUBSYS(NFNL_SUBSYS_ULOG);
 983
 984 module_init(nfnetlink_log_init);
 985 module_exit(nfnetlink_log_fini);