Merge git://git.infradead.org/hdrcleanup-2.6
[linux-2.6] / net / ipv4 / netfilter / ipt_LOG.c
1 /*
2  * This is a module which is used for logging packets.
3  */
4
5 /* (C) 1999-2001 Paul `Rusty' Russell
6  * (C) 2002-2004 Netfilter Core Team <coreteam@netfilter.org>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  */
12
13 #include <linux/module.h>
14 #include <linux/spinlock.h>
15 #include <linux/skbuff.h>
16 #include <linux/ip.h>
17 #include <net/icmp.h>
18 #include <net/udp.h>
19 #include <net/tcp.h>
20 #include <net/route.h>
21
22 #include <linux/netfilter.h>
23 #include <linux/netfilter_ipv4/ip_tables.h>
24 #include <linux/netfilter_ipv4/ipt_LOG.h>
25
26 MODULE_LICENSE("GPL");
27 MODULE_AUTHOR("Netfilter Core Team <coreteam@netfilter.org>");
28 MODULE_DESCRIPTION("iptables syslog logging module");
29
30 #if 0
31 #define DEBUGP printk
32 #else
33 #define DEBUGP(format, args...)
34 #endif
35
36 /* Use lock to serialize, so printks don't overlap */
37 static DEFINE_SPINLOCK(log_lock);
38
39 /* One level of recursion won't kill us */
40 static void dump_packet(const struct nf_loginfo *info,
41                         const struct sk_buff *skb,
42                         unsigned int iphoff)
43 {
44         struct iphdr _iph, *ih;
45         unsigned int logflags;
46
47         if (info->type == NF_LOG_TYPE_LOG)
48                 logflags = info->u.log.logflags;
49         else
50                 logflags = NF_LOG_MASK;
51
52         ih = skb_header_pointer(skb, iphoff, sizeof(_iph), &_iph);
53         if (ih == NULL) {
54                 printk("TRUNCATED");
55                 return;
56         }
57
58         /* Important fields:
59          * TOS, len, DF/MF, fragment offset, TTL, src, dst, options. */
60         /* Max length: 40 "SRC=255.255.255.255 DST=255.255.255.255 " */
61         printk("SRC=%u.%u.%u.%u DST=%u.%u.%u.%u ",
62                NIPQUAD(ih->saddr), NIPQUAD(ih->daddr));
63
64         /* Max length: 46 "LEN=65535 TOS=0xFF PREC=0xFF TTL=255 ID=65535 " */
65         printk("LEN=%u TOS=0x%02X PREC=0x%02X TTL=%u ID=%u ",
66                ntohs(ih->tot_len), ih->tos & IPTOS_TOS_MASK,
67                ih->tos & IPTOS_PREC_MASK, ih->ttl, ntohs(ih->id));
68
69         /* Max length: 6 "CE DF MF " */
70         if (ntohs(ih->frag_off) & IP_CE)
71                 printk("CE ");
72         if (ntohs(ih->frag_off) & IP_DF)
73                 printk("DF ");
74         if (ntohs(ih->frag_off) & IP_MF)
75                 printk("MF ");
76
77         /* Max length: 11 "FRAG:65535 " */
78         if (ntohs(ih->frag_off) & IP_OFFSET)
79                 printk("FRAG:%u ", ntohs(ih->frag_off) & IP_OFFSET);
80
81         if ((logflags & IPT_LOG_IPOPT)
82             && ih->ihl * 4 > sizeof(struct iphdr)) {
83                 unsigned char _opt[4 * 15 - sizeof(struct iphdr)], *op;
84                 unsigned int i, optsize;
85
86                 optsize = ih->ihl * 4 - sizeof(struct iphdr);
87                 op = skb_header_pointer(skb, iphoff+sizeof(_iph),
88                                         optsize, _opt);
89                 if (op == NULL) {
90                         printk("TRUNCATED");
91                         return;
92                 }
93
94                 /* Max length: 127 "OPT (" 15*4*2chars ") " */
95                 printk("OPT (");
96                 for (i = 0; i < optsize; i++)
97                         printk("%02X", op[i]);
98                 printk(") ");
99         }
100
101         switch (ih->protocol) {
102         case IPPROTO_TCP: {
103                 struct tcphdr _tcph, *th;
104
105                 /* Max length: 10 "PROTO=TCP " */
106                 printk("PROTO=TCP ");
107
108                 if (ntohs(ih->frag_off) & IP_OFFSET)
109                         break;
110
111                 /* Max length: 25 "INCOMPLETE [65535 bytes] " */
112                 th = skb_header_pointer(skb, iphoff + ih->ihl * 4,
113                                         sizeof(_tcph), &_tcph);
114                 if (th == NULL) {
115                         printk("INCOMPLETE [%u bytes] ",
116                                skb->len - iphoff - ih->ihl*4);
117                         break;
118                 }
119
120                 /* Max length: 20 "SPT=65535 DPT=65535 " */
121                 printk("SPT=%u DPT=%u ",
122                        ntohs(th->source), ntohs(th->dest));
123                 /* Max length: 30 "SEQ=4294967295 ACK=4294967295 " */
124                 if (logflags & IPT_LOG_TCPSEQ)
125                         printk("SEQ=%u ACK=%u ",
126                                ntohl(th->seq), ntohl(th->ack_seq));
127                 /* Max length: 13 "WINDOW=65535 " */
128                 printk("WINDOW=%u ", ntohs(th->window));
129                 /* Max length: 9 "RES=0x3F " */
130                 printk("RES=0x%02x ", (u8)(ntohl(tcp_flag_word(th) & TCP_RESERVED_BITS) >> 22));
131                 /* Max length: 32 "CWR ECE URG ACK PSH RST SYN FIN " */
132                 if (th->cwr)
133                         printk("CWR ");
134                 if (th->ece)
135                         printk("ECE ");
136                 if (th->urg)
137                         printk("URG ");
138                 if (th->ack)
139                         printk("ACK ");
140                 if (th->psh)
141                         printk("PSH ");
142                 if (th->rst)
143                         printk("RST ");
144                 if (th->syn)
145                         printk("SYN ");
146                 if (th->fin)
147                         printk("FIN ");
148                 /* Max length: 11 "URGP=65535 " */
149                 printk("URGP=%u ", ntohs(th->urg_ptr));
150
151                 if ((logflags & IPT_LOG_TCPOPT)
152                     && th->doff * 4 > sizeof(struct tcphdr)) {
153                         unsigned char _opt[4 * 15 - sizeof(struct tcphdr)];
154                         unsigned char *op;
155                         unsigned int i, optsize;
156
157                         optsize = th->doff * 4 - sizeof(struct tcphdr);
158                         op = skb_header_pointer(skb,
159                                                 iphoff+ih->ihl*4+sizeof(_tcph),
160                                                 optsize, _opt);
161                         if (op == NULL) {
162                                 printk("TRUNCATED");
163                                 return;
164                         }
165
166                         /* Max length: 127 "OPT (" 15*4*2chars ") " */
167                         printk("OPT (");
168                         for (i = 0; i < optsize; i++)
169                                 printk("%02X", op[i]);
170                         printk(") ");
171                 }
172                 break;
173         }
174         case IPPROTO_UDP: {
175                 struct udphdr _udph, *uh;
176
177                 /* Max length: 10 "PROTO=UDP " */
178                 printk("PROTO=UDP ");
179
180                 if (ntohs(ih->frag_off) & IP_OFFSET)
181                         break;
182
183                 /* Max length: 25 "INCOMPLETE [65535 bytes] " */
184                 uh = skb_header_pointer(skb, iphoff+ih->ihl*4,
185                                         sizeof(_udph), &_udph);
186                 if (uh == NULL) {
187                         printk("INCOMPLETE [%u bytes] ",
188                                skb->len - iphoff - ih->ihl*4);
189                         break;
190                 }
191
192                 /* Max length: 20 "SPT=65535 DPT=65535 " */
193                 printk("SPT=%u DPT=%u LEN=%u ",
194                        ntohs(uh->source), ntohs(uh->dest),
195                        ntohs(uh->len));
196                 break;
197         }
198         case IPPROTO_ICMP: {
199                 struct icmphdr _icmph, *ich;
200                 static const size_t required_len[NR_ICMP_TYPES+1]
201                         = { [ICMP_ECHOREPLY] = 4,
202                             [ICMP_DEST_UNREACH]
203                             = 8 + sizeof(struct iphdr),
204                             [ICMP_SOURCE_QUENCH]
205                             = 8 + sizeof(struct iphdr),
206                             [ICMP_REDIRECT]
207                             = 8 + sizeof(struct iphdr),
208                             [ICMP_ECHO] = 4,
209                             [ICMP_TIME_EXCEEDED]
210                             = 8 + sizeof(struct iphdr),
211                             [ICMP_PARAMETERPROB]
212                             = 8 + sizeof(struct iphdr),
213                             [ICMP_TIMESTAMP] = 20,
214                             [ICMP_TIMESTAMPREPLY] = 20,
215                             [ICMP_ADDRESS] = 12,
216                             [ICMP_ADDRESSREPLY] = 12 };
217
218                 /* Max length: 11 "PROTO=ICMP " */
219                 printk("PROTO=ICMP ");
220
221                 if (ntohs(ih->frag_off) & IP_OFFSET)
222                         break;
223
224                 /* Max length: 25 "INCOMPLETE [65535 bytes] " */
225                 ich = skb_header_pointer(skb, iphoff + ih->ihl * 4,
226                                          sizeof(_icmph), &_icmph);
227                 if (ich == NULL) {
228                         printk("INCOMPLETE [%u bytes] ",
229                                skb->len - iphoff - ih->ihl*4);
230                         break;
231                 }
232
233                 /* Max length: 18 "TYPE=255 CODE=255 " */
234                 printk("TYPE=%u CODE=%u ", ich->type, ich->code);
235
236                 /* Max length: 25 "INCOMPLETE [65535 bytes] " */
237                 if (ich->type <= NR_ICMP_TYPES
238                     && required_len[ich->type]
239                     && skb->len-iphoff-ih->ihl*4 < required_len[ich->type]) {
240                         printk("INCOMPLETE [%u bytes] ",
241                                skb->len - iphoff - ih->ihl*4);
242                         break;
243                 }
244
245                 switch (ich->type) {
246                 case ICMP_ECHOREPLY:
247                 case ICMP_ECHO:
248                         /* Max length: 19 "ID=65535 SEQ=65535 " */
249                         printk("ID=%u SEQ=%u ",
250                                ntohs(ich->un.echo.id),
251                                ntohs(ich->un.echo.sequence));
252                         break;
253
254                 case ICMP_PARAMETERPROB:
255                         /* Max length: 14 "PARAMETER=255 " */
256                         printk("PARAMETER=%u ",
257                                ntohl(ich->un.gateway) >> 24);
258                         break;
259                 case ICMP_REDIRECT:
260                         /* Max length: 24 "GATEWAY=255.255.255.255 " */
261                         printk("GATEWAY=%u.%u.%u.%u ",
262                                NIPQUAD(ich->un.gateway));
263                         /* Fall through */
264                 case ICMP_DEST_UNREACH:
265                 case ICMP_SOURCE_QUENCH:
266                 case ICMP_TIME_EXCEEDED:
267                         /* Max length: 3+maxlen */
268                         if (!iphoff) { /* Only recurse once. */
269                                 printk("[");
270                                 dump_packet(info, skb,
271                                             iphoff + ih->ihl*4+sizeof(_icmph));
272                                 printk("] ");
273                         }
274
275                         /* Max length: 10 "MTU=65535 " */
276                         if (ich->type == ICMP_DEST_UNREACH
277                             && ich->code == ICMP_FRAG_NEEDED)
278                                 printk("MTU=%u ", ntohs(ich->un.frag.mtu));
279                 }
280                 break;
281         }
282         /* Max Length */
283         case IPPROTO_AH: {
284                 struct ip_auth_hdr _ahdr, *ah;
285
286                 if (ntohs(ih->frag_off) & IP_OFFSET)
287                         break;
288                 
289                 /* Max length: 9 "PROTO=AH " */
290                 printk("PROTO=AH ");
291
292                 /* Max length: 25 "INCOMPLETE [65535 bytes] " */
293                 ah = skb_header_pointer(skb, iphoff+ih->ihl*4,
294                                         sizeof(_ahdr), &_ahdr);
295                 if (ah == NULL) {
296                         printk("INCOMPLETE [%u bytes] ",
297                                skb->len - iphoff - ih->ihl*4);
298                         break;
299                 }
300
301                 /* Length: 15 "SPI=0xF1234567 " */
302                 printk("SPI=0x%x ", ntohl(ah->spi));
303                 break;
304         }
305         case IPPROTO_ESP: {
306                 struct ip_esp_hdr _esph, *eh;
307
308                 /* Max length: 10 "PROTO=ESP " */
309                 printk("PROTO=ESP ");
310
311                 if (ntohs(ih->frag_off) & IP_OFFSET)
312                         break;
313
314                 /* Max length: 25 "INCOMPLETE [65535 bytes] " */
315                 eh = skb_header_pointer(skb, iphoff+ih->ihl*4,
316                                         sizeof(_esph), &_esph);
317                 if (eh == NULL) {
318                         printk("INCOMPLETE [%u bytes] ",
319                                skb->len - iphoff - ih->ihl*4);
320                         break;
321                 }
322
323                 /* Length: 15 "SPI=0xF1234567 " */
324                 printk("SPI=0x%x ", ntohl(eh->spi));
325                 break;
326         }
327         /* Max length: 10 "PROTO 255 " */
328         default:
329                 printk("PROTO=%u ", ih->protocol);
330         }
331
332         /* Max length: 15 "UID=4294967295 " */
333         if ((logflags & IPT_LOG_UID) && !iphoff && skb->sk) {
334                 read_lock_bh(&skb->sk->sk_callback_lock);
335                 if (skb->sk->sk_socket && skb->sk->sk_socket->file)
336                         printk("UID=%u ", skb->sk->sk_socket->file->f_uid);
337                 read_unlock_bh(&skb->sk->sk_callback_lock);
338         }
339
340         /* Proto    Max log string length */
341         /* IP:      40+46+6+11+127 = 230 */
342         /* TCP:     10+max(25,20+30+13+9+32+11+127) = 252 */
343         /* UDP:     10+max(25,20) = 35 */
344         /* ICMP:    11+max(25, 18+25+max(19,14,24+3+n+10,3+n+10)) = 91+n */
345         /* ESP:     10+max(25)+15 = 50 */
346         /* AH:      9+max(25)+15 = 49 */
347         /* unknown: 10 */
348
349         /* (ICMP allows recursion one level deep) */
350         /* maxlen =  IP + ICMP +  IP + max(TCP,UDP,ICMP,unknown) */
351         /* maxlen = 230+   91  + 230 + 252 = 803 */
352 }
353
354 static struct nf_loginfo default_loginfo = {
355         .type   = NF_LOG_TYPE_LOG,
356         .u = {
357                 .log = {
358                         .level    = 0,
359                         .logflags = NF_LOG_MASK,
360                 },
361         },
362 };
363
364 static void
365 ipt_log_packet(unsigned int pf,
366                unsigned int hooknum,
367                const struct sk_buff *skb,
368                const struct net_device *in,
369                const struct net_device *out,
370                const struct nf_loginfo *loginfo,
371                const char *prefix)
372 {
373         if (!loginfo)
374                 loginfo = &default_loginfo;
375
376         spin_lock_bh(&log_lock);
377         printk("<%d>%sIN=%s OUT=%s ", loginfo->u.log.level,
378                prefix,
379                in ? in->name : "",
380                out ? out->name : "");
381 #ifdef CONFIG_BRIDGE_NETFILTER
382         if (skb->nf_bridge) {
383                 struct net_device *physindev = skb->nf_bridge->physindev;
384                 struct net_device *physoutdev = skb->nf_bridge->physoutdev;
385
386                 if (physindev && in != physindev)
387                         printk("PHYSIN=%s ", physindev->name);
388                 if (physoutdev && out != physoutdev)
389                         printk("PHYSOUT=%s ", physoutdev->name);
390         }
391 #endif
392
393         if (in && !out) {
394                 /* MAC logging for input chain only. */
395                 printk("MAC=");
396                 if (skb->dev && skb->dev->hard_header_len
397                     && skb->mac.raw != (void*)skb->nh.iph) {
398                         int i;
399                         unsigned char *p = skb->mac.raw;
400                         for (i = 0; i < skb->dev->hard_header_len; i++,p++)
401                                 printk("%02x%c", *p,
402                                        i==skb->dev->hard_header_len - 1
403                                        ? ' ':':');
404                 } else
405                         printk(" ");
406         }
407
408         dump_packet(loginfo, skb, 0);
409         printk("\n");
410         spin_unlock_bh(&log_lock);
411 }
412
413 static unsigned int
414 ipt_log_target(struct sk_buff **pskb,
415                const struct net_device *in,
416                const struct net_device *out,
417                unsigned int hooknum,
418                const struct xt_target *target,
419                const void *targinfo,
420                void *userinfo)
421 {
422         const struct ipt_log_info *loginfo = targinfo;
423         struct nf_loginfo li;
424
425         li.type = NF_LOG_TYPE_LOG;
426         li.u.log.level = loginfo->level;
427         li.u.log.logflags = loginfo->logflags;
428
429         if (loginfo->logflags & IPT_LOG_NFLOG)
430                 nf_log_packet(PF_INET, hooknum, *pskb, in, out, &li,
431                               "%s", loginfo->prefix);
432         else
433                 ipt_log_packet(PF_INET, hooknum, *pskb, in, out, &li,
434                                loginfo->prefix);
435
436         return IPT_CONTINUE;
437 }
438
439 static int ipt_log_checkentry(const char *tablename,
440                               const void *e,
441                               const struct xt_target *target,
442                               void *targinfo,
443                               unsigned int targinfosize,
444                               unsigned int hook_mask)
445 {
446         const struct ipt_log_info *loginfo = targinfo;
447
448         if (loginfo->level >= 8) {
449                 DEBUGP("LOG: level %u >= 8\n", loginfo->level);
450                 return 0;
451         }
452         if (loginfo->prefix[sizeof(loginfo->prefix)-1] != '\0') {
453                 DEBUGP("LOG: prefix term %i\n",
454                        loginfo->prefix[sizeof(loginfo->prefix)-1]);
455                 return 0;
456         }
457         return 1;
458 }
459
460 static struct ipt_target ipt_log_reg = {
461         .name           = "LOG",
462         .target         = ipt_log_target,
463         .targetsize     = sizeof(struct ipt_log_info),
464         .checkentry     = ipt_log_checkentry,
465         .me             = THIS_MODULE,
466 };
467
468 static struct nf_logger ipt_log_logger ={
469         .name           = "ipt_LOG",
470         .logfn          = &ipt_log_packet,
471         .me             = THIS_MODULE,
472 };
473
474 static int __init ipt_log_init(void)
475 {
476         if (ipt_register_target(&ipt_log_reg))
477                 return -EINVAL;
478         if (nf_log_register(PF_INET, &ipt_log_logger) < 0) {
479                 printk(KERN_WARNING "ipt_LOG: not logging via system console "
480                        "since somebody else already registered for PF_INET\n");
481                 /* we cannot make module load fail here, since otherwise
482                  * iptables userspace would abort */
483         }
484         
485         return 0;
486 }
487
488 static void __exit ipt_log_fini(void)
489 {
490         nf_log_unregister_logger(&ipt_log_logger);
491         ipt_unregister_target(&ipt_log_reg);
492 }
493
494 module_init(ipt_log_init);
495 module_exit(ipt_log_fini);