blob: fbe660f958731d7ec390effbb27046fff59953d6 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * IP Virtual Server
3 * data structure and functionality definitions
4 */
5
Julius Volzbc4768e2008-07-31 20:45:24 -07006#ifndef _NET_IP_VS_H
7#define _NET_IP_VS_H
Linus Torvalds1da177e2005-04-16 15:20:36 -07008
Julius Volzbc4768e2008-07-31 20:45:24 -07009#include <linux/ip_vs.h> /* definitions shared with userland */
Linus Torvalds1da177e2005-04-16 15:20:36 -070010
Julius Volzbc4768e2008-07-31 20:45:24 -070011/* old ipvsadm versions still include this file directly */
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#ifdef __KERNEL__
13
Julius Volzbc4768e2008-07-31 20:45:24 -070014#include <asm/types.h> /* for __uXX types */
15
16#include <linux/sysctl.h> /* for ctl_path */
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/list.h> /* for struct list_head */
18#include <linux/spinlock.h> /* for struct rwlock_t */
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <asm/atomic.h> /* for struct atomic_t */
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/compiler.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020021#include <linux/timer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020023#include <net/checksum.h>
Julius Volze7ade462008-09-02 15:55:33 +020024#include <linux/netfilter.h> /* for union nf_inet_addr */
KOVACS Krisztian1668e012008-10-01 07:33:10 -070025#include <linux/ip.h>
Julius Volze7ade462008-09-02 15:55:33 +020026#include <linux/ipv6.h> /* for struct ipv6hdr */
27#include <net/ipv6.h> /* for ipv6_addr_copy */
Julian Anastasovcf356d62010-10-17 16:21:07 +030028#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Julian Anastasovf4bc17c2010-09-21 17:35:41 +020029#include <net/netfilter/nf_conntrack.h>
30#endif
Hans Schillstrom61b1ab42011-01-03 14:44:42 +010031#include <net/net_namespace.h> /* Netw namespace */
32
33/*
34 * Generic access of ipvs struct
35 */
36static inline struct netns_ipvs *net_ipvs(struct net* net)
37{
38 return net->ipvs;
39}
Hans Schillstromfc723252011-01-03 14:44:43 +010040/*
41 * Get net ptr from skb in traffic cases
42 * use skb_sknet when call is from userland (ioctl or netlink)
43 */
Hans Schillstroma0840e22011-01-03 14:44:58 +010044static inline struct net *skb_net(const struct sk_buff *skb)
Hans Schillstromfc723252011-01-03 14:44:43 +010045{
46#ifdef CONFIG_NET_NS
47#ifdef CONFIG_IP_VS_DEBUG
48 /*
49 * This is used for debug only.
50 * Start with the most likely hit
51 * End with BUG
52 */
53 if (likely(skb->dev && skb->dev->nd_net))
54 return dev_net(skb->dev);
55 if (skb_dst(skb)->dev)
56 return dev_net(skb_dst(skb)->dev);
57 WARN(skb->sk, "Maybe skb_sknet should be used in %s() at line:%d\n",
58 __func__, __LINE__);
59 if (likely(skb->sk && skb->sk->sk_net))
60 return sock_net(skb->sk);
61 pr_err("There is no net ptr to find in the skb in %s() line:%d\n",
62 __func__, __LINE__);
63 BUG();
64#else
65 return dev_net(skb->dev ? : skb_dst(skb)->dev);
66#endif
67#else
68 return &init_net;
69#endif
70}
71
Hans Schillstroma0840e22011-01-03 14:44:58 +010072static inline struct net *skb_sknet(const struct sk_buff *skb)
Hans Schillstromfc723252011-01-03 14:44:43 +010073{
74#ifdef CONFIG_NET_NS
75#ifdef CONFIG_IP_VS_DEBUG
76 /* Start with the most likely hit */
77 if (likely(skb->sk && skb->sk->sk_net))
78 return sock_net(skb->sk);
79 WARN(skb->dev, "Maybe skb_net should be used instead in %s() line:%d\n",
80 __func__, __LINE__);
81 if (likely(skb->dev && skb->dev->nd_net))
82 return dev_net(skb->dev);
83 pr_err("There is no net ptr to find in the skb in %s() line:%d\n",
84 __func__, __LINE__);
85 BUG();
86#else
87 return sock_net(skb->sk);
88#endif
89#else
90 return &init_net;
91#endif
92}
Hans Schillstromb17fc992011-01-03 14:44:56 +010093/*
94 * This one needed for single_open_net since net is stored directly in
95 * private not as a struct i.e. seq_file_net cant be used.
96 */
97static inline struct net *seq_file_single_net(struct seq_file *seq)
98{
99#ifdef CONFIG_NET_NS
100 return (struct net *)seq->private;
101#else
102 return &init_net;
103#endif
104}
Catalin(ux) M. BOIE6f7edb42010-01-05 05:50:24 +0100105
106/* Connections' size value needed by ip_vs_ctl.c */
107extern int ip_vs_conn_tab_size;
108
109
Julius Volz64aae3c2008-09-02 15:55:34 +0200110struct ip_vs_iphdr {
111 int len;
112 __u8 protocol;
113 union nf_inet_addr saddr;
114 union nf_inet_addr daddr;
115};
116
117static inline void
118ip_vs_fill_iphdr(int af, const void *nh, struct ip_vs_iphdr *iphdr)
119{
120#ifdef CONFIG_IP_VS_IPV6
121 if (af == AF_INET6) {
122 const struct ipv6hdr *iph = nh;
123 iphdr->len = sizeof(struct ipv6hdr);
124 iphdr->protocol = iph->nexthdr;
125 ipv6_addr_copy(&iphdr->saddr.in6, &iph->saddr);
126 ipv6_addr_copy(&iphdr->daddr.in6, &iph->daddr);
127 } else
128#endif
129 {
130 const struct iphdr *iph = nh;
131 iphdr->len = iph->ihl * 4;
132 iphdr->protocol = iph->protocol;
133 iphdr->saddr.ip = iph->saddr;
134 iphdr->daddr.ip = iph->daddr;
135 }
136}
137
138static inline void ip_vs_addr_copy(int af, union nf_inet_addr *dst,
139 const union nf_inet_addr *src)
140{
141#ifdef CONFIG_IP_VS_IPV6
142 if (af == AF_INET6)
143 ipv6_addr_copy(&dst->in6, &src->in6);
144 else
145#endif
146 dst->ip = src->ip;
147}
148
149static inline int ip_vs_addr_equal(int af, const union nf_inet_addr *a,
150 const union nf_inet_addr *b)
151{
152#ifdef CONFIG_IP_VS_IPV6
153 if (af == AF_INET6)
154 return ipv6_addr_equal(&a->in6, &b->in6);
155#endif
156 return a->ip == b->ip;
157}
158
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159#ifdef CONFIG_IP_VS_DEBUG
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -0200160#include <linux/net.h>
161
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162extern int ip_vs_get_debug_level(void);
Julius Volzc842a3a2008-09-02 15:55:35 +0200163
164static inline const char *ip_vs_dbg_addr(int af, char *buf, size_t buf_len,
165 const union nf_inet_addr *addr,
166 int *idx)
167{
168 int len;
169#ifdef CONFIG_IP_VS_IPV6
170 if (af == AF_INET6)
Harvey Harrison5b095d9892008-10-29 12:52:50 -0700171 len = snprintf(&buf[*idx], buf_len - *idx, "[%pI6]",
Harvey Harrison0c6ce782008-10-28 16:09:23 -0700172 &addr->in6) + 1;
Julius Volzc842a3a2008-09-02 15:55:35 +0200173 else
174#endif
Harvey Harrison3685f25d2008-10-31 00:56:49 -0700175 len = snprintf(&buf[*idx], buf_len - *idx, "%pI4",
176 &addr->ip) + 1;
Julius Volzc842a3a2008-09-02 15:55:35 +0200177
178 *idx += len;
179 BUG_ON(*idx > buf_len + 1);
180 return &buf[*idx - len];
181}
182
Hannes Eder9aada7a2009-07-30 14:29:44 -0700183#define IP_VS_DBG_BUF(level, msg, ...) \
184 do { \
185 char ip_vs_dbg_buf[160]; \
186 int ip_vs_dbg_idx = 0; \
187 if (level <= ip_vs_get_debug_level()) \
188 printk(KERN_DEBUG pr_fmt(msg), ##__VA_ARGS__); \
189 } while (0)
190#define IP_VS_ERR_BUF(msg...) \
191 do { \
192 char ip_vs_dbg_buf[160]; \
193 int ip_vs_dbg_idx = 0; \
194 pr_err(msg); \
195 } while (0)
Julius Volzc842a3a2008-09-02 15:55:35 +0200196
197/* Only use from within IP_VS_DBG_BUF() or IP_VS_ERR_BUF macros */
Hannes Eder9aada7a2009-07-30 14:29:44 -0700198#define IP_VS_DBG_ADDR(af, addr) \
199 ip_vs_dbg_addr(af, ip_vs_dbg_buf, \
200 sizeof(ip_vs_dbg_buf), addr, \
201 &ip_vs_dbg_idx)
Julius Volzc842a3a2008-09-02 15:55:35 +0200202
Hannes Eder9aada7a2009-07-30 14:29:44 -0700203#define IP_VS_DBG(level, msg, ...) \
204 do { \
205 if (level <= ip_vs_get_debug_level()) \
206 printk(KERN_DEBUG pr_fmt(msg), ##__VA_ARGS__); \
207 } while (0)
208#define IP_VS_DBG_RL(msg, ...) \
209 do { \
210 if (net_ratelimit()) \
211 printk(KERN_DEBUG pr_fmt(msg), ##__VA_ARGS__); \
212 } while (0)
Julian Anastasov0d796412010-10-17 16:46:17 +0300213#define IP_VS_DBG_PKT(level, af, pp, skb, ofs, msg) \
Hannes Eder9aada7a2009-07-30 14:29:44 -0700214 do { \
215 if (level <= ip_vs_get_debug_level()) \
Julian Anastasov0d796412010-10-17 16:46:17 +0300216 pp->debug_packet(af, pp, skb, ofs, msg); \
Hannes Eder9aada7a2009-07-30 14:29:44 -0700217 } while (0)
Julian Anastasov0d796412010-10-17 16:46:17 +0300218#define IP_VS_DBG_RL_PKT(level, af, pp, skb, ofs, msg) \
Hannes Eder9aada7a2009-07-30 14:29:44 -0700219 do { \
220 if (level <= ip_vs_get_debug_level() && \
221 net_ratelimit()) \
Julian Anastasov0d796412010-10-17 16:46:17 +0300222 pp->debug_packet(af, pp, skb, ofs, msg); \
Hannes Eder9aada7a2009-07-30 14:29:44 -0700223 } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224#else /* NO DEBUGGING at ALL */
Julius Volzc842a3a2008-09-02 15:55:35 +0200225#define IP_VS_DBG_BUF(level, msg...) do {} while (0)
226#define IP_VS_ERR_BUF(msg...) do {} while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227#define IP_VS_DBG(level, msg...) do {} while (0)
228#define IP_VS_DBG_RL(msg...) do {} while (0)
Julian Anastasov0d796412010-10-17 16:46:17 +0300229#define IP_VS_DBG_PKT(level, af, pp, skb, ofs, msg) do {} while (0)
230#define IP_VS_DBG_RL_PKT(level, af, pp, skb, ofs, msg) do {} while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231#endif
232
233#define IP_VS_BUG() BUG()
Hannes Eder1e3e2382009-08-02 11:05:41 +0000234#define IP_VS_ERR_RL(msg, ...) \
Hannes Eder9aada7a2009-07-30 14:29:44 -0700235 do { \
236 if (net_ratelimit()) \
Hannes Eder1e3e2382009-08-02 11:05:41 +0000237 pr_err(msg, ##__VA_ARGS__); \
Hannes Eder9aada7a2009-07-30 14:29:44 -0700238 } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239
240#ifdef CONFIG_IP_VS_DEBUG
241#define EnterFunction(level) \
Hannes Eder9aada7a2009-07-30 14:29:44 -0700242 do { \
243 if (level <= ip_vs_get_debug_level()) \
244 printk(KERN_DEBUG \
245 pr_fmt("Enter: %s, %s line %i\n"), \
246 __func__, __FILE__, __LINE__); \
247 } while (0)
248#define LeaveFunction(level) \
249 do { \
250 if (level <= ip_vs_get_debug_level()) \
251 printk(KERN_DEBUG \
252 pr_fmt("Leave: %s, %s line %i\n"), \
253 __func__, __FILE__, __LINE__); \
254 } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255#else
256#define EnterFunction(level) do {} while (0)
257#define LeaveFunction(level) do {} while (0)
258#endif
259
260#define IP_VS_WAIT_WHILE(expr) while (expr) { cpu_relax(); }
261
262
263/*
264 * The port number of FTP service (in network order).
265 */
Harvey Harrisonf3a7c662009-02-14 22:58:35 -0800266#define FTPPORT cpu_to_be16(21)
267#define FTPDATA cpu_to_be16(20)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268
269/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 * TCP State Values
271 */
272enum {
273 IP_VS_TCP_S_NONE = 0,
274 IP_VS_TCP_S_ESTABLISHED,
275 IP_VS_TCP_S_SYN_SENT,
276 IP_VS_TCP_S_SYN_RECV,
277 IP_VS_TCP_S_FIN_WAIT,
278 IP_VS_TCP_S_TIME_WAIT,
279 IP_VS_TCP_S_CLOSE,
280 IP_VS_TCP_S_CLOSE_WAIT,
281 IP_VS_TCP_S_LAST_ACK,
282 IP_VS_TCP_S_LISTEN,
283 IP_VS_TCP_S_SYNACK,
284 IP_VS_TCP_S_LAST
285};
286
287/*
288 * UDP State Values
289 */
290enum {
291 IP_VS_UDP_S_NORMAL,
292 IP_VS_UDP_S_LAST,
293};
294
295/*
296 * ICMP State Values
297 */
298enum {
299 IP_VS_ICMP_S_NORMAL,
300 IP_VS_ICMP_S_LAST,
301};
302
303/*
Venkata Mohan Reddy2906f662010-02-18 12:31:05 +0100304 * SCTP State Values
305 */
306enum ip_vs_sctp_states {
307 IP_VS_SCTP_S_NONE,
308 IP_VS_SCTP_S_INIT_CLI,
309 IP_VS_SCTP_S_INIT_SER,
310 IP_VS_SCTP_S_INIT_ACK_CLI,
311 IP_VS_SCTP_S_INIT_ACK_SER,
312 IP_VS_SCTP_S_ECHO_CLI,
313 IP_VS_SCTP_S_ECHO_SER,
314 IP_VS_SCTP_S_ESTABLISHED,
315 IP_VS_SCTP_S_SHUT_CLI,
316 IP_VS_SCTP_S_SHUT_SER,
317 IP_VS_SCTP_S_SHUT_ACK_CLI,
318 IP_VS_SCTP_S_SHUT_ACK_SER,
319 IP_VS_SCTP_S_CLOSED,
320 IP_VS_SCTP_S_LAST
321};
322
323/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 * Delta sequence info structure
325 * Each ip_vs_conn has 2 (output AND input seq. changes).
326 * Only used in the VS/NAT.
327 */
328struct ip_vs_seq {
329 __u32 init_seq; /* Add delta from this seq */
330 __u32 delta; /* Delta in sequence numbers */
331 __u32 previous_delta; /* Delta in sequence numbers
332 before last resized pkt */
333};
334
Hans Schillstromb17fc992011-01-03 14:44:56 +0100335/*
336 * counters per cpu
337 */
338struct ip_vs_counters {
339 __u32 conns; /* connections scheduled */
340 __u32 inpkts; /* incoming packets */
341 __u32 outpkts; /* outgoing packets */
342 __u64 inbytes; /* incoming bytes */
343 __u64 outbytes; /* outgoing bytes */
344};
345/*
346 * Stats per cpu
347 */
348struct ip_vs_cpu_stats {
349 struct ip_vs_counters ustats;
350 struct u64_stats_sync syncp;
351};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352
353/*
Sven Wegener3a14a3132008-08-10 18:24:41 +0000354 * IPVS statistics objects
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 */
Sven Wegener3a14a3132008-08-10 18:24:41 +0000356struct ip_vs_estimator {
357 struct list_head list;
358
359 u64 last_inbytes;
360 u64 last_outbytes;
361 u32 last_conns;
362 u32 last_inpkts;
363 u32 last_outpkts;
364
365 u32 cps;
366 u32 inpps;
367 u32 outpps;
368 u32 inbps;
369 u32 outbps;
370};
371
Eric Dumazetfd2c3ef2009-11-03 03:26:03 +0000372struct ip_vs_stats {
Hans Schillstromb17fc992011-01-03 14:44:56 +0100373 struct ip_vs_stats_user ustats; /* statistics */
Sven Wegenere9c0ce22008-09-08 13:39:04 +0200374 struct ip_vs_estimator est; /* estimator */
Hans Schillstromb17fc992011-01-03 14:44:56 +0100375 struct ip_vs_cpu_stats *cpustats; /* per cpu counters */
376 spinlock_t lock; /* spin lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377};
378
Hans Schillstromb17fc992011-01-03 14:44:56 +0100379/*
380 * Helper Macros for per cpu
381 * ipvs->tot_stats->ustats.count
382 */
383#define IPVS_STAT_INC(ipvs, count) \
384 __this_cpu_inc((ipvs)->ustats->count)
385
386#define IPVS_STAT_ADD(ipvs, count, value) \
387 do {\
388 write_seqcount_begin(per_cpu_ptr((ipvs)->ustats_seq, \
389 raw_smp_processor_id())); \
390 __this_cpu_add((ipvs)->ustats->count, value); \
391 write_seqcount_end(per_cpu_ptr((ipvs)->ustats_seq, \
392 raw_smp_processor_id())); \
393 } while (0)
394
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -0200395struct dst_entry;
396struct iphdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397struct ip_vs_conn;
398struct ip_vs_app;
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -0200399struct sk_buff;
Hans Schillstrom252c6412011-01-03 14:44:46 +0100400struct ip_vs_proto_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401
402struct ip_vs_protocol {
403 struct ip_vs_protocol *next;
404 char *name;
Julian Anastasov2ad17de2008-04-29 03:21:23 -0700405 u16 protocol;
406 u16 num_states;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 int dont_defrag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
409 void (*init)(struct ip_vs_protocol *pp);
410
411 void (*exit)(struct ip_vs_protocol *pp);
412
Hans Schillstrom252c6412011-01-03 14:44:46 +0100413 void (*init_netns)(struct net *net, struct ip_vs_proto_data *pd);
414
415 void (*exit_netns)(struct net *net, struct ip_vs_proto_data *pd);
416
Julius Volz51ef3482008-09-02 15:55:40 +0200417 int (*conn_schedule)(int af, struct sk_buff *skb,
Hans Schillstrom93304192011-01-03 14:44:51 +0100418 struct ip_vs_proto_data *pd,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 int *verdict, struct ip_vs_conn **cpp);
420
421 struct ip_vs_conn *
Julius Volz51ef3482008-09-02 15:55:40 +0200422 (*conn_in_get)(int af,
423 const struct sk_buff *skb,
Julius Volz51ef3482008-09-02 15:55:40 +0200424 const struct ip_vs_iphdr *iph,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 unsigned int proto_off,
426 int inverse);
427
428 struct ip_vs_conn *
Julius Volz51ef3482008-09-02 15:55:40 +0200429 (*conn_out_get)(int af,
430 const struct sk_buff *skb,
Julius Volz51ef3482008-09-02 15:55:40 +0200431 const struct ip_vs_iphdr *iph,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 unsigned int proto_off,
433 int inverse);
434
Herbert Xu3db05fe2007-10-15 00:53:15 -0700435 int (*snat_handler)(struct sk_buff *skb,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 struct ip_vs_protocol *pp, struct ip_vs_conn *cp);
437
Herbert Xu3db05fe2007-10-15 00:53:15 -0700438 int (*dnat_handler)(struct sk_buff *skb,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 struct ip_vs_protocol *pp, struct ip_vs_conn *cp);
440
Julius Volz51ef3482008-09-02 15:55:40 +0200441 int (*csum_check)(int af, struct sk_buff *skb,
442 struct ip_vs_protocol *pp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443
444 const char *(*state_name)(int state);
445
446 int (*state_transition)(struct ip_vs_conn *cp, int direction,
447 const struct sk_buff *skb,
Hans Schillstrom93304192011-01-03 14:44:51 +0100448 struct ip_vs_proto_data *pd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449
Hans Schillstromab8a5e82011-01-03 14:44:53 +0100450 int (*register_app)(struct net *net, struct ip_vs_app *inc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451
Hans Schillstromab8a5e82011-01-03 14:44:53 +0100452 void (*unregister_app)(struct net *net, struct ip_vs_app *inc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453
454 int (*app_conn_bind)(struct ip_vs_conn *cp);
455
Julian Anastasov0d796412010-10-17 16:46:17 +0300456 void (*debug_packet)(int af, struct ip_vs_protocol *pp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 const struct sk_buff *skb,
458 int offset,
459 const char *msg);
460
Hans Schillstrom93304192011-01-03 14:44:51 +0100461 void (*timeout_change)(struct ip_vs_proto_data *pd, int flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462};
463
Hans Schillstrom252c6412011-01-03 14:44:46 +0100464/*
465 * protocol data per netns
466 */
467struct ip_vs_proto_data {
468 struct ip_vs_proto_data *next;
469 struct ip_vs_protocol *pp;
470 int *timeout_table; /* protocol timeout table */
471 atomic_t appcnt; /* counter of proto app incs. */
472 struct tcp_states_t *tcp_state_table;
473};
474
475extern struct ip_vs_protocol *ip_vs_proto_get(unsigned short proto);
476extern struct ip_vs_proto_data *ip_vs_proto_data_get(struct net *net,
477 unsigned short proto);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478
Simon Hormanf11017e2010-08-22 21:37:52 +0900479struct ip_vs_conn_param {
Hans Schillstrom6e67e582011-01-03 14:44:57 +0100480 struct net *net;
Simon Hormanf11017e2010-08-22 21:37:52 +0900481 const union nf_inet_addr *caddr;
482 const union nf_inet_addr *vaddr;
483 __be16 cport;
484 __be16 vport;
485 __u16 protocol;
486 u16 af;
Simon Horman85999282010-08-22 21:37:53 +0900487
488 const struct ip_vs_pe *pe;
489 char *pe_data;
490 __u8 pe_data_len;
Simon Hormanf11017e2010-08-22 21:37:52 +0900491};
492
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493/*
494 * IP_VS structure allocated for each dynamically scheduled connection
495 */
496struct ip_vs_conn {
497 struct list_head c_list; /* hashed list heads */
Hans Schillstrom6e67e582011-01-03 14:44:57 +0100498#ifdef CONFIG_NET_NS
499 struct net *net; /* Name space */
500#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 /* Protocol, addresses and port numbers */
Hans Schillstrom6e67e582011-01-03 14:44:57 +0100502 u16 af; /* address family */
503 __be16 cport;
504 __be16 vport;
505 __be16 dport;
506 __u32 fwmark; /* Fire wall mark from skb */
507 union nf_inet_addr caddr; /* client address */
508 union nf_inet_addr vaddr; /* virtual address */
509 union nf_inet_addr daddr; /* destination address */
510 volatile __u32 flags; /* status flags */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 __u16 protocol; /* Which protocol (TCP/UDP) */
512
513 /* counter and timer */
514 atomic_t refcnt; /* reference count */
515 struct timer_list timer; /* Expiration timer */
516 volatile unsigned long timeout; /* timeout */
517
518 /* Flags and state transition */
519 spinlock_t lock; /* lock for state transition */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 volatile __u16 state; /* state info */
Rumen G. Bogdanovskiefac5272007-11-07 02:36:55 -0800521 volatile __u16 old_state; /* old state, to be used for
522 * state transition triggerd
523 * synchronization
524 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525
526 /* Control members */
527 struct ip_vs_conn *control; /* Master control connection */
528 atomic_t n_control; /* Number of controlled ones */
529 struct ip_vs_dest *dest; /* real server */
530 atomic_t in_pkts; /* incoming packet counter */
531
532 /* packet transmitter for different forwarding methods. If it
533 mangles the packet, it must return NF_DROP or better NF_STOLEN,
534 otherwise this must be changed to a sk_buff **.
Julian Anastasovfc604762010-10-17 16:38:15 +0300535 NF_ACCEPT can be returned when destination is local.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 */
537 int (*packet_xmit)(struct sk_buff *skb, struct ip_vs_conn *cp,
538 struct ip_vs_protocol *pp);
539
540 /* Note: we can group the following members into a structure,
541 in order to save more space, and the following members are
542 only used in VS/NAT anyway */
543 struct ip_vs_app *app; /* bound ip_vs_app object */
544 void *app_data; /* Application private data */
545 struct ip_vs_seq in_seq; /* incoming seq. struct */
546 struct ip_vs_seq out_seq; /* outgoing seq. struct */
Simon Horman85999282010-08-22 21:37:53 +0900547
Simon Hormane9e5eee2010-11-08 20:05:57 +0900548 const struct ip_vs_pe *pe;
Simon Horman85999282010-08-22 21:37:53 +0900549 char *pe_data;
550 __u8 pe_data_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551};
552
Hans Schillstrom6e67e582011-01-03 14:44:57 +0100553/*
554 * To save some memory in conn table when name space is disabled.
555 */
556static inline struct net *ip_vs_conn_net(const struct ip_vs_conn *cp)
557{
558#ifdef CONFIG_NET_NS
559 return cp->net;
560#else
561 return &init_net;
562#endif
563}
564static inline void ip_vs_conn_net_set(struct ip_vs_conn *cp, struct net *net)
565{
566#ifdef CONFIG_NET_NS
567 cp->net = net;
568#endif
569}
570
571static inline int ip_vs_conn_net_eq(const struct ip_vs_conn *cp,
572 struct net *net)
573{
574#ifdef CONFIG_NET_NS
575 return cp->net == net;
576#else
577 return 1;
578#endif
579}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
581/*
Julius Volzc860c6b2008-09-02 15:55:36 +0200582 * Extended internal versions of struct ip_vs_service_user and
583 * ip_vs_dest_user for IPv6 support.
584 *
585 * We need these to conveniently pass around service and destination
586 * options, but unfortunately, we also need to keep the old definitions to
587 * maintain userspace backwards compatibility for the setsockopt interface.
588 */
589struct ip_vs_service_user_kern {
590 /* virtual service addresses */
591 u16 af;
592 u16 protocol;
593 union nf_inet_addr addr; /* virtual ip address */
594 u16 port;
595 u32 fwmark; /* firwall mark of service */
596
597 /* virtual service options */
598 char *sched_name;
Simon Horman0d1e71b2010-08-22 21:37:54 +0900599 char *pe_name;
Julius Volzc860c6b2008-09-02 15:55:36 +0200600 unsigned flags; /* virtual service flags */
601 unsigned timeout; /* persistent timeout in sec */
602 u32 netmask; /* persistent netmask */
603};
604
605
606struct ip_vs_dest_user_kern {
607 /* destination server address */
608 union nf_inet_addr addr;
609 u16 port;
610
611 /* real server options */
612 unsigned conn_flags; /* connection flags */
613 int weight; /* destination weight */
614
615 /* thresholds for active connections */
616 u32 u_threshold; /* upper threshold */
617 u32 l_threshold; /* lower threshold */
618};
619
620
621/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 * The information about the virtual service offered to the net
623 * and the forwarding entries
624 */
625struct ip_vs_service {
626 struct list_head s_list; /* for normal service table */
627 struct list_head f_list; /* for fwmark-based service table */
628 atomic_t refcnt; /* reference counter */
629 atomic_t usecnt; /* use counter */
630
Julius Volze7ade462008-09-02 15:55:33 +0200631 u16 af; /* address family */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 __u16 protocol; /* which protocol (TCP/UDP) */
Julius Volze7ade462008-09-02 15:55:33 +0200633 union nf_inet_addr addr; /* IP address for virtual service */
Al Viro014d7302006-09-28 14:29:52 -0700634 __be16 port; /* port number for the service */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 __u32 fwmark; /* firewall mark of the service */
636 unsigned flags; /* service status flags */
637 unsigned timeout; /* persistent timeout in ticks */
Al Viro014d7302006-09-28 14:29:52 -0700638 __be32 netmask; /* grouping granularity */
Hans Schillstromfc723252011-01-03 14:44:43 +0100639 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640
641 struct list_head destinations; /* real server d-linked list */
642 __u32 num_dests; /* number of servers */
643 struct ip_vs_stats stats; /* statistics for the service */
644 struct ip_vs_app *inc; /* bind conns to this app inc */
645
646 /* for scheduling */
647 struct ip_vs_scheduler *scheduler; /* bound scheduler object */
648 rwlock_t sched_lock; /* lock sched_data */
649 void *sched_data; /* scheduler application data */
Simon Horman85999282010-08-22 21:37:53 +0900650
651 /* alternate persistence engine */
652 struct ip_vs_pe *pe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653};
654
655
656/*
657 * The real server destination forwarding entry
658 * with ip address, port number, and so on.
659 */
660struct ip_vs_dest {
661 struct list_head n_list; /* for the dests in the service */
662 struct list_head d_list; /* for table with all the dests */
663
Julius Volze7ade462008-09-02 15:55:33 +0200664 u16 af; /* address family */
665 union nf_inet_addr addr; /* IP address of the server */
Al Viro014d7302006-09-28 14:29:52 -0700666 __be16 port; /* port number of the server */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 volatile unsigned flags; /* dest status flags */
668 atomic_t conn_flags; /* flags to copy to conn */
669 atomic_t weight; /* server weight */
670
671 atomic_t refcnt; /* reference counter */
672 struct ip_vs_stats stats; /* statistics */
673
674 /* connection counters and thresholds */
675 atomic_t activeconns; /* active connections */
676 atomic_t inactconns; /* inactive connections */
677 atomic_t persistconns; /* persistent connections */
678 __u32 u_threshold; /* upper threshold */
679 __u32 l_threshold; /* lower threshold */
680
681 /* for destination cache */
682 spinlock_t dst_lock; /* lock of dst_cache */
683 struct dst_entry *dst_cache; /* destination cache entry */
684 u32 dst_rtos; /* RT_TOS(tos) for dst */
Hans Schillstrom714f0952010-10-19 10:38:48 +0200685 u32 dst_cookie;
686#ifdef CONFIG_IP_VS_IPV6
687 struct in6_addr dst_saddr;
688#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
690 /* for virtual service */
691 struct ip_vs_service *svc; /* service it belongs to */
692 __u16 protocol; /* which protocol (TCP/UDP) */
Julius Volze7ade462008-09-02 15:55:33 +0200693 union nf_inet_addr vaddr; /* virtual IP address */
Al Viro014d7302006-09-28 14:29:52 -0700694 __be16 vport; /* virtual port number */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 __u32 vfwmark; /* firewall mark of service */
696};
697
698
699/*
700 * The scheduler object
701 */
702struct ip_vs_scheduler {
703 struct list_head n_list; /* d-linked list head */
704 char *name; /* scheduler name */
705 atomic_t refcnt; /* reference counter */
706 struct module *module; /* THIS_MODULE/NULL */
707
708 /* scheduler initializing service */
709 int (*init_service)(struct ip_vs_service *svc);
710 /* scheduling service finish */
711 int (*done_service)(struct ip_vs_service *svc);
712 /* scheduler updating service */
713 int (*update_service)(struct ip_vs_service *svc);
714
715 /* selecting a server from the given service */
716 struct ip_vs_dest* (*schedule)(struct ip_vs_service *svc,
717 const struct sk_buff *skb);
718};
719
Simon Horman85999282010-08-22 21:37:53 +0900720/* The persistence engine object */
721struct ip_vs_pe {
722 struct list_head n_list; /* d-linked list head */
723 char *name; /* scheduler name */
724 atomic_t refcnt; /* reference counter */
725 struct module *module; /* THIS_MODULE/NULL */
726
727 /* get the connection template, if any */
728 int (*fill_param)(struct ip_vs_conn_param *p, struct sk_buff *skb);
729 bool (*ct_match)(const struct ip_vs_conn_param *p,
730 struct ip_vs_conn *ct);
731 u32 (*hashkey_raw)(const struct ip_vs_conn_param *p, u32 initval,
732 bool inverse);
Simon Hormana3c918a2010-08-22 21:37:53 +0900733 int (*show_pe_data)(const struct ip_vs_conn *cp, char *buf);
Simon Horman85999282010-08-22 21:37:53 +0900734};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
736/*
737 * The application module object (a.k.a. app incarnation)
738 */
Eric Dumazetfd2c3ef2009-11-03 03:26:03 +0000739struct ip_vs_app {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 struct list_head a_list; /* member in app list */
741 int type; /* IP_VS_APP_TYPE_xxx */
742 char *name; /* application module name */
743 __u16 protocol;
744 struct module *module; /* THIS_MODULE/NULL */
745 struct list_head incs_list; /* list of incarnations */
746
747 /* members for application incarnations */
748 struct list_head p_list; /* member in proto app list */
749 struct ip_vs_app *app; /* its real application */
Al Viro014d7302006-09-28 14:29:52 -0700750 __be16 port; /* port number in net order */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 atomic_t usecnt; /* usage counter */
752
Julian Anastasov8b27b102010-10-17 16:17:20 +0300753 /*
754 * output hook: Process packet in inout direction, diff set for TCP.
755 * Return: 0=Error, 1=Payload Not Mangled/Mangled but checksum is ok,
756 * 2=Mangled but checksum was not updated
757 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 int (*pkt_out)(struct ip_vs_app *, struct ip_vs_conn *,
Herbert Xu3db05fe2007-10-15 00:53:15 -0700759 struct sk_buff *, int *diff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760
Julian Anastasov8b27b102010-10-17 16:17:20 +0300761 /*
762 * input hook: Process packet in outin direction, diff set for TCP.
763 * Return: 0=Error, 1=Payload Not Mangled/Mangled but checksum is ok,
764 * 2=Mangled but checksum was not updated
765 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 int (*pkt_in)(struct ip_vs_app *, struct ip_vs_conn *,
Herbert Xu3db05fe2007-10-15 00:53:15 -0700767 struct sk_buff *, int *diff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768
769 /* ip_vs_app initializer */
770 int (*init_conn)(struct ip_vs_app *, struct ip_vs_conn *);
771
772 /* ip_vs_app finish */
773 int (*done_conn)(struct ip_vs_app *, struct ip_vs_conn *);
774
775
776 /* not used now */
777 int (*bind_conn)(struct ip_vs_app *, struct ip_vs_conn *,
778 struct ip_vs_protocol *);
779
780 void (*unbind_conn)(struct ip_vs_app *, struct ip_vs_conn *);
781
782 int * timeout_table;
783 int * timeouts;
784 int timeouts_size;
785
786 int (*conn_schedule)(struct sk_buff *skb, struct ip_vs_app *app,
787 int *verdict, struct ip_vs_conn **cpp);
788
789 struct ip_vs_conn *
790 (*conn_in_get)(const struct sk_buff *skb, struct ip_vs_app *app,
791 const struct iphdr *iph, unsigned int proto_off,
792 int inverse);
793
794 struct ip_vs_conn *
795 (*conn_out_get)(const struct sk_buff *skb, struct ip_vs_app *app,
796 const struct iphdr *iph, unsigned int proto_off,
797 int inverse);
798
799 int (*state_transition)(struct ip_vs_conn *cp, int direction,
800 const struct sk_buff *skb,
801 struct ip_vs_app *app);
802
803 void (*timeout_change)(struct ip_vs_app *app, int flags);
804};
805
806
807/*
808 * IPVS core functions
809 * (from ip_vs_core.c)
810 */
811extern const char *ip_vs_proto_name(unsigned proto);
812extern void ip_vs_init_hash_table(struct list_head *table, int rows);
Sven Wegenerafdd6142008-08-10 09:18:01 +0000813#define IP_VS_INIT_HASH_TABLE(t) ip_vs_init_hash_table((t), ARRAY_SIZE((t)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815#define IP_VS_APP_TYPE_FTP 1
816
817/*
818 * ip_vs_conn handling functions
819 * (from ip_vs_conn.c)
820 */
821
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822enum {
823 IP_VS_DIR_INPUT = 0,
824 IP_VS_DIR_OUTPUT,
825 IP_VS_DIR_INPUT_ONLY,
826 IP_VS_DIR_LAST,
827};
828
Hans Schillstrom6e67e582011-01-03 14:44:57 +0100829static inline void ip_vs_conn_fill_param(struct net *net, int af, int protocol,
Simon Hormanf11017e2010-08-22 21:37:52 +0900830 const union nf_inet_addr *caddr,
831 __be16 cport,
832 const union nf_inet_addr *vaddr,
833 __be16 vport,
834 struct ip_vs_conn_param *p)
835{
Hans Schillstrom6e67e582011-01-03 14:44:57 +0100836 p->net = net;
Simon Hormanf11017e2010-08-22 21:37:52 +0900837 p->af = af;
838 p->protocol = protocol;
839 p->caddr = caddr;
840 p->cport = cport;
841 p->vaddr = vaddr;
842 p->vport = vport;
Simon Horman85999282010-08-22 21:37:53 +0900843 p->pe = NULL;
844 p->pe_data = NULL;
Simon Hormanf11017e2010-08-22 21:37:52 +0900845}
Julius Volz28364a52008-09-02 15:55:43 +0200846
Simon Hormanf11017e2010-08-22 21:37:52 +0900847struct ip_vs_conn *ip_vs_conn_in_get(const struct ip_vs_conn_param *p);
848struct ip_vs_conn *ip_vs_ct_in_get(const struct ip_vs_conn_param *p);
Julius Volz28364a52008-09-02 15:55:43 +0200849
Simon Horman5c0d2372010-08-02 17:12:44 +0200850struct ip_vs_conn * ip_vs_conn_in_get_proto(int af, const struct sk_buff *skb,
Simon Horman5c0d2372010-08-02 17:12:44 +0200851 const struct ip_vs_iphdr *iph,
852 unsigned int proto_off,
853 int inverse);
854
Simon Hormanf11017e2010-08-22 21:37:52 +0900855struct ip_vs_conn *ip_vs_conn_out_get(const struct ip_vs_conn_param *p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856
Simon Horman5c0d2372010-08-02 17:12:44 +0200857struct ip_vs_conn * ip_vs_conn_out_get_proto(int af, const struct sk_buff *skb,
Simon Horman5c0d2372010-08-02 17:12:44 +0200858 const struct ip_vs_iphdr *iph,
859 unsigned int proto_off,
860 int inverse);
861
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862/* put back the conn without restarting its timer */
863static inline void __ip_vs_conn_put(struct ip_vs_conn *cp)
864{
865 atomic_dec(&cp->refcnt);
866}
867extern void ip_vs_conn_put(struct ip_vs_conn *cp);
Al Viro014d7302006-09-28 14:29:52 -0700868extern void ip_vs_conn_fill_cport(struct ip_vs_conn *cp, __be16 cport);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869
Simon Hormanf11017e2010-08-22 21:37:52 +0900870struct ip_vs_conn *ip_vs_conn_new(const struct ip_vs_conn_param *p,
871 const union nf_inet_addr *daddr,
872 __be16 dport, unsigned flags,
Hans Schillstrom0e051e62010-11-19 14:25:07 +0100873 struct ip_vs_dest *dest, __u32 fwmark);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874extern void ip_vs_conn_expire_now(struct ip_vs_conn *cp);
875
876extern const char * ip_vs_state_name(__u16 proto, int state);
877
Hans Schillstrom4a85b962011-01-03 14:44:47 +0100878extern void ip_vs_tcp_conn_listen(struct net *net, struct ip_vs_conn *cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879extern int ip_vs_check_template(struct ip_vs_conn *ct);
Hans Schillstromf6340ee2011-01-03 14:44:59 +0100880extern void ip_vs_random_dropentry(struct net *net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881extern int ip_vs_conn_init(void);
882extern void ip_vs_conn_cleanup(void);
883
884static inline void ip_vs_control_del(struct ip_vs_conn *cp)
885{
886 struct ip_vs_conn *ctl_cp = cp->control;
887 if (!ctl_cp) {
Julius Volzcfc78c52008-09-02 15:55:53 +0200888 IP_VS_ERR_BUF("request control DEL for uncontrolled: "
889 "%s:%d to %s:%d\n",
890 IP_VS_DBG_ADDR(cp->af, &cp->caddr),
891 ntohs(cp->cport),
892 IP_VS_DBG_ADDR(cp->af, &cp->vaddr),
893 ntohs(cp->vport));
894
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 return;
896 }
897
Julius Volzcfc78c52008-09-02 15:55:53 +0200898 IP_VS_DBG_BUF(7, "DELeting control for: "
899 "cp.dst=%s:%d ctl_cp.dst=%s:%d\n",
900 IP_VS_DBG_ADDR(cp->af, &cp->caddr),
901 ntohs(cp->cport),
902 IP_VS_DBG_ADDR(cp->af, &ctl_cp->caddr),
903 ntohs(ctl_cp->cport));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904
905 cp->control = NULL;
906 if (atomic_read(&ctl_cp->n_control) == 0) {
Julius Volzcfc78c52008-09-02 15:55:53 +0200907 IP_VS_ERR_BUF("BUG control DEL with n=0 : "
908 "%s:%d to %s:%d\n",
909 IP_VS_DBG_ADDR(cp->af, &cp->caddr),
910 ntohs(cp->cport),
911 IP_VS_DBG_ADDR(cp->af, &cp->vaddr),
912 ntohs(cp->vport));
913
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 return;
915 }
916 atomic_dec(&ctl_cp->n_control);
917}
918
919static inline void
920ip_vs_control_add(struct ip_vs_conn *cp, struct ip_vs_conn *ctl_cp)
921{
922 if (cp->control) {
Julius Volzcfc78c52008-09-02 15:55:53 +0200923 IP_VS_ERR_BUF("request control ADD for already controlled: "
924 "%s:%d to %s:%d\n",
925 IP_VS_DBG_ADDR(cp->af, &cp->caddr),
926 ntohs(cp->cport),
927 IP_VS_DBG_ADDR(cp->af, &cp->vaddr),
928 ntohs(cp->vport));
929
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 ip_vs_control_del(cp);
931 }
932
Julius Volzcfc78c52008-09-02 15:55:53 +0200933 IP_VS_DBG_BUF(7, "ADDing control for: "
934 "cp.dst=%s:%d ctl_cp.dst=%s:%d\n",
935 IP_VS_DBG_ADDR(cp->af, &cp->caddr),
936 ntohs(cp->cport),
937 IP_VS_DBG_ADDR(cp->af, &ctl_cp->caddr),
938 ntohs(ctl_cp->cport));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939
940 cp->control = ctl_cp;
941 atomic_inc(&ctl_cp->n_control);
942}
943
944
945/*
946 * IPVS application functions
947 * (from ip_vs_app.c)
948 */
949#define IP_VS_APP_MAX_PORTS 8
Hans Schillstromab8a5e82011-01-03 14:44:53 +0100950extern int register_ip_vs_app(struct net *net, struct ip_vs_app *app);
951extern void unregister_ip_vs_app(struct net *net, struct ip_vs_app *app);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952extern int ip_vs_bind_app(struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
953extern void ip_vs_unbind_app(struct ip_vs_conn *cp);
Hans Schillstromab8a5e82011-01-03 14:44:53 +0100954extern int register_ip_vs_app_inc(struct net *net, struct ip_vs_app *app,
955 __u16 proto, __u16 port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956extern int ip_vs_app_inc_get(struct ip_vs_app *inc);
957extern void ip_vs_app_inc_put(struct ip_vs_app *inc);
958
Herbert Xu3db05fe2007-10-15 00:53:15 -0700959extern int ip_vs_app_pkt_out(struct ip_vs_conn *, struct sk_buff *skb);
960extern int ip_vs_app_pkt_in(struct ip_vs_conn *, struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961extern int ip_vs_app_init(void);
962extern void ip_vs_app_cleanup(void);
963
Simon Horman8be67a62010-08-22 21:37:54 +0900964void ip_vs_bind_pe(struct ip_vs_service *svc, struct ip_vs_pe *pe);
965void ip_vs_unbind_pe(struct ip_vs_service *svc);
966int register_ip_vs_pe(struct ip_vs_pe *pe);
967int unregister_ip_vs_pe(struct ip_vs_pe *pe);
Simon Hormane9e5eee2010-11-08 20:05:57 +0900968struct ip_vs_pe *ip_vs_pe_getbyname(const char *name);
Hans Schillstromfe5e7a12010-11-19 14:25:12 +0100969struct ip_vs_pe *__ip_vs_pe_getbyname(const char *pe_name);
Simon Hormane9e5eee2010-11-08 20:05:57 +0900970
971static inline void ip_vs_pe_get(const struct ip_vs_pe *pe)
972{
973 if (pe && pe->module)
974 __module_get(pe->module);
975}
976
977static inline void ip_vs_pe_put(const struct ip_vs_pe *pe)
978{
979 if (pe && pe->module)
980 module_put(pe->module);
981}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982
983/*
984 * IPVS protocol functions (from ip_vs_proto.c)
985 */
986extern int ip_vs_protocol_init(void);
987extern void ip_vs_protocol_cleanup(void);
Hans Schillstrom93304192011-01-03 14:44:51 +0100988extern void ip_vs_protocol_timeout_change(struct netns_ipvs *ipvs, int flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989extern int *ip_vs_create_timeout_table(int *table, int size);
990extern int
Jan Engelhardt36cbd3d2009-08-05 10:42:58 -0700991ip_vs_set_state_timeout(int *table, int num, const char *const *names,
992 const char *name, int to);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993extern void
Julian Anastasov0d796412010-10-17 16:46:17 +0300994ip_vs_tcpudp_debug_packet(int af, struct ip_vs_protocol *pp,
995 const struct sk_buff *skb,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 int offset, const char *msg);
997
998extern struct ip_vs_protocol ip_vs_protocol_tcp;
999extern struct ip_vs_protocol ip_vs_protocol_udp;
1000extern struct ip_vs_protocol ip_vs_protocol_icmp;
1001extern struct ip_vs_protocol ip_vs_protocol_esp;
1002extern struct ip_vs_protocol ip_vs_protocol_ah;
Venkata Mohan Reddy2906f662010-02-18 12:31:05 +01001003extern struct ip_vs_protocol ip_vs_protocol_sctp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004
1005/*
1006 * Registering/unregistering scheduler functions
1007 * (from ip_vs_sched.c)
1008 */
1009extern int register_ip_vs_scheduler(struct ip_vs_scheduler *scheduler);
1010extern int unregister_ip_vs_scheduler(struct ip_vs_scheduler *scheduler);
1011extern int ip_vs_bind_scheduler(struct ip_vs_service *svc,
1012 struct ip_vs_scheduler *scheduler);
1013extern int ip_vs_unbind_scheduler(struct ip_vs_service *svc);
1014extern struct ip_vs_scheduler *ip_vs_scheduler_get(const char *sched_name);
1015extern void ip_vs_scheduler_put(struct ip_vs_scheduler *scheduler);
1016extern struct ip_vs_conn *
Julian Anastasov190ecd22010-10-17 16:24:37 +03001017ip_vs_schedule(struct ip_vs_service *svc, struct sk_buff *skb,
Hans Schillstrom93304192011-01-03 14:44:51 +01001018 struct ip_vs_proto_data *pd, int *ignored);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019extern int ip_vs_leave(struct ip_vs_service *svc, struct sk_buff *skb,
Hans Schillstrom93304192011-01-03 14:44:51 +01001020 struct ip_vs_proto_data *pd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021
1022
1023/*
1024 * IPVS control data and functions (from ip_vs_ctl.c)
1025 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026extern struct ip_vs_stats ip_vs_stats;
Sven Wegener5587da52008-08-10 18:24:40 +00001027extern const struct ctl_path net_vs_ctl_path[];
Hans Schillstromb880c1f2010-11-19 14:25:14 +01001028extern int sysctl_ip_vs_sync_ver;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029
Hans Schillstromf1313152011-01-03 14:44:55 +01001030extern void ip_vs_sync_switch_mode(struct net *net, int mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031extern struct ip_vs_service *
Hans Schillstromfc723252011-01-03 14:44:43 +01001032ip_vs_service_get(struct net *net, int af, __u32 fwmark, __u16 protocol,
Julius Volz3c2e0502008-09-02 15:55:38 +02001033 const union nf_inet_addr *vaddr, __be16 vport);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034
1035static inline void ip_vs_service_put(struct ip_vs_service *svc)
1036{
1037 atomic_dec(&svc->usecnt);
1038}
1039
1040extern struct ip_vs_dest *
Hans Schillstromfc723252011-01-03 14:44:43 +01001041ip_vs_lookup_real_service(struct net *net, int af, __u16 protocol,
Julius Volz7937df12008-09-02 15:55:48 +02001042 const union nf_inet_addr *daddr, __be16 dport);
1043
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044extern int ip_vs_use_count_inc(void);
1045extern void ip_vs_use_count_dec(void);
1046extern int ip_vs_control_init(void);
1047extern void ip_vs_control_cleanup(void);
Rumen G. Bogdanovski1e356f92007-11-07 02:35:54 -08001048extern struct ip_vs_dest *
Hans Schillstromfc723252011-01-03 14:44:43 +01001049ip_vs_find_dest(struct net *net, int af, const union nf_inet_addr *daddr,
1050 __be16 dport, const union nf_inet_addr *vaddr, __be16 vport,
1051 __u16 protocol, __u32 fwmark);
Rumen G. Bogdanovski1e356f92007-11-07 02:35:54 -08001052extern struct ip_vs_dest *ip_vs_try_bind_dest(struct ip_vs_conn *cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053
1054
1055/*
1056 * IPVS sync daemon data and function prototypes
1057 * (from ip_vs_sync.c)
1058 */
Hans Schillstromf1313152011-01-03 14:44:55 +01001059extern int start_sync_thread(struct net *net, int state, char *mcast_ifn,
1060 __u8 syncid);
1061extern int stop_sync_thread(struct net *net, int state);
1062extern void ip_vs_sync_conn(struct net *net, struct ip_vs_conn *cp);
Hans Schillstrom61b1ab42011-01-03 14:44:42 +01001063extern int ip_vs_sync_init(void);
1064extern void ip_vs_sync_cleanup(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065
1066
1067/*
1068 * IPVS rate estimator prototypes (from ip_vs_est.c)
1069 */
Sven Wegenera919cf42008-08-14 00:47:16 +02001070extern int ip_vs_estimator_init(void);
1071extern void ip_vs_estimator_cleanup(void);
Hans Schillstrom29c20262011-01-03 14:44:54 +01001072extern void ip_vs_new_estimator(struct net *net, struct ip_vs_stats *stats);
1073extern void ip_vs_kill_estimator(struct net *net, struct ip_vs_stats *stats);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074extern void ip_vs_zero_estimator(struct ip_vs_stats *stats);
1075
1076/*
1077 * Various IPVS packet transmitters (from ip_vs_xmit.c)
1078 */
1079extern int ip_vs_null_xmit
1080(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
1081extern int ip_vs_bypass_xmit
1082(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
1083extern int ip_vs_nat_xmit
1084(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
1085extern int ip_vs_tunnel_xmit
1086(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
1087extern int ip_vs_dr_xmit
1088(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
1089extern int ip_vs_icmp_xmit
1090(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, int offset);
1091extern void ip_vs_dst_reset(struct ip_vs_dest *dest);
1092
Julius Volzb3cdd2a72008-09-02 15:55:45 +02001093#ifdef CONFIG_IP_VS_IPV6
1094extern int ip_vs_bypass_xmit_v6
1095(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
1096extern int ip_vs_nat_xmit_v6
1097(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
1098extern int ip_vs_tunnel_xmit_v6
1099(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
1100extern int ip_vs_dr_xmit_v6
1101(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
1102extern int ip_vs_icmp_xmit_v6
1103(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp,
1104 int offset);
1105#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106
1107/*
1108 * This is a simple mechanism to ignore packets when
1109 * we are loaded. Just set ip_vs_drop_rate to 'n' and
1110 * we start to drop 1/rate of the packets
1111 */
1112extern int ip_vs_drop_rate;
1113extern int ip_vs_drop_counter;
1114
Hans Schillstroma0840e22011-01-03 14:44:58 +01001115static inline int ip_vs_todrop(struct netns_ipvs *ipvs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116{
Hans Schillstroma0840e22011-01-03 14:44:58 +01001117 if (!ipvs->drop_rate)
1118 return 0;
1119 if (--ipvs->drop_counter > 0)
1120 return 0;
1121 ipvs->drop_counter = ipvs->drop_rate;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 return 1;
1123}
1124
1125/*
1126 * ip_vs_fwd_tag returns the forwarding tag of the connection
1127 */
1128#define IP_VS_FWD_METHOD(cp) (cp->flags & IP_VS_CONN_F_FWD_MASK)
1129
Adrian Bunk732db652005-09-01 17:40:26 -07001130static inline char ip_vs_fwd_tag(struct ip_vs_conn *cp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131{
1132 char fwd;
1133
1134 switch (IP_VS_FWD_METHOD(cp)) {
1135 case IP_VS_CONN_F_MASQ:
1136 fwd = 'M'; break;
1137 case IP_VS_CONN_F_LOCALNODE:
1138 fwd = 'L'; break;
1139 case IP_VS_CONN_F_TUNNEL:
1140 fwd = 'T'; break;
1141 case IP_VS_CONN_F_DROUTE:
1142 fwd = 'R'; break;
1143 case IP_VS_CONN_F_BYPASS:
1144 fwd = 'B'; break;
1145 default:
1146 fwd = '?'; break;
1147 }
1148 return fwd;
1149}
1150
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151extern void ip_vs_nat_icmp(struct sk_buff *skb, struct ip_vs_protocol *pp,
Julius Volzb3cdd2a72008-09-02 15:55:45 +02001152 struct ip_vs_conn *cp, int dir);
1153
1154#ifdef CONFIG_IP_VS_IPV6
1155extern void ip_vs_nat_icmp_v6(struct sk_buff *skb, struct ip_vs_protocol *pp,
1156 struct ip_vs_conn *cp, int dir);
1157#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158
Al Virob1550f22006-11-14 21:37:50 -08001159extern __sum16 ip_vs_checksum_complete(struct sk_buff *skb, int offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160
Al Virof9214b22006-11-16 02:41:18 -08001161static inline __wsum ip_vs_check_diff4(__be32 old, __be32 new, __wsum oldsum)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162{
Al Virof9214b22006-11-16 02:41:18 -08001163 __be32 diff[2] = { ~old, new };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164
Joe Perches07f07572008-11-19 15:44:53 -08001165 return csum_partial(diff, sizeof(diff), oldsum);
Al Virof9214b22006-11-16 02:41:18 -08001166}
1167
Julius Volz0bbdd422008-09-02 15:55:42 +02001168#ifdef CONFIG_IP_VS_IPV6
1169static inline __wsum ip_vs_check_diff16(const __be32 *old, const __be32 *new,
1170 __wsum oldsum)
1171{
1172 __be32 diff[8] = { ~old[3], ~old[2], ~old[1], ~old[0],
1173 new[3], new[2], new[1], new[0] };
1174
Joe Perches07f07572008-11-19 15:44:53 -08001175 return csum_partial(diff, sizeof(diff), oldsum);
Julius Volz0bbdd422008-09-02 15:55:42 +02001176}
1177#endif
1178
Al Virof9214b22006-11-16 02:41:18 -08001179static inline __wsum ip_vs_check_diff2(__be16 old, __be16 new, __wsum oldsum)
1180{
1181 __be16 diff[2] = { ~old, new };
1182
Joe Perches07f07572008-11-19 15:44:53 -08001183 return csum_partial(diff, sizeof(diff), oldsum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184}
1185
Julian Anastasovcf356d62010-10-17 16:21:07 +03001186/*
1187 * Forget current conntrack (unconfirmed) and attach notrack entry
1188 */
1189static inline void ip_vs_notrack(struct sk_buff *skb)
1190{
1191#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
1192 enum ip_conntrack_info ctinfo;
1193 struct nf_conn *ct = ct = nf_ct_get(skb, &ctinfo);
1194
1195 if (!ct || !nf_ct_is_untracked(ct)) {
1196 nf_reset(skb);
1197 skb->nfct = &nf_ct_untracked_get()->ct_general;
1198 skb->nfctinfo = IP_CT_NEW;
1199 nf_conntrack_get(skb->nfct);
1200 }
1201#endif
1202}
1203
Julian Anastasovf4bc17c2010-09-21 17:35:41 +02001204#ifdef CONFIG_IP_VS_NFCT
1205/*
1206 * Netfilter connection tracking
1207 * (from ip_vs_nfct.c)
1208 */
Hans Schillstroma0840e22011-01-03 14:44:58 +01001209static inline int ip_vs_conntrack_enabled(struct netns_ipvs *ipvs)
Julian Anastasovf4bc17c2010-09-21 17:35:41 +02001210{
Hans Schillstroma0840e22011-01-03 14:44:58 +01001211 return ipvs->sysctl_conntrack;
Julian Anastasovf4bc17c2010-09-21 17:35:41 +02001212}
1213
Julian Anastasov6523ce12010-09-05 18:02:29 +00001214extern void ip_vs_update_conntrack(struct sk_buff *skb, struct ip_vs_conn *cp,
1215 int outin);
Julian Anastasovf4bc17c2010-09-21 17:35:41 +02001216extern int ip_vs_confirm_conntrack(struct sk_buff *skb, struct ip_vs_conn *cp);
1217extern void ip_vs_nfct_expect_related(struct sk_buff *skb, struct nf_conn *ct,
1218 struct ip_vs_conn *cp, u_int8_t proto,
1219 const __be16 port, int from_rs);
1220extern void ip_vs_conn_drop_conntrack(struct ip_vs_conn *cp);
1221
1222#else
1223
Hans Schillstroma0840e22011-01-03 14:44:58 +01001224static inline int ip_vs_conntrack_enabled(struct netns_ipvs *ipvs)
Julian Anastasovf4bc17c2010-09-21 17:35:41 +02001225{
1226 return 0;
1227}
1228
1229static inline void ip_vs_update_conntrack(struct sk_buff *skb,
1230 struct ip_vs_conn *cp, int outin)
1231{
1232}
1233
1234static inline int ip_vs_confirm_conntrack(struct sk_buff *skb,
1235 struct ip_vs_conn *cp)
1236{
1237 return NF_ACCEPT;
1238}
1239
1240static inline void ip_vs_conn_drop_conntrack(struct ip_vs_conn *cp)
1241{
1242}
1243/* CONFIG_IP_VS_NFCT */
1244#endif
Julian Anastasov6523ce12010-09-05 18:02:29 +00001245
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246#endif /* __KERNEL__ */
1247
Julius Volzbc4768e2008-07-31 20:45:24 -07001248#endif /* _NET_IP_VS_H */