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

   1 #include <linux/kernel.h>
   2 #include <linux/init.h>
   3 #include <linux/module.h>
   4 #include <linux/proc_fs.h>
   5 #include <linux/skbuff.h>
   6 #include <linux/netfilter.h>
   7 #include <linux/seq_file.h>
   8 #include <net/protocol.h>
   9 #include <net/netfilter/nf_log.h>
  10
  11 #include "nf_internals.h"
  12
  13 /* Internal logging interface, which relies on the real
  14    LOG target modules */
  15
  16 #define NF_LOG_PREFIXLEN                128
  17
  18 static const struct nf_logger *nf_loggers[NFPROTO_NUMPROTO] __read_mostly;
  19 static struct list_head nf_loggers_l[NFPROTO_NUMPROTO] __read_mostly;
  20 static DEFINE_MUTEX(nf_log_mutex);
  21
  22 static struct nf_logger *__find_logger(int pf, const char *str_logger)
  23 {
  24         struct nf_logger *t;
  25
  26         list_for_each_entry(t, &nf_loggers_l[pf], list[pf]) {
  27                 if (!strnicmp(str_logger, t->name, strlen(t->name)))
  28                         return t;
  29         }
  30
  31         return NULL;
  32 }
  33
  34 /* return EEXIST if the same logger is registred, 0 on success. */
  35 int nf_log_register(u_int8_t pf, struct nf_logger *logger)
  36 {
  37         const struct nf_logger *llog;
  38
  39         if (pf >= ARRAY_SIZE(nf_loggers))
  40                 return -EINVAL;
  41
  42         mutex_lock(&nf_log_mutex);
  43
  44         if (pf == NFPROTO_UNSPEC) {
  45                 int i;
  46                 for (i = NFPROTO_UNSPEC; i < NFPROTO_NUMPROTO; i++)
  47                         list_add_tail(&(logger->list[i]), &(nf_loggers_l[i]));
  48         } else {
  49                 /* register at end of list to honor first register win */
  50                 list_add_tail(&logger->list[pf], &nf_loggers_l[pf]);
  51                 llog = rcu_dereference(nf_loggers[pf]);
  52                 if (llog == NULL)
  53                         rcu_assign_pointer(nf_loggers[pf], logger);
  54         }
  55
  56         mutex_unlock(&nf_log_mutex);
  57
  58         return 0;
  59 }
  60 EXPORT_SYMBOL(nf_log_register);
  61
  62 void nf_log_unregister(struct nf_logger *logger)
  63 {
  64         const struct nf_logger *c_logger;
  65         int i;
  66
  67         mutex_lock(&nf_log_mutex);
  68         for (i = 0; i < ARRAY_SIZE(nf_loggers); i++) {
  69                 c_logger = rcu_dereference(nf_loggers[i]);
  70                 if (c_logger == logger)
  71                         rcu_assign_pointer(nf_loggers[i], NULL);
  72                 list_del(&logger->list[i]);
  73         }
  74         mutex_unlock(&nf_log_mutex);
  75
  76         synchronize_rcu();
  77 }
  78 EXPORT_SYMBOL(nf_log_unregister);
  79
  80 int nf_log_bind_pf(u_int8_t pf, const struct nf_logger *logger)
  81 {
  82         mutex_lock(&nf_log_mutex);
  83         if (__find_logger(pf, logger->name) == NULL) {
  84                 mutex_unlock(&nf_log_mutex);
  85                 return -ENOENT;
  86         }
  87         rcu_assign_pointer(nf_loggers[pf], logger);
  88         mutex_unlock(&nf_log_mutex);
  89         return 0;
  90 }
  91 EXPORT_SYMBOL(nf_log_bind_pf);
  92
  93 void nf_log_unbind_pf(u_int8_t pf)
  94 {
  95         mutex_lock(&nf_log_mutex);
  96         rcu_assign_pointer(nf_loggers[pf], NULL);
  97         mutex_unlock(&nf_log_mutex);
  98 }
  99 EXPORT_SYMBOL(nf_log_unbind_pf);
 100
 101 void nf_log_packet(u_int8_t pf,
 102                    unsigned int hooknum,
 103                    const struct sk_buff *skb,
 104                    const struct net_device *in,
 105                    const struct net_device *out,
 106                    const struct nf_loginfo *loginfo,
 107                    const char *fmt, ...)
 108 {
 109         va_list args;
 110         char prefix[NF_LOG_PREFIXLEN];
 111         const struct nf_logger *logger;
 112
 113         rcu_read_lock();
 114         logger = rcu_dereference(nf_loggers[pf]);
 115         if (logger) {
 116                 va_start(args, fmt);
 117                 vsnprintf(prefix, sizeof(prefix), fmt, args);
 118                 va_end(args);
 119                 logger->logfn(pf, hooknum, skb, in, out, loginfo, prefix);
 120         }
 121         rcu_read_unlock();
 122 }
 123 EXPORT_SYMBOL(nf_log_packet);
 124
 125 #ifdef CONFIG_PROC_FS
 126 static void *seq_start(struct seq_file *seq, loff_t *pos)
 127         __acquires(RCU)
 128 {
 129         rcu_read_lock();
 130
 131         if (*pos >= ARRAY_SIZE(nf_loggers))
 132                 return NULL;
 133
 134         return pos;
 135 }
 136
 137 static void *seq_next(struct seq_file *s, void *v, loff_t *pos)
 138 {
 139         (*pos)++;
 140
 141         if (*pos >= ARRAY_SIZE(nf_loggers))
 142                 return NULL;
 143
 144         return pos;
 145 }
 146
 147 static void seq_stop(struct seq_file *s, void *v)
 148         __releases(RCU)
 149 {
 150         rcu_read_unlock();
 151 }
 152
 153 static int seq_show(struct seq_file *s, void *v)
 154 {
 155         loff_t *pos = v;
 156         const struct nf_logger *logger;
 157         struct nf_logger *t;
 158         int ret;
 159
 160         logger = rcu_dereference(nf_loggers[*pos]);
 161
 162         if (!logger)
 163                 ret = seq_printf(s, "%2lld NONE (", *pos);
 164         else
 165                 ret = seq_printf(s, "%2lld %s (", *pos, logger->name);
 166
 167         if (ret < 0)
 168                 return ret;
 169
 170         mutex_lock(&nf_log_mutex);
 171         list_for_each_entry(t, &nf_loggers_l[*pos], list[*pos]) {
 172                 ret = seq_printf(s, "%s", t->name);
 173                 if (ret < 0) {
 174                         mutex_unlock(&nf_log_mutex);
 175                         return ret;
 176                 }
 177                 if (&t->list[*pos] != nf_loggers_l[*pos].prev) {
 178                         ret = seq_printf(s, ",");
 179                         if (ret < 0) {
 180                                 mutex_unlock(&nf_log_mutex);
 181                                 return ret;
 182                         }
 183                 }
 184         }
 185         mutex_unlock(&nf_log_mutex);
 186
 187         return seq_printf(s, ")\n");
 188 }
 189
 190 static const struct seq_operations nflog_seq_ops = {
 191         .start  = seq_start,
 192         .next   = seq_next,
 193         .stop   = seq_stop,
 194         .show   = seq_show,
 195 };
 196
 197 static int nflog_open(struct inode *inode, struct file *file)
 198 {
 199         return seq_open(file, &nflog_seq_ops);
 200 }
 201
 202 static const struct file_operations nflog_file_ops = {
 203         .owner   = THIS_MODULE,
 204         .open    = nflog_open,
 205         .read    = seq_read,
 206         .llseek  = seq_lseek,
 207         .release = seq_release,
 208 };
 209
 210 #endif /* PROC_FS */
 211
 212
 213 int __init netfilter_log_init(void)
 214 {
 215         int i;
 216 #ifdef CONFIG_PROC_FS
 217         if (!proc_create("nf_log", S_IRUGO,
 218                          proc_net_netfilter, &nflog_file_ops))
 219                 return -1;
 220 #endif
 221
 222         for (i = NFPROTO_UNSPEC; i < NFPROTO_NUMPROTO; i++)
 223                 INIT_LIST_HEAD(&(nf_loggers_l[i]));
 224
 225         return 0;
 226 }