1/* 2 * IP Virtual Server 3 * data structure and functionality definitions 4 */ 5 6#ifndef _NET_IP_VS_H 7#define _NET_IP_VS_H 8 9#include <linux/ip_vs.h> /* definitions shared with userland */ 10 11/* old ipvsadm versions still include this file directly */ 12#ifdef __KERNEL__ 13 14#include <asm/types.h> /* for __uXX types */ 15 16#include <linux/sysctl.h> /* for ctl_path */ 17#include <linux/list.h> /* for struct list_head */ 18#include <linux/spinlock.h> /* for struct rwlock_t */ 19#include <asm/atomic.h> /* for struct atomic_t */ 20#include <linux/compiler.h> 21#include <linux/timer.h> 22 23#include <net/checksum.h> 24#include <linux/netfilter.h> /* for union nf_inet_addr */ 25#include <linux/ip.h> 26#include <linux/ipv6.h> /* for struct ipv6hdr */ 27#include <net/ipv6.h> /* for ipv6_addr_copy */ 28 29 30/* Connections' size value needed by ip_vs_ctl.c */ 31extern int ip_vs_conn_tab_size; 32 33 34struct ip_vs_iphdr { 35 int len; 36 __u8 protocol; 37 union nf_inet_addr saddr; 38 union nf_inet_addr daddr; 39}; 40 41static inline void 42ip_vs_fill_iphdr(int af, const void *nh, struct ip_vs_iphdr *iphdr) 43{ 44#ifdef CONFIG_IP_VS_IPV6 45 if (af == AF_INET6) { 46 const struct ipv6hdr *iph = nh; 47 iphdr->len = sizeof(struct ipv6hdr); 48 iphdr->protocol = iph->nexthdr; 49 ipv6_addr_copy(&iphdr->saddr.in6, &iph->saddr); 50 ipv6_addr_copy(&iphdr->daddr.in6, &iph->daddr); 51 } else 52#endif 53 { 54 const struct iphdr *iph = nh; 55 iphdr->len = iph->ihl * 4; 56 iphdr->protocol = iph->protocol; 57 iphdr->saddr.ip = iph->saddr; 58 iphdr->daddr.ip = iph->daddr; 59 } 60} 61 62static inline void ip_vs_addr_copy(int af, union nf_inet_addr *dst, 63 const union nf_inet_addr *src) 64{ 65#ifdef CONFIG_IP_VS_IPV6 66 if (af == AF_INET6) 67 ipv6_addr_copy(&dst->in6, &src->in6); 68 else 69#endif 70 dst->ip = src->ip; 71} 72 73static inline int ip_vs_addr_equal(int af, const union nf_inet_addr *a, 74 const union nf_inet_addr *b) 75{ 76#ifdef CONFIG_IP_VS_IPV6 77 if (af == AF_INET6) 78 return ipv6_addr_equal(&a->in6, &b->in6); 79#endif 80 return a->ip == b->ip; 81} 82 83#ifdef CONFIG_IP_VS_DEBUG 84#include <linux/net.h> 85 86extern int ip_vs_get_debug_level(void); 87 88static inline const char *ip_vs_dbg_addr(int af, char *buf, size_t buf_len, 89 const union nf_inet_addr *addr, 90 int *idx) 91{ 92 int len; 93#ifdef CONFIG_IP_VS_IPV6 94 if (af == AF_INET6) 95 len = snprintf(&buf[*idx], buf_len - *idx, "[%pI6]", 96 &addr->in6) + 1; 97 else 98#endif 99 len = snprintf(&buf[*idx], buf_len - *idx, "%pI4", 100 &addr->ip) + 1; 101 102 *idx += len; 103 BUG_ON(*idx > buf_len + 1); 104 return &buf[*idx - len]; 105} 106 107#define IP_VS_DBG_BUF(level, msg, ...) \ 108 do { \ 109 char ip_vs_dbg_buf[160]; \ 110 int ip_vs_dbg_idx = 0; \ 111 if (level <= ip_vs_get_debug_level()) \ 112 printk(KERN_DEBUG pr_fmt(msg), ##__VA_ARGS__); \ 113 } while (0) 114#define IP_VS_ERR_BUF(msg...) \ 115 do { \ 116 char ip_vs_dbg_buf[160]; \ 117 int ip_vs_dbg_idx = 0; \ 118 pr_err(msg); \ 119 } while (0) 120 121/* Only use from within IP_VS_DBG_BUF() or IP_VS_ERR_BUF macros */ 122#define IP_VS_DBG_ADDR(af, addr) \ 123 ip_vs_dbg_addr(af, ip_vs_dbg_buf, \ 124 sizeof(ip_vs_dbg_buf), addr, \ 125 &ip_vs_dbg_idx) 126 127#define IP_VS_DBG(level, msg, ...) \ 128 do { \ 129 if (level <= ip_vs_get_debug_level()) \ 130 printk(KERN_DEBUG pr_fmt(msg), ##__VA_ARGS__); \ 131 } while (0) 132#define IP_VS_DBG_RL(msg, ...) \ 133 do { \ 134 if (net_ratelimit()) \ 135 printk(KERN_DEBUG pr_fmt(msg), ##__VA_ARGS__); \ 136 } while (0) 137#define IP_VS_DBG_PKT(level, pp, skb, ofs, msg) \ 138 do { \ 139 if (level <= ip_vs_get_debug_level()) \ 140 pp->debug_packet(pp, skb, ofs, msg); \ 141 } while (0) 142#define IP_VS_DBG_RL_PKT(level, pp, skb, ofs, msg) \ 143 do { \ 144 if (level <= ip_vs_get_debug_level() && \ 145 net_ratelimit()) \ 146 pp->debug_packet(pp, skb, ofs, msg); \ 147 } while (0) 148#else /* NO DEBUGGING at ALL */ 149#define IP_VS_DBG_BUF(level, msg...) do {} while (0) 150#define IP_VS_ERR_BUF(msg...) do {} while (0) 151#define IP_VS_DBG(level, msg...) do {} while (0) 152#define IP_VS_DBG_RL(msg...) do {} while (0) 153#define IP_VS_DBG_PKT(level, pp, skb, ofs, msg) do {} while (0) 154#define IP_VS_DBG_RL_PKT(level, pp, skb, ofs, msg) do {} while (0) 155#endif 156 157#define IP_VS_BUG() BUG() 158#define IP_VS_ERR_RL(msg, ...) \ 159 do { \ 160 if (net_ratelimit()) \ 161 pr_err(msg, ##__VA_ARGS__); \ 162 } while (0) 163 164#ifdef CONFIG_IP_VS_DEBUG 165#define EnterFunction(level) \ 166 do { \ 167 if (level <= ip_vs_get_debug_level()) \ 168 printk(KERN_DEBUG \ 169 pr_fmt("Enter: %s, %s line %i\n"), \ 170 __func__, __FILE__, __LINE__); \ 171 } while (0) 172#define LeaveFunction(level) \ 173 do { \ 174 if (level <= ip_vs_get_debug_level()) \ 175 printk(KERN_DEBUG \ 176 pr_fmt("Leave: %s, %s line %i\n"), \ 177 __func__, __FILE__, __LINE__); \ 178 } while (0) 179#else 180#define EnterFunction(level) do {} while (0) 181#define LeaveFunction(level) do {} while (0) 182#endif 183 184#define IP_VS_WAIT_WHILE(expr) while (expr) { cpu_relax(); } 185 186 187/* 188 * The port number of FTP service (in network order). 189 */ 190#define FTPPORT cpu_to_be16(21) 191#define FTPDATA cpu_to_be16(20) 192 193/* 194 * TCP State Values 195 */ 196enum { 197 IP_VS_TCP_S_NONE = 0, 198 IP_VS_TCP_S_ESTABLISHED, 199 IP_VS_TCP_S_SYN_SENT, 200 IP_VS_TCP_S_SYN_RECV, 201 IP_VS_TCP_S_FIN_WAIT, 202 IP_VS_TCP_S_TIME_WAIT, 203 IP_VS_TCP_S_CLOSE, 204 IP_VS_TCP_S_CLOSE_WAIT, 205 IP_VS_TCP_S_LAST_ACK, 206 IP_VS_TCP_S_LISTEN, 207 IP_VS_TCP_S_SYNACK, 208 IP_VS_TCP_S_LAST 209}; 210 211/* 212 * UDP State Values 213 */ 214enum { 215 IP_VS_UDP_S_NORMAL, 216 IP_VS_UDP_S_LAST, 217}; 218 219/* 220 * ICMP State Values 221 */ 222enum { 223 IP_VS_ICMP_S_NORMAL, 224 IP_VS_ICMP_S_LAST, 225}; 226 227/* 228 * SCTP State Values 229 */ 230enum ip_vs_sctp_states { 231 IP_VS_SCTP_S_NONE, 232 IP_VS_SCTP_S_INIT_CLI, 233 IP_VS_SCTP_S_INIT_SER, 234 IP_VS_SCTP_S_INIT_ACK_CLI, 235 IP_VS_SCTP_S_INIT_ACK_SER, 236 IP_VS_SCTP_S_ECHO_CLI, 237 IP_VS_SCTP_S_ECHO_SER, 238 IP_VS_SCTP_S_ESTABLISHED, 239 IP_VS_SCTP_S_SHUT_CLI, 240 IP_VS_SCTP_S_SHUT_SER, 241 IP_VS_SCTP_S_SHUT_ACK_CLI, 242 IP_VS_SCTP_S_SHUT_ACK_SER, 243 IP_VS_SCTP_S_CLOSED, 244 IP_VS_SCTP_S_LAST 245}; 246 247/* 248 * Delta sequence info structure 249 * Each ip_vs_conn has 2 (output AND input seq. changes). 250 * Only used in the VS/NAT. 251 */ 252struct ip_vs_seq { 253 __u32 init_seq; /* Add delta from this seq */ 254 __u32 delta; /* Delta in sequence numbers */ 255 __u32 previous_delta; /* Delta in sequence numbers 256 before last resized pkt */ 257}; 258 259 260/* 261 * IPVS statistics objects 262 */ 263struct ip_vs_estimator { 264 struct list_head list; 265 266 u64 last_inbytes; 267 u64 last_outbytes; 268 u32 last_conns; 269 u32 last_inpkts; 270 u32 last_outpkts; 271 272 u32 cps; 273 u32 inpps; 274 u32 outpps; 275 u32 inbps; 276 u32 outbps; 277}; 278 279struct ip_vs_stats { 280 struct ip_vs_stats_user ustats; /* statistics */ 281 struct ip_vs_estimator est; /* estimator */ 282 283 spinlock_t lock; /* spin lock */ 284}; 285 286struct dst_entry; 287struct iphdr; 288struct ip_vs_conn; 289struct ip_vs_app; 290struct sk_buff; 291 292struct ip_vs_protocol { 293 struct ip_vs_protocol *next; 294 char *name; 295 u16 protocol; 296 u16 num_states; 297 int dont_defrag; 298 atomic_t appcnt; /* counter of proto app incs */ 299 int *timeout_table; /* protocol timeout table */ 300 301 void (*init)(struct ip_vs_protocol *pp); 302 303 void (*exit)(struct ip_vs_protocol *pp); 304 305 int (*conn_schedule)(int af, struct sk_buff *skb, 306 struct ip_vs_protocol *pp, 307 int *verdict, struct ip_vs_conn **cpp); 308 309 struct ip_vs_conn * 310 (*conn_in_get)(int af, 311 const struct sk_buff *skb, 312 struct ip_vs_protocol *pp, 313 const struct ip_vs_iphdr *iph, 314 unsigned int proto_off, 315 int inverse); 316 317 struct ip_vs_conn * 318 (*conn_out_get)(int af, 319 const struct sk_buff *skb, 320 struct ip_vs_protocol *pp, 321 const struct ip_vs_iphdr *iph, 322 unsigned int proto_off, 323 int inverse); 324 325 int (*snat_handler)(struct sk_buff *skb, 326 struct ip_vs_protocol *pp, struct ip_vs_conn *cp); 327 328 int (*dnat_handler)(struct sk_buff *skb, 329 struct ip_vs_protocol *pp, struct ip_vs_conn *cp); 330 331 int (*csum_check)(int af, struct sk_buff *skb, 332 struct ip_vs_protocol *pp); 333 334 const char *(*state_name)(int state); 335 336 int (*state_transition)(struct ip_vs_conn *cp, int direction, 337 const struct sk_buff *skb, 338 struct ip_vs_protocol *pp); 339 340 int (*register_app)(struct ip_vs_app *inc); 341 342 void (*unregister_app)(struct ip_vs_app *inc); 343 344 int (*app_conn_bind)(struct ip_vs_conn *cp); 345 346 void (*debug_packet)(struct ip_vs_protocol *pp, 347 const struct sk_buff *skb, 348 int offset, 349 const char *msg); 350 351 void (*timeout_change)(struct ip_vs_protocol *pp, int flags); 352 353 int (*set_state_timeout)(struct ip_vs_protocol *pp, char *sname, int to); 354}; 355 356extern struct ip_vs_protocol * ip_vs_proto_get(unsigned short proto); 357 358/* 359 * IP_VS structure allocated for each dynamically scheduled connection 360 */ 361struct ip_vs_conn { 362 struct list_head c_list; /* hashed list heads */ 363 364 /* Protocol, addresses and port numbers */ 365 u16 af; /* address family */ 366 union nf_inet_addr caddr; /* client address */ 367 union nf_inet_addr vaddr; /* virtual address */ 368 union nf_inet_addr daddr; /* destination address */ 369 __be16 cport; 370 __be16 vport; 371 __be16 dport; 372 __u16 protocol; /* Which protocol (TCP/UDP) */ 373 374 /* counter and timer */ 375 atomic_t refcnt; /* reference count */ 376 struct timer_list timer; /* Expiration timer */ 377 volatile unsigned long timeout; /* timeout */ 378 379 /* Flags and state transition */ 380 spinlock_t lock; /* lock for state transition */ 381 volatile __u16 flags; /* status flags */ 382 volatile __u16 state; /* state info */ 383 volatile __u16 old_state; /* old state, to be used for 384 * state transition triggerd 385 * synchronization 386 */ 387 388 /* Control members */ 389 struct ip_vs_conn *control; /* Master control connection */ 390 atomic_t n_control; /* Number of controlled ones */ 391 struct ip_vs_dest *dest; /* real server */ 392 atomic_t in_pkts; /* incoming packet counter */ 393 394 /* packet transmitter for different forwarding methods. If it 395 mangles the packet, it must return NF_DROP or better NF_STOLEN, 396 otherwise this must be changed to a sk_buff **. 397 */ 398 int (*packet_xmit)(struct sk_buff *skb, struct ip_vs_conn *cp, 399 struct ip_vs_protocol *pp); 400 401 /* Note: we can group the following members into a structure, 402 in order to save more space, and the following members are 403 only used in VS/NAT anyway */ 404 struct ip_vs_app *app; /* bound ip_vs_app object */ 405 void *app_data; /* Application private data */ 406 struct ip_vs_seq in_seq; /* incoming seq. struct */ 407 struct ip_vs_seq out_seq; /* outgoing seq. struct */ 408}; 409 410 411/* 412 * Extended internal versions of struct ip_vs_service_user and 413 * ip_vs_dest_user for IPv6 support. 414 * 415 * We need these to conveniently pass around service and destination 416 * options, but unfortunately, we also need to keep the old definitions to 417 * maintain userspace backwards compatibility for the setsockopt interface. 418 */ 419struct ip_vs_service_user_kern { 420 /* virtual service addresses */ 421 u16 af; 422 u16 protocol; 423 union nf_inet_addr addr; /* virtual ip address */ 424 u16 port; 425 u32 fwmark; /* firwall mark of service */ 426 427 /* virtual service options */ 428 char *sched_name; 429 unsigned flags; /* virtual service flags */ 430 unsigned timeout; /* persistent timeout in sec */ 431 u32 netmask; /* persistent netmask */ 432}; 433 434 435struct ip_vs_dest_user_kern { 436 /* destination server address */ 437 union nf_inet_addr addr; 438 u16 port; 439 440 /* real server options */ 441 unsigned conn_flags; /* connection flags */ 442 int weight; /* destination weight */ 443 444 /* thresholds for active connections */ 445 u32 u_threshold; /* upper threshold */ 446 u32 l_threshold; /* lower threshold */ 447}; 448 449 450/* 451 * The information about the virtual service offered to the net 452 * and the forwarding entries 453 */ 454struct ip_vs_service { 455 struct list_head s_list; /* for normal service table */ 456 struct list_head f_list; /* for fwmark-based service table */ 457 atomic_t refcnt; /* reference counter */ 458 atomic_t usecnt; /* use counter */ 459 460 u16 af; /* address family */ 461 __u16 protocol; /* which protocol (TCP/UDP) */ 462 union nf_inet_addr addr; /* IP address for virtual service */ 463 __be16 port; /* port number for the service */ 464 __u32 fwmark; /* firewall mark of the service */ 465 unsigned flags; /* service status flags */ 466 unsigned timeout; /* persistent timeout in ticks */ 467 __be32 netmask; /* grouping granularity */ 468 469 struct list_head destinations; /* real server d-linked list */ 470 __u32 num_dests; /* number of servers */ 471 struct ip_vs_stats stats; /* statistics for the service */ 472 struct ip_vs_app *inc; /* bind conns to this app inc */ 473 474 /* for scheduling */ 475 struct ip_vs_scheduler *scheduler; /* bound scheduler object */ 476 rwlock_t sched_lock; /* lock sched_data */ 477 void *sched_data; /* scheduler application data */ 478}; 479 480 481/* 482 * The real server destination forwarding entry 483 * with ip address, port number, and so on. 484 */ 485struct ip_vs_dest { 486 struct list_head n_list; /* for the dests in the service */ 487 struct list_head d_list; /* for table with all the dests */ 488 489 u16 af; /* address family */ 490 union nf_inet_addr addr; /* IP address of the server */ 491 __be16 port; /* port number of the server */ 492 volatile unsigned flags; /* dest status flags */ 493 atomic_t conn_flags; /* flags to copy to conn */ 494 atomic_t weight; /* server weight */ 495 496 atomic_t refcnt; /* reference counter */ 497 struct ip_vs_stats stats; /* statistics */ 498 499 /* connection counters and thresholds */ 500 atomic_t activeconns; /* active connections */ 501 atomic_t inactconns; /* inactive connections */ 502 atomic_t persistconns; /* persistent connections */ 503 __u32 u_threshold; /* upper threshold */ 504 __u32 l_threshold; /* lower threshold */ 505 506 /* for destination cache */ 507 spinlock_t dst_lock; /* lock of dst_cache */ 508 struct dst_entry *dst_cache; /* destination cache entry */ 509 u32 dst_rtos; /* RT_TOS(tos) for dst */ 510 511 /* for virtual service */ 512 struct ip_vs_service *svc; /* service it belongs to */ 513 __u16 protocol; /* which protocol (TCP/UDP) */ 514 union nf_inet_addr vaddr; /* virtual IP address */ 515 __be16 vport; /* virtual port number */ 516 __u32 vfwmark; /* firewall mark of service */ 517}; 518 519 520/* 521 * The scheduler object 522 */ 523struct ip_vs_scheduler { 524 struct list_head n_list; /* d-linked list head */ 525 char *name; /* scheduler name */ 526 atomic_t refcnt; /* reference counter */ 527 struct module *module; /* THIS_MODULE/NULL */ 528 529 /* scheduler initializing service */ 530 int (*init_service)(struct ip_vs_service *svc); 531 /* scheduling service finish */ 532 int (*done_service)(struct ip_vs_service *svc); 533 /* scheduler updating service */ 534 int (*update_service)(struct ip_vs_service *svc); 535 536 /* selecting a server from the given service */ 537 struct ip_vs_dest* (*schedule)(struct ip_vs_service *svc, 538 const struct sk_buff *skb); 539}; 540 541 542/* 543 * The application module object (a.k.a. app incarnation) 544 */ 545struct ip_vs_app { 546 struct list_head a_list; /* member in app list */ 547 int type; /* IP_VS_APP_TYPE_xxx */ 548 char *name; /* application module name */ 549 __u16 protocol; 550 struct module *module; /* THIS_MODULE/NULL */ 551 struct list_head incs_list; /* list of incarnations */ 552 553 /* members for application incarnations */ 554 struct list_head p_list; /* member in proto app list */ 555 struct ip_vs_app *app; /* its real application */ 556 __be16 port; /* port number in net order */ 557 atomic_t usecnt; /* usage counter */ 558 559 /* output hook: return false if can't linearize. diff set for TCP. */ 560 int (*pkt_out)(struct ip_vs_app *, struct ip_vs_conn *, 561 struct sk_buff *, int *diff); 562 563 /* input hook: return false if can't linearize. diff set for TCP. */ 564 int (*pkt_in)(struct ip_vs_app *, struct ip_vs_conn *, 565 struct sk_buff *, int *diff); 566 567 /* ip_vs_app initializer */ 568 int (*init_conn)(struct ip_vs_app *, struct ip_vs_conn *); 569 570 /* ip_vs_app finish */ 571 int (*done_conn)(struct ip_vs_app *, struct ip_vs_conn *); 572 573 574 /* not used now */ 575 int (*bind_conn)(struct ip_vs_app *, struct ip_vs_conn *, 576 struct ip_vs_protocol *); 577 578 void (*unbind_conn)(struct ip_vs_app *, struct ip_vs_conn *); 579 580 int * timeout_table; 581 int * timeouts; 582 int timeouts_size; 583 584 int (*conn_schedule)(struct sk_buff *skb, struct ip_vs_app *app, 585 int *verdict, struct ip_vs_conn **cpp); 586 587 struct ip_vs_conn * 588 (*conn_in_get)(const struct sk_buff *skb, struct ip_vs_app *app, 589 const struct iphdr *iph, unsigned int proto_off, 590 int inverse); 591 592 struct ip_vs_conn * 593 (*conn_out_get)(const struct sk_buff *skb, struct ip_vs_app *app, 594 const struct iphdr *iph, unsigned int proto_off, 595 int inverse); 596 597 int (*state_transition)(struct ip_vs_conn *cp, int direction, 598 const struct sk_buff *skb, 599 struct ip_vs_app *app); 600 601 void (*timeout_change)(struct ip_vs_app *app, int flags); 602}; 603 604 605/* 606 * IPVS core functions 607 * (from ip_vs_core.c) 608 */ 609extern const char *ip_vs_proto_name(unsigned proto); 610extern void ip_vs_init_hash_table(struct list_head *table, int rows); 611#define IP_VS_INIT_HASH_TABLE(t) ip_vs_init_hash_table((t), ARRAY_SIZE((t))) 612 613#define IP_VS_APP_TYPE_FTP 1 614 615/* 616 * ip_vs_conn handling functions 617 * (from ip_vs_conn.c) 618 */ 619 620enum { 621 IP_VS_DIR_INPUT = 0, 622 IP_VS_DIR_OUTPUT, 623 IP_VS_DIR_INPUT_ONLY, 624 IP_VS_DIR_LAST, 625}; 626 627extern struct ip_vs_conn *ip_vs_conn_in_get 628(int af, int protocol, const union nf_inet_addr *s_addr, __be16 s_port, 629 const union nf_inet_addr *d_addr, __be16 d_port); 630 631extern struct ip_vs_conn *ip_vs_ct_in_get 632(int af, int protocol, const union nf_inet_addr *s_addr, __be16 s_port, 633 const union nf_inet_addr *d_addr, __be16 d_port); 634 635struct ip_vs_conn * ip_vs_conn_in_get_proto(int af, const struct sk_buff *skb, 636 struct ip_vs_protocol *pp, 637 const struct ip_vs_iphdr *iph, 638 unsigned int proto_off, 639 int inverse); 640 641extern struct ip_vs_conn *ip_vs_conn_out_get 642(int af, int protocol, const union nf_inet_addr *s_addr, __be16 s_port, 643 const union nf_inet_addr *d_addr, __be16 d_port); 644 645struct ip_vs_conn * ip_vs_conn_out_get_proto(int af, const struct sk_buff *skb, 646 struct ip_vs_protocol *pp, 647 const struct ip_vs_iphdr *iph, 648 unsigned int proto_off, 649 int inverse); 650 651/* put back the conn without restarting its timer */ 652static inline void __ip_vs_conn_put(struct ip_vs_conn *cp) 653{ 654 atomic_dec(&cp->refcnt); 655} 656extern void ip_vs_conn_put(struct ip_vs_conn *cp); 657extern void ip_vs_conn_fill_cport(struct ip_vs_conn *cp, __be16 cport); 658 659extern struct ip_vs_conn * 660ip_vs_conn_new(int af, int proto, const union nf_inet_addr *caddr, __be16 cport, 661 const union nf_inet_addr *vaddr, __be16 vport, 662 const union nf_inet_addr *daddr, __be16 dport, unsigned flags, 663 struct ip_vs_dest *dest); 664extern void ip_vs_conn_expire_now(struct ip_vs_conn *cp); 665 666extern const char * ip_vs_state_name(__u16 proto, int state); 667 668extern void ip_vs_tcp_conn_listen(struct ip_vs_conn *cp); 669extern int ip_vs_check_template(struct ip_vs_conn *ct); 670extern void ip_vs_random_dropentry(void); 671extern int ip_vs_conn_init(void); 672extern void ip_vs_conn_cleanup(void); 673 674static inline void ip_vs_control_del(struct ip_vs_conn *cp) 675{ 676 struct ip_vs_conn *ctl_cp = cp->control; 677 if (!ctl_cp) { 678 IP_VS_ERR_BUF("request control DEL for uncontrolled: " 679 "%s:%d to %s:%d\n", 680 IP_VS_DBG_ADDR(cp->af, &cp->caddr), 681 ntohs(cp->cport), 682 IP_VS_DBG_ADDR(cp->af, &cp->vaddr), 683 ntohs(cp->vport)); 684 685 return; 686 } 687 688 IP_VS_DBG_BUF(7, "DELeting control for: " 689 "cp.dst=%s:%d ctl_cp.dst=%s:%d\n", 690 IP_VS_DBG_ADDR(cp->af, &cp->caddr), 691 ntohs(cp->cport), 692 IP_VS_DBG_ADDR(cp->af, &ctl_cp->caddr), 693 ntohs(ctl_cp->cport)); 694 695 cp->control = NULL; 696 if (atomic_read(&ctl_cp->n_control) == 0) { 697 IP_VS_ERR_BUF("BUG control DEL with n=0 : " 698 "%s:%d to %s:%d\n", 699 IP_VS_DBG_ADDR(cp->af, &cp->caddr), 700 ntohs(cp->cport), 701 IP_VS_DBG_ADDR(cp->af, &cp->vaddr), 702 ntohs(cp->vport)); 703 704 return; 705 } 706 atomic_dec(&ctl_cp->n_control); 707} 708 709static inline void 710ip_vs_control_add(struct ip_vs_conn *cp, struct ip_vs_conn *ctl_cp) 711{ 712 if (cp->control) { 713 IP_VS_ERR_BUF("request control ADD for already controlled: " 714 "%s:%d to %s:%d\n", 715 IP_VS_DBG_ADDR(cp->af, &cp->caddr), 716 ntohs(cp->cport), 717 IP_VS_DBG_ADDR(cp->af, &cp->vaddr), 718 ntohs(cp->vport)); 719 720 ip_vs_control_del(cp); 721 } 722 723 IP_VS_DBG_BUF(7, "ADDing control for: " 724 "cp.dst=%s:%d ctl_cp.dst=%s:%d\n", 725 IP_VS_DBG_ADDR(cp->af, &cp->caddr), 726 ntohs(cp->cport), 727 IP_VS_DBG_ADDR(cp->af, &ctl_cp->caddr), 728 ntohs(ctl_cp->cport)); 729 730 cp->control = ctl_cp; 731 atomic_inc(&ctl_cp->n_control); 732} 733 734 735/* 736 * IPVS application functions 737 * (from ip_vs_app.c) 738 */ 739#define IP_VS_APP_MAX_PORTS 8 740extern int register_ip_vs_app(struct ip_vs_app *app); 741extern void unregister_ip_vs_app(struct ip_vs_app *app); 742extern int ip_vs_bind_app(struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 743extern void ip_vs_unbind_app(struct ip_vs_conn *cp); 744extern int 745register_ip_vs_app_inc(struct ip_vs_app *app, __u16 proto, __u16 port); 746extern int ip_vs_app_inc_get(struct ip_vs_app *inc); 747extern void ip_vs_app_inc_put(struct ip_vs_app *inc); 748 749extern int ip_vs_app_pkt_out(struct ip_vs_conn *, struct sk_buff *skb); 750extern int ip_vs_app_pkt_in(struct ip_vs_conn *, struct sk_buff *skb); 751extern int ip_vs_app_init(void); 752extern void ip_vs_app_cleanup(void); 753 754 755/* 756 * IPVS protocol functions (from ip_vs_proto.c) 757 */ 758extern int ip_vs_protocol_init(void); 759extern void ip_vs_protocol_cleanup(void); 760extern void ip_vs_protocol_timeout_change(int flags); 761extern int *ip_vs_create_timeout_table(int *table, int size); 762extern int 763ip_vs_set_state_timeout(int *table, int num, const char *const *names, 764 const char *name, int to); 765extern void 766ip_vs_tcpudp_debug_packet(struct ip_vs_protocol *pp, const struct sk_buff *skb, 767 int offset, const char *msg); 768 769extern struct ip_vs_protocol ip_vs_protocol_tcp; 770extern struct ip_vs_protocol ip_vs_protocol_udp; 771extern struct ip_vs_protocol ip_vs_protocol_icmp; 772extern struct ip_vs_protocol ip_vs_protocol_esp; 773extern struct ip_vs_protocol ip_vs_protocol_ah; 774extern struct ip_vs_protocol ip_vs_protocol_sctp; 775 776/* 777 * Registering/unregistering scheduler functions 778 * (from ip_vs_sched.c) 779 */ 780extern int register_ip_vs_scheduler(struct ip_vs_scheduler *scheduler); 781extern int unregister_ip_vs_scheduler(struct ip_vs_scheduler *scheduler); 782extern int ip_vs_bind_scheduler(struct ip_vs_service *svc, 783 struct ip_vs_scheduler *scheduler); 784extern int ip_vs_unbind_scheduler(struct ip_vs_service *svc); 785extern struct ip_vs_scheduler *ip_vs_scheduler_get(const char *sched_name); 786extern void ip_vs_scheduler_put(struct ip_vs_scheduler *scheduler); 787extern struct ip_vs_conn * 788ip_vs_schedule(struct ip_vs_service *svc, const struct sk_buff *skb); 789extern int ip_vs_leave(struct ip_vs_service *svc, struct sk_buff *skb, 790 struct ip_vs_protocol *pp); 791 792 793/* 794 * IPVS control data and functions (from ip_vs_ctl.c) 795 */ 796extern int sysctl_ip_vs_cache_bypass; 797extern int sysctl_ip_vs_expire_nodest_conn; 798extern int sysctl_ip_vs_expire_quiescent_template; 799extern int sysctl_ip_vs_sync_threshold[2]; 800extern int sysctl_ip_vs_nat_icmp_send; 801extern struct ip_vs_stats ip_vs_stats; 802extern const struct ctl_path net_vs_ctl_path[]; 803 804extern struct ip_vs_service * 805ip_vs_service_get(int af, __u32 fwmark, __u16 protocol, 806 const union nf_inet_addr *vaddr, __be16 vport); 807 808static inline void ip_vs_service_put(struct ip_vs_service *svc) 809{ 810 atomic_dec(&svc->usecnt); 811} 812 813extern struct ip_vs_dest * 814ip_vs_lookup_real_service(int af, __u16 protocol, 815 const union nf_inet_addr *daddr, __be16 dport); 816 817extern int ip_vs_use_count_inc(void); 818extern void ip_vs_use_count_dec(void); 819extern int ip_vs_control_init(void); 820extern void ip_vs_control_cleanup(void); 821extern struct ip_vs_dest * 822ip_vs_find_dest(int af, const union nf_inet_addr *daddr, __be16 dport, 823 const union nf_inet_addr *vaddr, __be16 vport, __u16 protocol); 824extern struct ip_vs_dest *ip_vs_try_bind_dest(struct ip_vs_conn *cp); 825 826 827/* 828 * IPVS sync daemon data and function prototypes 829 * (from ip_vs_sync.c) 830 */ 831extern volatile int ip_vs_sync_state; 832extern volatile int ip_vs_master_syncid; 833extern volatile int ip_vs_backup_syncid; 834extern char ip_vs_master_mcast_ifn[IP_VS_IFNAME_MAXLEN]; 835extern char ip_vs_backup_mcast_ifn[IP_VS_IFNAME_MAXLEN]; 836extern int start_sync_thread(int state, char *mcast_ifn, __u8 syncid); 837extern int stop_sync_thread(int state); 838extern void ip_vs_sync_conn(struct ip_vs_conn *cp); 839 840 841/* 842 * IPVS rate estimator prototypes (from ip_vs_est.c) 843 */ 844extern int ip_vs_estimator_init(void); 845extern void ip_vs_estimator_cleanup(void); 846extern void ip_vs_new_estimator(struct ip_vs_stats *stats); 847extern void ip_vs_kill_estimator(struct ip_vs_stats *stats); 848extern void ip_vs_zero_estimator(struct ip_vs_stats *stats); 849 850/* 851 * Various IPVS packet transmitters (from ip_vs_xmit.c) 852 */ 853extern int ip_vs_null_xmit 854(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 855extern int ip_vs_bypass_xmit 856(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 857extern int ip_vs_nat_xmit 858(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 859extern int ip_vs_tunnel_xmit 860(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 861extern int ip_vs_dr_xmit 862(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 863extern int ip_vs_icmp_xmit 864(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, int offset); 865extern void ip_vs_dst_reset(struct ip_vs_dest *dest); 866 867#ifdef CONFIG_IP_VS_IPV6 868extern int ip_vs_bypass_xmit_v6 869(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 870extern int ip_vs_nat_xmit_v6 871(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 872extern int ip_vs_tunnel_xmit_v6 873(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 874extern int ip_vs_dr_xmit_v6 875(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 876extern int ip_vs_icmp_xmit_v6 877(struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, 878 int offset); 879#endif 880 881/* 882 * This is a simple mechanism to ignore packets when 883 * we are loaded. Just set ip_vs_drop_rate to 'n' and 884 * we start to drop 1/rate of the packets 885 */ 886extern int ip_vs_drop_rate; 887extern int ip_vs_drop_counter; 888 889static __inline__ int ip_vs_todrop(void) 890{ 891 if (!ip_vs_drop_rate) return 0; 892 if (--ip_vs_drop_counter > 0) return 0; 893 ip_vs_drop_counter = ip_vs_drop_rate; 894 return 1; 895} 896 897/* 898 * ip_vs_fwd_tag returns the forwarding tag of the connection 899 */ 900#define IP_VS_FWD_METHOD(cp) (cp->flags & IP_VS_CONN_F_FWD_MASK) 901 902static inline char ip_vs_fwd_tag(struct ip_vs_conn *cp) 903{ 904 char fwd; 905 906 switch (IP_VS_FWD_METHOD(cp)) { 907 case IP_VS_CONN_F_MASQ: 908 fwd = 'M'; break; 909 case IP_VS_CONN_F_LOCALNODE: 910 fwd = 'L'; break; 911 case IP_VS_CONN_F_TUNNEL: 912 fwd = 'T'; break; 913 case IP_VS_CONN_F_DROUTE: 914 fwd = 'R'; break; 915 case IP_VS_CONN_F_BYPASS: 916 fwd = 'B'; break; 917 default: 918 fwd = '?'; break; 919 } 920 return fwd; 921} 922 923extern void ip_vs_nat_icmp(struct sk_buff *skb, struct ip_vs_protocol *pp, 924 struct ip_vs_conn *cp, int dir); 925 926#ifdef CONFIG_IP_VS_IPV6 927extern void ip_vs_nat_icmp_v6(struct sk_buff *skb, struct ip_vs_protocol *pp, 928 struct ip_vs_conn *cp, int dir); 929#endif 930 931extern __sum16 ip_vs_checksum_complete(struct sk_buff *skb, int offset); 932 933static inline __wsum ip_vs_check_diff4(__be32 old, __be32 new, __wsum oldsum) 934{ 935 __be32 diff[2] = { ~old, new }; 936 937 return csum_partial(diff, sizeof(diff), oldsum); 938} 939 940#ifdef CONFIG_IP_VS_IPV6 941static inline __wsum ip_vs_check_diff16(const __be32 *old, const __be32 *new, 942 __wsum oldsum) 943{ 944 __be32 diff[8] = { ~old[3], ~old[2], ~old[1], ~old[0], 945 new[3], new[2], new[1], new[0] }; 946 947 return csum_partial(diff, sizeof(diff), oldsum); 948} 949#endif 950 951static inline __wsum ip_vs_check_diff2(__be16 old, __be16 new, __wsum oldsum) 952{ 953 __be16 diff[2] = { ~old, new }; 954 955 return csum_partial(diff, sizeof(diff), oldsum); 956} 957 958extern void ip_vs_update_conntrack(struct sk_buff *skb, struct ip_vs_conn *cp, 959 int outin); 960 961#endif /* __KERNEL__ */ 962 963#endif /* _NET_IP_VS_H */ 964