Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/shaggy...
[linux-2.6] / net / ipv4 / ipvs / ip_vs_app.c
1 /*
2  * ip_vs_app.c: Application module support for IPVS
3  *
4  * Version:     $Id: ip_vs_app.c,v 1.17 2003/03/22 06:31:21 wensong Exp $
5  *
6  * Authors:     Wensong Zhang <wensong@linuxvirtualserver.org>
7  *
8  *              This program is free software; you can redistribute it and/or
9  *              modify it under the terms of the GNU General Public License
10  *              as published by the Free Software Foundation; either version
11  *              2 of the License, or (at your option) any later version.
12  *
13  * Most code here is taken from ip_masq_app.c in kernel 2.2. The difference
14  * is that ip_vs_app module handles the reverse direction (incoming requests
15  * and outgoing responses).
16  *
17  *              IP_MASQ_APP application masquerading module
18  *
19  * Author:      Juan Jose Ciarlante, <jjciarla@raiz.uncu.edu.ar>
20  *
21  */
22
23 #include <linux/module.h>
24 #include <linux/kernel.h>
25 #include <linux/skbuff.h>
26 #include <linux/in.h>
27 #include <linux/ip.h>
28 #include <net/protocol.h>
29 #include <net/tcp.h>
30 #include <asm/system.h>
31 #include <linux/stat.h>
32 #include <linux/proc_fs.h>
33 #include <linux/seq_file.h>
34
35 #include <net/ip_vs.h>
36
37 EXPORT_SYMBOL(register_ip_vs_app);
38 EXPORT_SYMBOL(unregister_ip_vs_app);
39 EXPORT_SYMBOL(register_ip_vs_app_inc);
40
41 /* ipvs application list head */
42 static LIST_HEAD(ip_vs_app_list);
43 static DECLARE_MUTEX(__ip_vs_app_mutex);
44
45
46 /*
47  *      Get an ip_vs_app object
48  */
49 static inline int ip_vs_app_get(struct ip_vs_app *app)
50 {
51         /* test and get the module atomically */
52         if (app->module)
53                 return try_module_get(app->module);
54         else
55                 return 1;
56 }
57
58
59 static inline void ip_vs_app_put(struct ip_vs_app *app)
60 {
61         if (app->module)
62                 module_put(app->module);
63 }
64
65
66 /*
67  *      Allocate/initialize app incarnation and register it in proto apps.
68  */
69 static int
70 ip_vs_app_inc_new(struct ip_vs_app *app, __u16 proto, __u16 port)
71 {
72         struct ip_vs_protocol *pp;
73         struct ip_vs_app *inc;
74         int ret;
75
76         if (!(pp = ip_vs_proto_get(proto)))
77                 return -EPROTONOSUPPORT;
78
79         if (!pp->unregister_app)
80                 return -EOPNOTSUPP;
81
82         inc = kmalloc(sizeof(struct ip_vs_app), GFP_KERNEL);
83         if (!inc)
84                 return -ENOMEM;
85         memcpy(inc, app, sizeof(*inc));
86         INIT_LIST_HEAD(&inc->p_list);
87         INIT_LIST_HEAD(&inc->incs_list);
88         inc->app = app;
89         inc->port = htons(port);
90         atomic_set(&inc->usecnt, 0);
91
92         if (app->timeouts) {
93                 inc->timeout_table =
94                         ip_vs_create_timeout_table(app->timeouts,
95                                                    app->timeouts_size);
96                 if (!inc->timeout_table) {
97                         ret = -ENOMEM;
98                         goto out;
99                 }
100         }
101
102         ret = pp->register_app(inc);
103         if (ret)
104                 goto out;
105
106         list_add(&inc->a_list, &app->incs_list);
107         IP_VS_DBG(9, "%s application %s:%u registered\n",
108                   pp->name, inc->name, inc->port);
109
110         return 0;
111
112   out:
113         if (inc->timeout_table)
114                 kfree(inc->timeout_table);
115         kfree(inc);
116         return ret;
117 }
118
119
120 /*
121  *      Release app incarnation
122  */
123 static void
124 ip_vs_app_inc_release(struct ip_vs_app *inc)
125 {
126         struct ip_vs_protocol *pp;
127
128         if (!(pp = ip_vs_proto_get(inc->protocol)))
129                 return;
130
131         if (pp->unregister_app)
132                 pp->unregister_app(inc);
133
134         IP_VS_DBG(9, "%s App %s:%u unregistered\n",
135                   pp->name, inc->name, inc->port);
136
137         list_del(&inc->a_list);
138
139         if (inc->timeout_table != NULL)
140                 kfree(inc->timeout_table);
141         kfree(inc);
142 }
143
144
145 /*
146  *      Get reference to app inc (only called from softirq)
147  *
148  */
149 int ip_vs_app_inc_get(struct ip_vs_app *inc)
150 {
151         int result;
152
153         atomic_inc(&inc->usecnt);
154         if (unlikely((result = ip_vs_app_get(inc->app)) != 1))
155                 atomic_dec(&inc->usecnt);
156         return result;
157 }
158
159
160 /*
161  *      Put the app inc (only called from timer or net softirq)
162  */
163 void ip_vs_app_inc_put(struct ip_vs_app *inc)
164 {
165         ip_vs_app_put(inc->app);
166         atomic_dec(&inc->usecnt);
167 }
168
169
170 /*
171  *      Register an application incarnation in protocol applications
172  */
173 int
174 register_ip_vs_app_inc(struct ip_vs_app *app, __u16 proto, __u16 port)
175 {
176         int result;
177
178         down(&__ip_vs_app_mutex);
179
180         result = ip_vs_app_inc_new(app, proto, port);
181
182         up(&__ip_vs_app_mutex);
183
184         return result;
185 }
186
187
188 /*
189  *      ip_vs_app registration routine
190  */
191 int register_ip_vs_app(struct ip_vs_app *app)
192 {
193         /* increase the module use count */
194         ip_vs_use_count_inc();
195
196         down(&__ip_vs_app_mutex);
197
198         list_add(&app->a_list, &ip_vs_app_list);
199
200         up(&__ip_vs_app_mutex);
201
202         return 0;
203 }
204
205
206 /*
207  *      ip_vs_app unregistration routine
208  *      We are sure there are no app incarnations attached to services
209  */
210 void unregister_ip_vs_app(struct ip_vs_app *app)
211 {
212         struct ip_vs_app *inc, *nxt;
213
214         down(&__ip_vs_app_mutex);
215
216         list_for_each_entry_safe(inc, nxt, &app->incs_list, a_list) {
217                 ip_vs_app_inc_release(inc);
218         }
219
220         list_del(&app->a_list);
221
222         up(&__ip_vs_app_mutex);
223
224         /* decrease the module use count */
225         ip_vs_use_count_dec();
226 }
227
228
229 #if 0000
230 /*
231  *      Get reference to app by name (called from user context)
232  */
233 struct ip_vs_app *ip_vs_app_get_by_name(char *appname)
234 {
235         struct ip_vs_app *app, *a = NULL;
236
237         down(&__ip_vs_app_mutex);
238
239         list_for_each_entry(ent, &ip_vs_app_list, a_list) {
240                 if (strcmp(app->name, appname))
241                         continue;
242
243                 /* softirq may call ip_vs_app_get too, so the caller
244                    must disable softirq on the current CPU */
245                 if (ip_vs_app_get(app))
246                         a = app;
247                 break;
248         }
249
250         up(&__ip_vs_app_mutex);
251
252         return a;
253 }
254 #endif
255
256
257 /*
258  *      Bind ip_vs_conn to its ip_vs_app (called by cp constructor)
259  */
260 int ip_vs_bind_app(struct ip_vs_conn *cp, struct ip_vs_protocol *pp)
261 {
262         return pp->app_conn_bind(cp);
263 }
264
265
266 /*
267  *      Unbind cp from application incarnation (called by cp destructor)
268  */
269 void ip_vs_unbind_app(struct ip_vs_conn *cp)
270 {
271         struct ip_vs_app *inc = cp->app;
272
273         if (!inc)
274                 return;
275
276         if (inc->unbind_conn)
277                 inc->unbind_conn(inc, cp);
278         if (inc->done_conn)
279                 inc->done_conn(inc, cp);
280         ip_vs_app_inc_put(inc);
281         cp->app = NULL;
282 }
283
284
285 /*
286  *      Fixes th->seq based on ip_vs_seq info.
287  */
288 static inline void vs_fix_seq(const struct ip_vs_seq *vseq, struct tcphdr *th)
289 {
290         __u32 seq = ntohl(th->seq);
291
292         /*
293          *      Adjust seq with delta-offset for all packets after
294          *      the most recent resized pkt seq and with previous_delta offset
295          *      for all packets before most recent resized pkt seq.
296          */
297         if (vseq->delta || vseq->previous_delta) {
298                 if(after(seq, vseq->init_seq)) {
299                         th->seq = htonl(seq + vseq->delta);
300                         IP_VS_DBG(9, "vs_fix_seq(): added delta (%d) to seq\n",
301                                   vseq->delta);
302                 } else {
303                         th->seq = htonl(seq + vseq->previous_delta);
304                         IP_VS_DBG(9, "vs_fix_seq(): added previous_delta "
305                                   "(%d) to seq\n", vseq->previous_delta);
306                 }
307         }
308 }
309
310
311 /*
312  *      Fixes th->ack_seq based on ip_vs_seq info.
313  */
314 static inline void
315 vs_fix_ack_seq(const struct ip_vs_seq *vseq, struct tcphdr *th)
316 {
317         __u32 ack_seq = ntohl(th->ack_seq);
318
319         /*
320          * Adjust ack_seq with delta-offset for
321          * the packets AFTER most recent resized pkt has caused a shift
322          * for packets before most recent resized pkt, use previous_delta
323          */
324         if (vseq->delta || vseq->previous_delta) {
325                 /* since ack_seq is the number of octet that is expected
326                    to receive next, so compare it with init_seq+delta */
327                 if(after(ack_seq, vseq->init_seq+vseq->delta)) {
328                         th->ack_seq = htonl(ack_seq - vseq->delta);
329                         IP_VS_DBG(9, "vs_fix_ack_seq(): subtracted delta "
330                                   "(%d) from ack_seq\n", vseq->delta);
331
332                 } else {
333                         th->ack_seq = htonl(ack_seq - vseq->previous_delta);
334                         IP_VS_DBG(9, "vs_fix_ack_seq(): subtracted "
335                                   "previous_delta (%d) from ack_seq\n",
336                                   vseq->previous_delta);
337                 }
338         }
339 }
340
341
342 /*
343  *      Updates ip_vs_seq if pkt has been resized
344  *      Assumes already checked proto==IPPROTO_TCP and diff!=0.
345  */
346 static inline void vs_seq_update(struct ip_vs_conn *cp, struct ip_vs_seq *vseq,
347                                  unsigned flag, __u32 seq, int diff)
348 {
349         /* spinlock is to keep updating cp->flags atomic */
350         spin_lock(&cp->lock);
351         if (!(cp->flags & flag) || after(seq, vseq->init_seq)) {
352                 vseq->previous_delta = vseq->delta;
353                 vseq->delta += diff;
354                 vseq->init_seq = seq;
355                 cp->flags |= flag;
356         }
357         spin_unlock(&cp->lock);
358 }
359
360 static inline int app_tcp_pkt_out(struct ip_vs_conn *cp, struct sk_buff **pskb,
361                                   struct ip_vs_app *app)
362 {
363         int diff;
364         unsigned int tcp_offset = (*pskb)->nh.iph->ihl*4;
365         struct tcphdr *th;
366         __u32 seq;
367
368         if (!ip_vs_make_skb_writable(pskb, tcp_offset + sizeof(*th)))
369                 return 0;
370
371         th = (struct tcphdr *)((*pskb)->nh.raw + tcp_offset);
372
373         /*
374          *      Remember seq number in case this pkt gets resized
375          */
376         seq = ntohl(th->seq);
377
378         /*
379          *      Fix seq stuff if flagged as so.
380          */
381         if (cp->flags & IP_VS_CONN_F_OUT_SEQ)
382                 vs_fix_seq(&cp->out_seq, th);
383         if (cp->flags & IP_VS_CONN_F_IN_SEQ)
384                 vs_fix_ack_seq(&cp->in_seq, th);
385
386         /*
387          *      Call private output hook function
388          */
389         if (app->pkt_out == NULL)
390                 return 1;
391
392         if (!app->pkt_out(app, cp, pskb, &diff))
393                 return 0;
394
395         /*
396          *      Update ip_vs seq stuff if len has changed.
397          */
398         if (diff != 0)
399                 vs_seq_update(cp, &cp->out_seq,
400                               IP_VS_CONN_F_OUT_SEQ, seq, diff);
401
402         return 1;
403 }
404
405 /*
406  *      Output pkt hook. Will call bound ip_vs_app specific function
407  *      called by ipvs packet handler, assumes previously checked cp!=NULL
408  *      returns false if it can't handle packet (oom)
409  */
410 int ip_vs_app_pkt_out(struct ip_vs_conn *cp, struct sk_buff **pskb)
411 {
412         struct ip_vs_app *app;
413
414         /*
415          *      check if application module is bound to
416          *      this ip_vs_conn.
417          */
418         if ((app = cp->app) == NULL)
419                 return 1;
420
421         /* TCP is complicated */
422         if (cp->protocol == IPPROTO_TCP)
423                 return app_tcp_pkt_out(cp, pskb, app);
424
425         /*
426          *      Call private output hook function
427          */
428         if (app->pkt_out == NULL)
429                 return 1;
430
431         return app->pkt_out(app, cp, pskb, NULL);
432 }
433
434
435 static inline int app_tcp_pkt_in(struct ip_vs_conn *cp, struct sk_buff **pskb,
436                                  struct ip_vs_app *app)
437 {
438         int diff;
439         unsigned int tcp_offset = (*pskb)->nh.iph->ihl*4;
440         struct tcphdr *th;
441         __u32 seq;
442
443         if (!ip_vs_make_skb_writable(pskb, tcp_offset + sizeof(*th)))
444                 return 0;
445
446         th = (struct tcphdr *)((*pskb)->nh.raw + tcp_offset);
447
448         /*
449          *      Remember seq number in case this pkt gets resized
450          */
451         seq = ntohl(th->seq);
452
453         /*
454          *      Fix seq stuff if flagged as so.
455          */
456         if (cp->flags & IP_VS_CONN_F_IN_SEQ)
457                 vs_fix_seq(&cp->in_seq, th);
458         if (cp->flags & IP_VS_CONN_F_OUT_SEQ)
459                 vs_fix_ack_seq(&cp->out_seq, th);
460
461         /*
462          *      Call private input hook function
463          */
464         if (app->pkt_in == NULL)
465                 return 1;
466
467         if (!app->pkt_in(app, cp, pskb, &diff))
468                 return 0;
469
470         /*
471          *      Update ip_vs seq stuff if len has changed.
472          */
473         if (diff != 0)
474                 vs_seq_update(cp, &cp->in_seq,
475                               IP_VS_CONN_F_IN_SEQ, seq, diff);
476
477         return 1;
478 }
479
480 /*
481  *      Input pkt hook. Will call bound ip_vs_app specific function
482  *      called by ipvs packet handler, assumes previously checked cp!=NULL.
483  *      returns false if can't handle packet (oom).
484  */
485 int ip_vs_app_pkt_in(struct ip_vs_conn *cp, struct sk_buff **pskb)
486 {
487         struct ip_vs_app *app;
488
489         /*
490          *      check if application module is bound to
491          *      this ip_vs_conn.
492          */
493         if ((app = cp->app) == NULL)
494                 return 1;
495
496         /* TCP is complicated */
497         if (cp->protocol == IPPROTO_TCP)
498                 return app_tcp_pkt_in(cp, pskb, app);
499
500         /*
501          *      Call private input hook function
502          */
503         if (app->pkt_in == NULL)
504                 return 1;
505
506         return app->pkt_in(app, cp, pskb, NULL);
507 }
508
509
510 #ifdef CONFIG_PROC_FS
511 /*
512  *      /proc/net/ip_vs_app entry function
513  */
514
515 static struct ip_vs_app *ip_vs_app_idx(loff_t pos)
516 {
517         struct ip_vs_app *app, *inc;
518
519         list_for_each_entry(app, &ip_vs_app_list, a_list) {
520                 list_for_each_entry(inc, &app->incs_list, a_list) {
521                         if (pos-- == 0)
522                                 return inc;
523                 }
524         }
525         return NULL;
526
527 }
528
529 static void *ip_vs_app_seq_start(struct seq_file *seq, loff_t *pos)
530 {
531         down(&__ip_vs_app_mutex);
532
533         return *pos ? ip_vs_app_idx(*pos - 1) : SEQ_START_TOKEN;
534 }
535
536 static void *ip_vs_app_seq_next(struct seq_file *seq, void *v, loff_t *pos)
537 {
538         struct ip_vs_app *inc, *app;
539         struct list_head *e;
540
541         ++*pos;
542         if (v == SEQ_START_TOKEN)
543                 return ip_vs_app_idx(0);
544
545         inc = v;
546         app = inc->app;
547
548         if ((e = inc->a_list.next) != &app->incs_list)
549                 return list_entry(e, struct ip_vs_app, a_list);
550
551         /* go on to next application */
552         for (e = app->a_list.next; e != &ip_vs_app_list; e = e->next) {
553                 app = list_entry(e, struct ip_vs_app, a_list);
554                 list_for_each_entry(inc, &app->incs_list, a_list) {
555                         return inc;
556                 }
557         }
558         return NULL;
559 }
560
561 static void ip_vs_app_seq_stop(struct seq_file *seq, void *v)
562 {
563         up(&__ip_vs_app_mutex);
564 }
565
566 static int ip_vs_app_seq_show(struct seq_file *seq, void *v)
567 {
568         if (v == SEQ_START_TOKEN)
569                 seq_puts(seq, "prot port    usecnt name\n");
570         else {
571                 const struct ip_vs_app *inc = v;
572
573                 seq_printf(seq, "%-3s  %-7u %-6d %-17s\n",
574                            ip_vs_proto_name(inc->protocol),
575                            ntohs(inc->port),
576                            atomic_read(&inc->usecnt),
577                            inc->name);
578         }
579         return 0;
580 }
581
582 static struct seq_operations ip_vs_app_seq_ops = {
583         .start = ip_vs_app_seq_start,
584         .next  = ip_vs_app_seq_next,
585         .stop  = ip_vs_app_seq_stop,
586         .show  = ip_vs_app_seq_show,
587 };
588
589 static int ip_vs_app_open(struct inode *inode, struct file *file)
590 {
591         return seq_open(file, &ip_vs_app_seq_ops);
592 }
593
594 static struct file_operations ip_vs_app_fops = {
595         .owner   = THIS_MODULE,
596         .open    = ip_vs_app_open,
597         .read    = seq_read,
598         .llseek  = seq_lseek,
599         .release = seq_release,
600 };
601 #endif
602
603
604 /*
605  *      Replace a segment of data with a new segment
606  */
607 int ip_vs_skb_replace(struct sk_buff *skb, gfp_t pri,
608                       char *o_buf, int o_len, char *n_buf, int n_len)
609 {
610         struct iphdr *iph;
611         int diff;
612         int o_offset;
613         int o_left;
614
615         EnterFunction(9);
616
617         diff = n_len - o_len;
618         o_offset = o_buf - (char *)skb->data;
619         /* The length of left data after o_buf+o_len in the skb data */
620         o_left = skb->len - (o_offset + o_len);
621
622         if (diff <= 0) {
623                 memmove(o_buf + n_len, o_buf + o_len, o_left);
624                 memcpy(o_buf, n_buf, n_len);
625                 skb_trim(skb, skb->len + diff);
626         } else if (diff <= skb_tailroom(skb)) {
627                 skb_put(skb, diff);
628                 memmove(o_buf + n_len, o_buf + o_len, o_left);
629                 memcpy(o_buf, n_buf, n_len);
630         } else {
631                 if (pskb_expand_head(skb, skb_headroom(skb), diff, pri))
632                         return -ENOMEM;
633                 skb_put(skb, diff);
634                 memmove(skb->data + o_offset + n_len,
635                         skb->data + o_offset + o_len, o_left);
636                 memcpy(skb->data + o_offset, n_buf, n_len);
637         }
638
639         /* must update the iph total length here */
640         iph = skb->nh.iph;
641         iph->tot_len = htons(skb->len);
642
643         LeaveFunction(9);
644         return 0;
645 }
646
647
648 int ip_vs_app_init(void)
649 {
650         /* we will replace it with proc_net_ipvs_create() soon */
651         proc_net_fops_create("ip_vs_app", 0, &ip_vs_app_fops);
652         return 0;
653 }
654
655
656 void ip_vs_app_cleanup(void)
657 {
658         proc_net_remove("ip_vs_app");
659 }