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