Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * This is a module which is used for logging packets. |
| 3 | */ |
| 4 | |
| 5 | /* (C) 2001 Jan Rekorajski <baggins@pld.org.pl> |
| 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 | */ |
Jan Engelhardt | ff67e4e | 2010-03-19 21:08:16 +0100 | [diff] [blame] | 12 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | #include <linux/module.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | #include <linux/skbuff.h> |
Arnaldo Carvalho de Melo | 14c8502 | 2005-12-27 02:43:12 -0200 | [diff] [blame] | 15 | #include <linux/if_arp.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 16 | #include <linux/ip.h> |
| 17 | #include <linux/spinlock.h> |
| 18 | #include <linux/icmpv6.h> |
| 19 | #include <net/udp.h> |
| 20 | #include <net/tcp.h> |
| 21 | #include <net/ipv6.h> |
| 22 | #include <linux/netfilter.h> |
Jan Engelhardt | 6709dbb | 2007-02-07 15:11:19 -0800 | [diff] [blame] | 23 | #include <linux/netfilter/x_tables.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 24 | #include <linux/netfilter_ipv6/ip6_tables.h> |
Patrick McHardy | f01ffbd | 2007-12-17 22:38:49 -0800 | [diff] [blame] | 25 | #include <net/netfilter/nf_log.h> |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 26 | #include <net/netfilter/xt_log.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | |
| 28 | MODULE_AUTHOR("Jan Rekorajski <baggins@pld.org.pl>"); |
Jan Engelhardt | 2ae15b6 | 2008-01-14 23:42:28 -0800 | [diff] [blame] | 29 | MODULE_DESCRIPTION("Xtables: IPv6 packet logging to syslog"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 30 | MODULE_LICENSE("GPL"); |
| 31 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 32 | struct in_device; |
| 33 | #include <net/route.h> |
| 34 | #include <linux/netfilter_ipv6/ip6t_LOG.h> |
| 35 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 36 | /* One level of recursion won't kill us */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 37 | static void dump_packet(struct sbuff *m, |
| 38 | const struct nf_loginfo *info, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 39 | const struct sk_buff *skb, unsigned int ip6hoff, |
| 40 | int recurse) |
| 41 | { |
| 42 | u_int8_t currenthdr; |
| 43 | int fragment; |
Jan Engelhardt | a47362a | 2007-07-07 22:16:55 -0700 | [diff] [blame] | 44 | struct ipv6hdr _ip6h; |
| 45 | const struct ipv6hdr *ih; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 46 | unsigned int ptr; |
| 47 | unsigned int hdrlen = 0; |
Harald Welte | 608c8e4 | 2005-08-09 19:58:27 -0700 | [diff] [blame] | 48 | unsigned int logflags; |
| 49 | |
| 50 | if (info->type == NF_LOG_TYPE_LOG) |
| 51 | logflags = info->u.log.logflags; |
| 52 | else |
| 53 | logflags = NF_LOG_MASK; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | |
| 55 | ih = skb_header_pointer(skb, ip6hoff, sizeof(_ip6h), &_ip6h); |
| 56 | if (ih == NULL) { |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 57 | sb_add(m, "TRUNCATED"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | return; |
| 59 | } |
| 60 | |
Joe Perches | 46b86a2 | 2006-01-13 14:29:07 -0800 | [diff] [blame] | 61 | /* Max length: 88 "SRC=0000.0000.0000.0000.0000.0000.0000.0000 DST=0000.0000.0000.0000.0000.0000.0000.0000 " */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 62 | sb_add(m, "SRC=%pI6 DST=%pI6 ", &ih->saddr, &ih->daddr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | |
| 64 | /* Max length: 44 "LEN=65535 TC=255 HOPLIMIT=255 FLOWLBL=FFFFF " */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 65 | sb_add(m, "LEN=%Zu TC=%u HOPLIMIT=%u FLOWLBL=%u ", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 66 | ntohs(ih->payload_len) + sizeof(struct ipv6hdr), |
Al Viro | e69a4adc | 2006-11-14 20:56:00 -0800 | [diff] [blame] | 67 | (ntohl(*(__be32 *)ih) & 0x0ff00000) >> 20, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 68 | ih->hop_limit, |
Al Viro | e69a4adc | 2006-11-14 20:56:00 -0800 | [diff] [blame] | 69 | (ntohl(*(__be32 *)ih) & 0x000fffff)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 70 | |
| 71 | fragment = 0; |
| 72 | ptr = ip6hoff + sizeof(struct ipv6hdr); |
| 73 | currenthdr = ih->nexthdr; |
| 74 | while (currenthdr != NEXTHDR_NONE && ip6t_ext_hdr(currenthdr)) { |
Jan Engelhardt | a47362a | 2007-07-07 22:16:55 -0700 | [diff] [blame] | 75 | struct ipv6_opt_hdr _hdr; |
| 76 | const struct ipv6_opt_hdr *hp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 77 | |
| 78 | hp = skb_header_pointer(skb, ptr, sizeof(_hdr), &_hdr); |
| 79 | if (hp == NULL) { |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 80 | sb_add(m, "TRUNCATED"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 81 | return; |
| 82 | } |
| 83 | |
| 84 | /* Max length: 48 "OPT (...) " */ |
Harald Welte | 608c8e4 | 2005-08-09 19:58:27 -0700 | [diff] [blame] | 85 | if (logflags & IP6T_LOG_IPOPT) |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 86 | sb_add(m, "OPT ( "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 87 | |
| 88 | switch (currenthdr) { |
| 89 | case IPPROTO_FRAGMENT: { |
Jan Engelhardt | a47362a | 2007-07-07 22:16:55 -0700 | [diff] [blame] | 90 | struct frag_hdr _fhdr; |
| 91 | const struct frag_hdr *fh; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 92 | |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 93 | sb_add(m, "FRAG:"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 94 | fh = skb_header_pointer(skb, ptr, sizeof(_fhdr), |
| 95 | &_fhdr); |
| 96 | if (fh == NULL) { |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 97 | sb_add(m, "TRUNCATED "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | return; |
| 99 | } |
| 100 | |
| 101 | /* Max length: 6 "65535 " */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 102 | sb_add(m, "%u ", ntohs(fh->frag_off) & 0xFFF8); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 103 | |
| 104 | /* Max length: 11 "INCOMPLETE " */ |
| 105 | if (fh->frag_off & htons(0x0001)) |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 106 | sb_add(m, "INCOMPLETE "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 107 | |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 108 | sb_add(m, "ID:%08x ", ntohl(fh->identification)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 109 | |
| 110 | if (ntohs(fh->frag_off) & 0xFFF8) |
| 111 | fragment = 1; |
| 112 | |
| 113 | hdrlen = 8; |
| 114 | |
| 115 | break; |
| 116 | } |
| 117 | case IPPROTO_DSTOPTS: |
| 118 | case IPPROTO_ROUTING: |
| 119 | case IPPROTO_HOPOPTS: |
| 120 | if (fragment) { |
Harald Welte | 608c8e4 | 2005-08-09 19:58:27 -0700 | [diff] [blame] | 121 | if (logflags & IP6T_LOG_IPOPT) |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 122 | sb_add(m, ")"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 123 | return; |
| 124 | } |
| 125 | hdrlen = ipv6_optlen(hp); |
| 126 | break; |
| 127 | /* Max Length */ |
| 128 | case IPPROTO_AH: |
Harald Welte | 608c8e4 | 2005-08-09 19:58:27 -0700 | [diff] [blame] | 129 | if (logflags & IP6T_LOG_IPOPT) { |
Jan Engelhardt | a47362a | 2007-07-07 22:16:55 -0700 | [diff] [blame] | 130 | struct ip_auth_hdr _ahdr; |
| 131 | const struct ip_auth_hdr *ah; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | |
| 133 | /* Max length: 3 "AH " */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 134 | sb_add(m, "AH "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 135 | |
| 136 | if (fragment) { |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 137 | sb_add(m, ")"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | return; |
| 139 | } |
| 140 | |
| 141 | ah = skb_header_pointer(skb, ptr, sizeof(_ahdr), |
| 142 | &_ahdr); |
| 143 | if (ah == NULL) { |
| 144 | /* |
YOSHIFUJI Hideaki | 1ab1457 | 2007-02-09 23:24:49 +0900 | [diff] [blame] | 145 | * Max length: 26 "INCOMPLETE [65535 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | * bytes] )" |
| 147 | */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 148 | sb_add(m, "INCOMPLETE [%u bytes] )", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 149 | skb->len - ptr); |
| 150 | return; |
| 151 | } |
| 152 | |
| 153 | /* Length: 15 "SPI=0xF1234567 */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 154 | sb_add(m, "SPI=0x%x ", ntohl(ah->spi)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 155 | |
| 156 | } |
| 157 | |
| 158 | hdrlen = (hp->hdrlen+2)<<2; |
| 159 | break; |
| 160 | case IPPROTO_ESP: |
Harald Welte | 608c8e4 | 2005-08-09 19:58:27 -0700 | [diff] [blame] | 161 | if (logflags & IP6T_LOG_IPOPT) { |
Jan Engelhardt | a47362a | 2007-07-07 22:16:55 -0700 | [diff] [blame] | 162 | struct ip_esp_hdr _esph; |
| 163 | const struct ip_esp_hdr *eh; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 164 | |
| 165 | /* Max length: 4 "ESP " */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 166 | sb_add(m, "ESP "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 167 | |
| 168 | if (fragment) { |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 169 | sb_add(m, ")"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 170 | return; |
| 171 | } |
| 172 | |
| 173 | /* |
| 174 | * Max length: 26 "INCOMPLETE [65535 bytes] )" |
| 175 | */ |
| 176 | eh = skb_header_pointer(skb, ptr, sizeof(_esph), |
| 177 | &_esph); |
| 178 | if (eh == NULL) { |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 179 | sb_add(m, "INCOMPLETE [%u bytes] )", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 180 | skb->len - ptr); |
| 181 | return; |
| 182 | } |
| 183 | |
| 184 | /* Length: 16 "SPI=0xF1234567 )" */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 185 | sb_add(m, "SPI=0x%x )", ntohl(eh->spi) ); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | |
| 187 | } |
| 188 | return; |
| 189 | default: |
| 190 | /* Max length: 20 "Unknown Ext Hdr 255" */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 191 | sb_add(m, "Unknown Ext Hdr %u", currenthdr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 192 | return; |
| 193 | } |
Harald Welte | 608c8e4 | 2005-08-09 19:58:27 -0700 | [diff] [blame] | 194 | if (logflags & IP6T_LOG_IPOPT) |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 195 | sb_add(m, ") "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 196 | |
| 197 | currenthdr = hp->nexthdr; |
| 198 | ptr += hdrlen; |
| 199 | } |
| 200 | |
| 201 | switch (currenthdr) { |
| 202 | case IPPROTO_TCP: { |
Jan Engelhardt | a47362a | 2007-07-07 22:16:55 -0700 | [diff] [blame] | 203 | struct tcphdr _tcph; |
| 204 | const struct tcphdr *th; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 205 | |
| 206 | /* Max length: 10 "PROTO=TCP " */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 207 | sb_add(m, "PROTO=TCP "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 208 | |
| 209 | if (fragment) |
| 210 | break; |
| 211 | |
| 212 | /* Max length: 25 "INCOMPLETE [65535 bytes] " */ |
| 213 | th = skb_header_pointer(skb, ptr, sizeof(_tcph), &_tcph); |
| 214 | if (th == NULL) { |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 215 | sb_add(m, "INCOMPLETE [%u bytes] ", skb->len - ptr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 216 | return; |
| 217 | } |
| 218 | |
| 219 | /* Max length: 20 "SPT=65535 DPT=65535 " */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 220 | sb_add(m, "SPT=%u DPT=%u ", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 221 | ntohs(th->source), ntohs(th->dest)); |
| 222 | /* Max length: 30 "SEQ=4294967295 ACK=4294967295 " */ |
Harald Welte | 608c8e4 | 2005-08-09 19:58:27 -0700 | [diff] [blame] | 223 | if (logflags & IP6T_LOG_TCPSEQ) |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 224 | sb_add(m, "SEQ=%u ACK=%u ", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 225 | ntohl(th->seq), ntohl(th->ack_seq)); |
| 226 | /* Max length: 13 "WINDOW=65535 " */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 227 | sb_add(m, "WINDOW=%u ", ntohs(th->window)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 228 | /* Max length: 9 "RES=0x3C " */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 229 | sb_add(m, "RES=0x%02x ", (u_int8_t)(ntohl(tcp_flag_word(th) & TCP_RESERVED_BITS) >> 22)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 230 | /* Max length: 32 "CWR ECE URG ACK PSH RST SYN FIN " */ |
| 231 | if (th->cwr) |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 232 | sb_add(m, "CWR "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 233 | if (th->ece) |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 234 | sb_add(m, "ECE "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 235 | if (th->urg) |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 236 | sb_add(m, "URG "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 237 | if (th->ack) |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 238 | sb_add(m, "ACK "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 239 | if (th->psh) |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 240 | sb_add(m, "PSH "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 241 | if (th->rst) |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 242 | sb_add(m, "RST "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 243 | if (th->syn) |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 244 | sb_add(m, "SYN "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 245 | if (th->fin) |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 246 | sb_add(m, "FIN "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | /* Max length: 11 "URGP=65535 " */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 248 | sb_add(m, "URGP=%u ", ntohs(th->urg_ptr)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | |
Joe Perches | 3666ed1 | 2009-11-23 23:17:06 +0100 | [diff] [blame] | 250 | if ((logflags & IP6T_LOG_TCPOPT) && |
| 251 | th->doff * 4 > sizeof(struct tcphdr)) { |
Jan Engelhardt | a47362a | 2007-07-07 22:16:55 -0700 | [diff] [blame] | 252 | u_int8_t _opt[60 - sizeof(struct tcphdr)]; |
| 253 | const u_int8_t *op; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 254 | unsigned int i; |
| 255 | unsigned int optsize = th->doff * 4 |
| 256 | - sizeof(struct tcphdr); |
| 257 | |
| 258 | op = skb_header_pointer(skb, |
| 259 | ptr + sizeof(struct tcphdr), |
| 260 | optsize, _opt); |
| 261 | if (op == NULL) { |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 262 | sb_add(m, "OPT (TRUNCATED)"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 263 | return; |
| 264 | } |
| 265 | |
| 266 | /* Max length: 127 "OPT (" 15*4*2chars ") " */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 267 | sb_add(m, "OPT ("); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 268 | for (i =0; i < optsize; i++) |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 269 | sb_add(m, "%02X", op[i]); |
| 270 | sb_add(m, ") "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 271 | } |
| 272 | break; |
| 273 | } |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 274 | case IPPROTO_UDP: |
| 275 | case IPPROTO_UDPLITE: { |
Jan Engelhardt | a47362a | 2007-07-07 22:16:55 -0700 | [diff] [blame] | 276 | struct udphdr _udph; |
| 277 | const struct udphdr *uh; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 278 | |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 279 | if (currenthdr == IPPROTO_UDP) |
| 280 | /* Max length: 10 "PROTO=UDP " */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 281 | sb_add(m, "PROTO=UDP " ); |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 282 | else /* Max length: 14 "PROTO=UDPLITE " */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 283 | sb_add(m, "PROTO=UDPLITE "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 284 | |
| 285 | if (fragment) |
| 286 | break; |
| 287 | |
| 288 | /* Max length: 25 "INCOMPLETE [65535 bytes] " */ |
| 289 | uh = skb_header_pointer(skb, ptr, sizeof(_udph), &_udph); |
| 290 | if (uh == NULL) { |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 291 | sb_add(m, "INCOMPLETE [%u bytes] ", skb->len - ptr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 292 | return; |
| 293 | } |
| 294 | |
| 295 | /* Max length: 20 "SPT=65535 DPT=65535 " */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 296 | sb_add(m, "SPT=%u DPT=%u LEN=%u ", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 297 | ntohs(uh->source), ntohs(uh->dest), |
| 298 | ntohs(uh->len)); |
| 299 | break; |
| 300 | } |
| 301 | case IPPROTO_ICMPV6: { |
Jan Engelhardt | a47362a | 2007-07-07 22:16:55 -0700 | [diff] [blame] | 302 | struct icmp6hdr _icmp6h; |
| 303 | const struct icmp6hdr *ic; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 304 | |
| 305 | /* Max length: 13 "PROTO=ICMPv6 " */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 306 | sb_add(m, "PROTO=ICMPv6 "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 307 | |
| 308 | if (fragment) |
| 309 | break; |
| 310 | |
| 311 | /* Max length: 25 "INCOMPLETE [65535 bytes] " */ |
| 312 | ic = skb_header_pointer(skb, ptr, sizeof(_icmp6h), &_icmp6h); |
| 313 | if (ic == NULL) { |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 314 | sb_add(m, "INCOMPLETE [%u bytes] ", skb->len - ptr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 315 | return; |
| 316 | } |
| 317 | |
| 318 | /* Max length: 18 "TYPE=255 CODE=255 " */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 319 | sb_add(m, "TYPE=%u CODE=%u ", ic->icmp6_type, ic->icmp6_code); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 320 | |
| 321 | switch (ic->icmp6_type) { |
| 322 | case ICMPV6_ECHO_REQUEST: |
| 323 | case ICMPV6_ECHO_REPLY: |
| 324 | /* Max length: 19 "ID=65535 SEQ=65535 " */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 325 | sb_add(m, "ID=%u SEQ=%u ", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 326 | ntohs(ic->icmp6_identifier), |
| 327 | ntohs(ic->icmp6_sequence)); |
| 328 | break; |
| 329 | case ICMPV6_MGM_QUERY: |
| 330 | case ICMPV6_MGM_REPORT: |
| 331 | case ICMPV6_MGM_REDUCTION: |
| 332 | break; |
| 333 | |
| 334 | case ICMPV6_PARAMPROB: |
| 335 | /* Max length: 17 "POINTER=ffffffff " */ |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 336 | sb_add(m, "POINTER=%08x ", ntohl(ic->icmp6_pointer)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 337 | /* Fall through */ |
| 338 | case ICMPV6_DEST_UNREACH: |
| 339 | case ICMPV6_PKT_TOOBIG: |
| 340 | case ICMPV6_TIME_EXCEED: |
| 341 | /* Max length: 3+maxlen */ |
| 342 | if (recurse) { |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 343 | sb_add(m, "["); |
| 344 | dump_packet(m, info, skb, |
| 345 | ptr + sizeof(_icmp6h), 0); |
| 346 | sb_add(m, "] "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 347 | } |
| 348 | |
| 349 | /* Max length: 10 "MTU=65535 " */ |
| 350 | if (ic->icmp6_type == ICMPV6_PKT_TOOBIG) |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 351 | sb_add(m, "MTU=%u ", ntohl(ic->icmp6_mtu)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 352 | } |
| 353 | break; |
| 354 | } |
| 355 | /* Max length: 10 "PROTO=255 " */ |
| 356 | default: |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 357 | sb_add(m, "PROTO=%u ", currenthdr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 358 | } |
| 359 | |
| 360 | /* Max length: 15 "UID=4294967295 " */ |
Harald Welte | 608c8e4 | 2005-08-09 19:58:27 -0700 | [diff] [blame] | 361 | if ((logflags & IP6T_LOG_UID) && recurse && skb->sk) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 362 | read_lock_bh(&skb->sk->sk_callback_lock); |
| 363 | if (skb->sk->sk_socket && skb->sk->sk_socket->file) |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 364 | sb_add(m, "UID=%u GID=%u ", |
David Howells | d76b0d9 | 2008-11-14 10:39:25 +1100 | [diff] [blame] | 365 | skb->sk->sk_socket->file->f_cred->fsuid, |
| 366 | skb->sk->sk_socket->file->f_cred->fsgid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 367 | read_unlock_bh(&skb->sk->sk_callback_lock); |
| 368 | } |
Patrick McHardy | 36e2a1b | 2008-03-20 15:15:45 +0100 | [diff] [blame] | 369 | |
| 370 | /* Max length: 16 "MARK=0xFFFFFFFF " */ |
| 371 | if (!recurse && skb->mark) |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 372 | sb_add(m, "MARK=0x%x ", skb->mark); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 373 | } |
| 374 | |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 375 | static void dump_mac_header(struct sbuff *m, |
| 376 | const struct nf_loginfo *info, |
Patrick McHardy | 7eb9282 | 2010-06-28 14:16:08 +0200 | [diff] [blame] | 377 | const struct sk_buff *skb) |
| 378 | { |
| 379 | struct net_device *dev = skb->dev; |
| 380 | unsigned int logflags = 0; |
| 381 | |
| 382 | if (info->type == NF_LOG_TYPE_LOG) |
| 383 | logflags = info->u.log.logflags; |
| 384 | |
| 385 | if (!(logflags & IP6T_LOG_MACDECODE)) |
| 386 | goto fallback; |
| 387 | |
| 388 | switch (dev->type) { |
| 389 | case ARPHRD_ETHER: |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 390 | sb_add(m, "MACSRC=%pM MACDST=%pM MACPROTO=%04x ", |
Patrick McHardy | 7eb9282 | 2010-06-28 14:16:08 +0200 | [diff] [blame] | 391 | eth_hdr(skb)->h_source, eth_hdr(skb)->h_dest, |
| 392 | ntohs(eth_hdr(skb)->h_proto)); |
| 393 | return; |
| 394 | default: |
| 395 | break; |
| 396 | } |
| 397 | |
| 398 | fallback: |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 399 | sb_add(m, "MAC="); |
Patrick McHardy | 7eb9282 | 2010-06-28 14:16:08 +0200 | [diff] [blame] | 400 | if (dev->hard_header_len && |
| 401 | skb->mac_header != skb->network_header) { |
| 402 | const unsigned char *p = skb_mac_header(skb); |
| 403 | unsigned int len = dev->hard_header_len; |
| 404 | unsigned int i; |
| 405 | |
| 406 | if (dev->type == ARPHRD_SIT && |
| 407 | (p -= ETH_HLEN) < skb->head) |
| 408 | p = NULL; |
| 409 | |
| 410 | if (p != NULL) { |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 411 | sb_add(m, "%02x", *p++); |
Patrick McHardy | 7eb9282 | 2010-06-28 14:16:08 +0200 | [diff] [blame] | 412 | for (i = 1; i < len; i++) |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 413 | sb_add(m, ":%02x", p[i]); |
Patrick McHardy | 7eb9282 | 2010-06-28 14:16:08 +0200 | [diff] [blame] | 414 | } |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 415 | sb_add(m, " "); |
Patrick McHardy | 7eb9282 | 2010-06-28 14:16:08 +0200 | [diff] [blame] | 416 | |
| 417 | if (dev->type == ARPHRD_SIT) { |
| 418 | const struct iphdr *iph = |
| 419 | (struct iphdr *)skb_mac_header(skb); |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 420 | sb_add(m, "TUNNEL=%pI4->%pI4 ", &iph->saddr, &iph->daddr); |
Patrick McHardy | 7eb9282 | 2010-06-28 14:16:08 +0200 | [diff] [blame] | 421 | } |
| 422 | } else |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 423 | sb_add(m, " "); |
Patrick McHardy | 7eb9282 | 2010-06-28 14:16:08 +0200 | [diff] [blame] | 424 | } |
| 425 | |
Harald Welte | 608c8e4 | 2005-08-09 19:58:27 -0700 | [diff] [blame] | 426 | static struct nf_loginfo default_loginfo = { |
| 427 | .type = NF_LOG_TYPE_LOG, |
| 428 | .u = { |
| 429 | .log = { |
Patrick McHardy | f0d57a5 | 2010-04-15 19:09:01 +0200 | [diff] [blame] | 430 | .level = 5, |
Harald Welte | 608c8e4 | 2005-08-09 19:58:27 -0700 | [diff] [blame] | 431 | .logflags = NF_LOG_MASK, |
| 432 | }, |
| 433 | }, |
| 434 | }; |
| 435 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 436 | static void |
Jan Engelhardt | 76108ce | 2008-10-08 11:35:00 +0200 | [diff] [blame] | 437 | ip6t_log_packet(u_int8_t pf, |
Harald Welte | 608c8e4 | 2005-08-09 19:58:27 -0700 | [diff] [blame] | 438 | unsigned int hooknum, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 439 | const struct sk_buff *skb, |
| 440 | const struct net_device *in, |
| 441 | const struct net_device *out, |
Harald Welte | 608c8e4 | 2005-08-09 19:58:27 -0700 | [diff] [blame] | 442 | const struct nf_loginfo *loginfo, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 443 | const char *prefix) |
| 444 | { |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 445 | struct sbuff *m = sb_open(); |
| 446 | |
Harald Welte | 608c8e4 | 2005-08-09 19:58:27 -0700 | [diff] [blame] | 447 | if (!loginfo) |
| 448 | loginfo = &default_loginfo; |
| 449 | |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 450 | sb_add(m, "<%d>%sIN=%s OUT=%s ", loginfo->u.log.level, |
| 451 | prefix, |
| 452 | in ? in->name : "", |
| 453 | out ? out->name : ""); |
Patrick McHardy | 047601b | 2005-06-21 14:07:13 -0700 | [diff] [blame] | 454 | |
Patrick McHardy | 7eb9282 | 2010-06-28 14:16:08 +0200 | [diff] [blame] | 455 | /* MAC logging for input path only. */ |
| 456 | if (in && !out) |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 457 | dump_mac_header(m, loginfo, skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 458 | |
Eric Dumazet | a8defca | 2010-10-04 20:56:05 +0200 | [diff] [blame^] | 459 | dump_packet(m, loginfo, skb, skb_network_offset(skb), 1); |
| 460 | |
| 461 | sb_close(m); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 462 | } |
| 463 | |
| 464 | static unsigned int |
Jan Engelhardt | 4b560b4 | 2009-07-05 19:43:26 +0200 | [diff] [blame] | 465 | log_tg6(struct sk_buff *skb, const struct xt_action_param *par) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 466 | { |
Jan Engelhardt | 7eb3558 | 2008-10-08 11:35:19 +0200 | [diff] [blame] | 467 | const struct ip6t_log_info *loginfo = par->targinfo; |
Harald Welte | 608c8e4 | 2005-08-09 19:58:27 -0700 | [diff] [blame] | 468 | struct nf_loginfo li; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 469 | |
Harald Welte | 608c8e4 | 2005-08-09 19:58:27 -0700 | [diff] [blame] | 470 | li.type = NF_LOG_TYPE_LOG; |
| 471 | li.u.log.level = loginfo->level; |
| 472 | li.u.log.logflags = loginfo->logflags; |
| 473 | |
Jan Engelhardt | 7eb3558 | 2008-10-08 11:35:19 +0200 | [diff] [blame] | 474 | ip6t_log_packet(NFPROTO_IPV6, par->hooknum, skb, par->in, par->out, |
Jan Engelhardt | ee999d8 | 2008-10-08 11:35:01 +0200 | [diff] [blame] | 475 | &li, loginfo->prefix); |
Jan Engelhardt | 6709dbb | 2007-02-07 15:11:19 -0800 | [diff] [blame] | 476 | return XT_CONTINUE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 477 | } |
| 478 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 479 | |
Jan Engelhardt | 135367b | 2010-03-19 17:16:42 +0100 | [diff] [blame] | 480 | static int log_tg6_check(const struct xt_tgchk_param *par) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 481 | { |
Jan Engelhardt | af5d6dc | 2008-10-08 11:35:19 +0200 | [diff] [blame] | 482 | const struct ip6t_log_info *loginfo = par->targinfo; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 483 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 484 | if (loginfo->level >= 8) { |
Jan Engelhardt | ff67e4e | 2010-03-19 21:08:16 +0100 | [diff] [blame] | 485 | pr_debug("level %u >= 8\n", loginfo->level); |
Jan Engelhardt | d6b00a5 | 2010-03-25 16:34:45 +0100 | [diff] [blame] | 486 | return -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 487 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 488 | if (loginfo->prefix[sizeof(loginfo->prefix)-1] != '\0') { |
Jan Engelhardt | ff67e4e | 2010-03-19 21:08:16 +0100 | [diff] [blame] | 489 | pr_debug("prefix not null-terminated\n"); |
Jan Engelhardt | d6b00a5 | 2010-03-25 16:34:45 +0100 | [diff] [blame] | 490 | return -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 491 | } |
Jan Engelhardt | d6b00a5 | 2010-03-25 16:34:45 +0100 | [diff] [blame] | 492 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 493 | } |
| 494 | |
Jan Engelhardt | d3c5ee6 | 2007-12-04 23:24:03 -0800 | [diff] [blame] | 495 | static struct xt_target log_tg6_reg __read_mostly = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 496 | .name = "LOG", |
Jan Engelhardt | ee999d8 | 2008-10-08 11:35:01 +0200 | [diff] [blame] | 497 | .family = NFPROTO_IPV6, |
Jan Engelhardt | d3c5ee6 | 2007-12-04 23:24:03 -0800 | [diff] [blame] | 498 | .target = log_tg6, |
Patrick McHardy | 7f93971 | 2006-03-20 18:01:43 -0800 | [diff] [blame] | 499 | .targetsize = sizeof(struct ip6t_log_info), |
Jan Engelhardt | d3c5ee6 | 2007-12-04 23:24:03 -0800 | [diff] [blame] | 500 | .checkentry = log_tg6_check, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 501 | .me = THIS_MODULE, |
| 502 | }; |
| 503 | |
Eric Leblond | ca735b3 | 2009-03-16 14:54:21 +0100 | [diff] [blame] | 504 | static struct nf_logger ip6t_logger __read_mostly = { |
Harald Welte | 608c8e4 | 2005-08-09 19:58:27 -0700 | [diff] [blame] | 505 | .name = "ip6t_LOG", |
| 506 | .logfn = &ip6t_log_packet, |
| 507 | .me = THIS_MODULE, |
| 508 | }; |
| 509 | |
Jan Engelhardt | d3c5ee6 | 2007-12-04 23:24:03 -0800 | [diff] [blame] | 510 | static int __init log_tg6_init(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 511 | { |
Jan Engelhardt | e1fd058 | 2007-02-07 15:10:34 -0800 | [diff] [blame] | 512 | int ret; |
| 513 | |
Jan Engelhardt | d3c5ee6 | 2007-12-04 23:24:03 -0800 | [diff] [blame] | 514 | ret = xt_register_target(&log_tg6_reg); |
Jan Engelhardt | e1fd058 | 2007-02-07 15:10:34 -0800 | [diff] [blame] | 515 | if (ret < 0) |
| 516 | return ret; |
Jan Engelhardt | ee999d8 | 2008-10-08 11:35:01 +0200 | [diff] [blame] | 517 | nf_log_register(NFPROTO_IPV6, &ip6t_logger); |
Patrick McHardy | 7e2acc7 | 2007-07-24 15:29:55 -0700 | [diff] [blame] | 518 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 519 | } |
| 520 | |
Jan Engelhardt | d3c5ee6 | 2007-12-04 23:24:03 -0800 | [diff] [blame] | 521 | static void __exit log_tg6_exit(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 522 | { |
Patrick McHardy | e92ad99 | 2007-02-12 11:11:55 -0800 | [diff] [blame] | 523 | nf_log_unregister(&ip6t_logger); |
Jan Engelhardt | d3c5ee6 | 2007-12-04 23:24:03 -0800 | [diff] [blame] | 524 | xt_unregister_target(&log_tg6_reg); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 525 | } |
| 526 | |
Jan Engelhardt | d3c5ee6 | 2007-12-04 23:24:03 -0800 | [diff] [blame] | 527 | module_init(log_tg6_init); |
| 528 | module_exit(log_tg6_exit); |