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 <linux/rcupdate.h> 9 #include <net/protocol.h> 10 11 #include "nf_internals.h" 12 13 /* 14 * A queue handler may be registered for each protocol. Each is protected by 15 * long term mutex. The handler must provide an an outfn() to accept packets 16 * for queueing and must reinject all packets it receives, no matter what. 17 */ 18 static struct nf_queue_handler *queue_handler[NPROTO]; 19 20 static DEFINE_RWLOCK(queue_handler_lock); 21 22 /* return EBUSY when somebody else is registered, return EEXIST if the 23 * same handler is registered, return 0 in case of success. */ 24 int nf_register_queue_handler(int pf, struct nf_queue_handler *qh) 25 { 26 int ret; 27 28 if (pf >= NPROTO) 29 return -EINVAL; 30 31 write_lock_bh(&queue_handler_lock); 32 if (queue_handler[pf] == qh) 33 ret = -EEXIST; 34 else if (queue_handler[pf]) 35 ret = -EBUSY; 36 else { 37 queue_handler[pf] = qh; 38 ret = 0; 39 } 40 write_unlock_bh(&queue_handler_lock); 41 42 return ret; 43 } 44 EXPORT_SYMBOL(nf_register_queue_handler); 45 46 /* The caller must flush their queue before this */ 47 int nf_unregister_queue_handler(int pf) 48 { 49 if (pf >= NPROTO) 50 return -EINVAL; 51 52 write_lock_bh(&queue_handler_lock); 53 queue_handler[pf] = NULL; 54 write_unlock_bh(&queue_handler_lock); 55 56 return 0; 57 } 58 EXPORT_SYMBOL(nf_unregister_queue_handler); 59 60 void nf_unregister_queue_handlers(struct nf_queue_handler *qh) 61 { 62 int pf; 63 64 write_lock_bh(&queue_handler_lock); 65 for (pf = 0; pf < NPROTO; pf++) { 66 if (queue_handler[pf] == qh) 67 queue_handler[pf] = NULL; 68 } 69 write_unlock_bh(&queue_handler_lock); 70 } 71 EXPORT_SYMBOL_GPL(nf_unregister_queue_handlers); 72 73 /* 74 * Any packet that leaves via this function must come back 75 * through nf_reinject(). 76 */ 77 static int __nf_queue(struct sk_buff *skb, 78 struct list_head *elem, 79 int pf, unsigned int hook, 80 struct net_device *indev, 81 struct net_device *outdev, 82 int (*okfn)(struct sk_buff *), 83 unsigned int queuenum) 84 { 85 int status; 86 struct nf_info *info; 87 #ifdef CONFIG_BRIDGE_NETFILTER 88 struct net_device *physindev = NULL; 89 struct net_device *physoutdev = NULL; 90 #endif 91 struct nf_afinfo *afinfo; 92 93 /* QUEUE == DROP if noone is waiting, to be safe. */ 94 read_lock(&queue_handler_lock); 95 if (!queue_handler[pf]) { 96 read_unlock(&queue_handler_lock); 97 kfree_skb(skb); 98 return 1; 99 } 100 101 afinfo = nf_get_afinfo(pf); 102 if (!afinfo) { 103 read_unlock(&queue_handler_lock); 104 kfree_skb(skb); 105 return 1; 106 } 107 108 info = kmalloc(sizeof(*info) + afinfo->route_key_size, GFP_ATOMIC); 109 if (!info) { 110 if (net_ratelimit()) 111 printk(KERN_ERR "OOM queueing packet %p\n", 112 skb); 113 read_unlock(&queue_handler_lock); 114 kfree_skb(skb); 115 return 1; 116 } 117 118 *info = (struct nf_info) { 119 (struct nf_hook_ops *)elem, pf, hook, indev, outdev, okfn }; 120 121 /* If it's going away, ignore hook. */ 122 if (!try_module_get(info->elem->owner)) { 123 read_unlock(&queue_handler_lock); 124 kfree(info); 125 return 0; 126 } 127 128 /* Bump dev refs so they don't vanish while packet is out */ 129 if (indev) dev_hold(indev); 130 if (outdev) dev_hold(outdev); 131 132 #ifdef CONFIG_BRIDGE_NETFILTER 133 if (skb->nf_bridge) { 134 physindev = skb->nf_bridge->physindev; 135 if (physindev) dev_hold(physindev); 136 physoutdev = skb->nf_bridge->physoutdev; 137 if (physoutdev) dev_hold(physoutdev); 138 } 139 #endif 140 afinfo->saveroute(skb, info); 141 status = queue_handler[pf]->outfn(skb, info, queuenum, 142 queue_handler[pf]->data); 143 144 read_unlock(&queue_handler_lock); 145 146 if (status < 0) { 147 /* James M doesn't say fuck enough. */ 148 if (indev) dev_put(indev); 149 if (outdev) dev_put(outdev); 150 #ifdef CONFIG_BRIDGE_NETFILTER 151 if (physindev) dev_put(physindev); 152 if (physoutdev) dev_put(physoutdev); 153 #endif 154 module_put(info->elem->owner); 155 kfree(info); 156 kfree_skb(skb); 157 158 return 1; 159 } 160 161 return 1; 162 } 163 164 int nf_queue(struct sk_buff *skb, 165 struct list_head *elem, 166 int pf, unsigned int hook, 167 struct net_device *indev, 168 struct net_device *outdev, 169 int (*okfn)(struct sk_buff *), 170 unsigned int queuenum) 171 { 172 struct sk_buff *segs; 173 174 if (!skb_is_gso(skb)) 175 return __nf_queue(skb, elem, pf, hook, indev, outdev, okfn, 176 queuenum); 177 178 switch (pf) { 179 case AF_INET: 180 skb->protocol = htons(ETH_P_IP); 181 break; 182 case AF_INET6: 183 skb->protocol = htons(ETH_P_IPV6); 184 break; 185 } 186 187 segs = skb_gso_segment(skb, 0); 188 kfree_skb(skb); 189 if (unlikely(IS_ERR(segs))) 190 return 1; 191 192 do { 193 struct sk_buff *nskb = segs->next; 194 195 segs->next = NULL; 196 if (!__nf_queue(segs, elem, pf, hook, indev, outdev, okfn, 197 queuenum)) 198 kfree_skb(segs); 199 segs = nskb; 200 } while (segs); 201 return 1; 202 } 203 204 void nf_reinject(struct sk_buff *skb, struct nf_info *info, 205 unsigned int verdict) 206 { 207 struct list_head *elem = &info->elem->list; 208 struct list_head *i; 209 struct nf_afinfo *afinfo; 210 211 rcu_read_lock(); 212 213 /* Release those devices we held, or Alexey will kill me. */ 214 if (info->indev) dev_put(info->indev); 215 if (info->outdev) dev_put(info->outdev); 216 #ifdef CONFIG_BRIDGE_NETFILTER 217 if (skb->nf_bridge) { 218 if (skb->nf_bridge->physindev) 219 dev_put(skb->nf_bridge->physindev); 220 if (skb->nf_bridge->physoutdev) 221 dev_put(skb->nf_bridge->physoutdev); 222 } 223 #endif 224 225 /* Drop reference to owner of hook which queued us. */ 226 module_put(info->elem->owner); 227 228 list_for_each_rcu(i, &nf_hooks[info->pf][info->hook]) { 229 if (i == elem) 230 break; 231 } 232 233 if (i == &nf_hooks[info->pf][info->hook]) { 234 /* The module which sent it to userspace is gone. */ 235 NFDEBUG("%s: module disappeared, dropping packet.\n", 236 __FUNCTION__); 237 verdict = NF_DROP; 238 } 239 240 /* Continue traversal iff userspace said ok... */ 241 if (verdict == NF_REPEAT) { 242 elem = elem->prev; 243 verdict = NF_ACCEPT; 244 } 245 246 if (verdict == NF_ACCEPT) { 247 afinfo = nf_get_afinfo(info->pf); 248 if (!afinfo || afinfo->reroute(&skb, info) < 0) 249 verdict = NF_DROP; 250 } 251 252 if (verdict == NF_ACCEPT) { 253 next_hook: 254 verdict = nf_iterate(&nf_hooks[info->pf][info->hook], 255 &skb, info->hook, 256 info->indev, info->outdev, &elem, 257 info->okfn, INT_MIN); 258 } 259 260 switch (verdict & NF_VERDICT_MASK) { 261 case NF_ACCEPT: 262 case NF_STOP: 263 info->okfn(skb); 264 case NF_STOLEN: 265 break; 266 case NF_QUEUE: 267 if (!__nf_queue(skb, elem, info->pf, info->hook, 268 info->indev, info->outdev, info->okfn, 269 verdict >> NF_VERDICT_BITS)) 270 goto next_hook; 271 break; 272 default: 273 kfree_skb(skb); 274 } 275 rcu_read_unlock(); 276 kfree(info); 277 return; 278 } 279 EXPORT_SYMBOL(nf_reinject); 280 281 #ifdef CONFIG_PROC_FS 282 static void *seq_start(struct seq_file *seq, loff_t *pos) 283 { 284 if (*pos >= NPROTO) 285 return NULL; 286 287 return pos; 288 } 289 290 static void *seq_next(struct seq_file *s, void *v, loff_t *pos) 291 { 292 (*pos)++; 293 294 if (*pos >= NPROTO) 295 return NULL; 296 297 return pos; 298 } 299 300 static void seq_stop(struct seq_file *s, void *v) 301 { 302 303 } 304 305 static int seq_show(struct seq_file *s, void *v) 306 { 307 int ret; 308 loff_t *pos = v; 309 struct nf_queue_handler *qh; 310 311 read_lock_bh(&queue_handler_lock); 312 qh = queue_handler[*pos]; 313 if (!qh) 314 ret = seq_printf(s, "%2lld NONE\n", *pos); 315 else 316 ret = seq_printf(s, "%2lld %s\n", *pos, qh->name); 317 read_unlock_bh(&queue_handler_lock); 318 319 return ret; 320 } 321 322 static struct seq_operations nfqueue_seq_ops = { 323 .start = seq_start, 324 .next = seq_next, 325 .stop = seq_stop, 326 .show = seq_show, 327 }; 328 329 static int nfqueue_open(struct inode *inode, struct file *file) 330 { 331 return seq_open(file, &nfqueue_seq_ops); 332 } 333 334 static const struct file_operations nfqueue_file_ops = { 335 .owner = THIS_MODULE, 336 .open = nfqueue_open, 337 .read = seq_read, 338 .llseek = seq_lseek, 339 .release = seq_release, 340 }; 341 #endif /* PROC_FS */ 342 343 344 int __init netfilter_queue_init(void) 345 { 346 #ifdef CONFIG_PROC_FS 347 struct proc_dir_entry *pde; 348 349 pde = create_proc_entry("nf_queue", S_IRUGO, proc_net_netfilter); 350 if (!pde) 351 return -1; 352 pde->proc_fops = &nfqueue_file_ops; 353 #endif 354 return 0; 355 } 356 357