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 */ 31 extern int ip_vs_conn_tab_size; 32 33 34 struct ip_vs_iphdr { 35 int len; 36 __u8 protocol; 37 union nf_inet_addr saddr; 38 union nf_inet_addr daddr; 39 }; 40 41 static inline void 42 ip_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 62 static 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 73 static 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 86 extern int ip_vs_get_debug_level(void); 87 88 static 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 */ 196 enum { 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 */ 214 enum { 215 IP_VS_UDP_S_NORMAL, 216 IP_VS_UDP_S_LAST, 217 }; 218 219 /* 220 * ICMP State Values 221 */ 222 enum { 223 IP_VS_ICMP_S_NORMAL, 224 IP_VS_ICMP_S_LAST, 225 }; 226 227 /* 228 * SCTP State Values 229 */ 230 enum 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 */ 252 struct 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 */ 263 struct 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 279 struct 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 286 struct dst_entry; 287 struct iphdr; 288 struct ip_vs_conn; 289 struct ip_vs_app; 290 struct sk_buff; 291 292 struct 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 356 extern struct ip_vs_protocol * ip_vs_proto_get(unsigned short proto); 357 358 /* 359 * IP_VS structure allocated for each dynamically scheduled connection 360 */ 361 struct 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 */ 419 struct 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 435 struct 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 */ 454 struct 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 */ 485 struct 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 */ 523 struct 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 */ 545 struct 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 */ 609 extern const char *ip_vs_proto_name(unsigned proto); 610 extern 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 620 enum { 621 IP_VS_DIR_INPUT = 0, 622 IP_VS_DIR_OUTPUT, 623 IP_VS_DIR_INPUT_ONLY, 624 IP_VS_DIR_LAST, 625 }; 626 627 extern 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 631 extern 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 635 extern struct ip_vs_conn *ip_vs_conn_out_get 636 (int af, int protocol, const union nf_inet_addr *s_addr, __be16 s_port, 637 const union nf_inet_addr *d_addr, __be16 d_port); 638 639 /* put back the conn without restarting its timer */ 640 static inline void __ip_vs_conn_put(struct ip_vs_conn *cp) 641 { 642 atomic_dec(&cp->refcnt); 643 } 644 extern void ip_vs_conn_put(struct ip_vs_conn *cp); 645 extern void ip_vs_conn_fill_cport(struct ip_vs_conn *cp, __be16 cport); 646 647 extern struct ip_vs_conn * 648 ip_vs_conn_new(int af, int proto, const union nf_inet_addr *caddr, __be16 cport, 649 const union nf_inet_addr *vaddr, __be16 vport, 650 const union nf_inet_addr *daddr, __be16 dport, unsigned flags, 651 struct ip_vs_dest *dest); 652 extern void ip_vs_conn_expire_now(struct ip_vs_conn *cp); 653 654 extern const char * ip_vs_state_name(__u16 proto, int state); 655 656 extern void ip_vs_tcp_conn_listen(struct ip_vs_conn *cp); 657 extern int ip_vs_check_template(struct ip_vs_conn *ct); 658 extern void ip_vs_random_dropentry(void); 659 extern int ip_vs_conn_init(void); 660 extern void ip_vs_conn_cleanup(void); 661 662 static inline void ip_vs_control_del(struct ip_vs_conn *cp) 663 { 664 struct ip_vs_conn *ctl_cp = cp->control; 665 if (!ctl_cp) { 666 IP_VS_ERR_BUF("request control DEL for uncontrolled: " 667 "%s:%d to %s:%d\n", 668 IP_VS_DBG_ADDR(cp->af, &cp->caddr), 669 ntohs(cp->cport), 670 IP_VS_DBG_ADDR(cp->af, &cp->vaddr), 671 ntohs(cp->vport)); 672 673 return; 674 } 675 676 IP_VS_DBG_BUF(7, "DELeting control for: " 677 "cp.dst=%s:%d ctl_cp.dst=%s:%d\n", 678 IP_VS_DBG_ADDR(cp->af, &cp->caddr), 679 ntohs(cp->cport), 680 IP_VS_DBG_ADDR(cp->af, &ctl_cp->caddr), 681 ntohs(ctl_cp->cport)); 682 683 cp->control = NULL; 684 if (atomic_read(&ctl_cp->n_control) == 0) { 685 IP_VS_ERR_BUF("BUG control DEL with n=0 : " 686 "%s:%d to %s:%d\n", 687 IP_VS_DBG_ADDR(cp->af, &cp->caddr), 688 ntohs(cp->cport), 689 IP_VS_DBG_ADDR(cp->af, &cp->vaddr), 690 ntohs(cp->vport)); 691 692 return; 693 } 694 atomic_dec(&ctl_cp->n_control); 695 } 696 697 static inline void 698 ip_vs_control_add(struct ip_vs_conn *cp, struct ip_vs_conn *ctl_cp) 699 { 700 if (cp->control) { 701 IP_VS_ERR_BUF("request control ADD for already controlled: " 702 "%s:%d to %s:%d\n", 703 IP_VS_DBG_ADDR(cp->af, &cp->caddr), 704 ntohs(cp->cport), 705 IP_VS_DBG_ADDR(cp->af, &cp->vaddr), 706 ntohs(cp->vport)); 707 708 ip_vs_control_del(cp); 709 } 710 711 IP_VS_DBG_BUF(7, "ADDing control for: " 712 "cp.dst=%s:%d ctl_cp.dst=%s:%d\n", 713 IP_VS_DBG_ADDR(cp->af, &cp->caddr), 714 ntohs(cp->cport), 715 IP_VS_DBG_ADDR(cp->af, &ctl_cp->caddr), 716 ntohs(ctl_cp->cport)); 717 718 cp->control = ctl_cp; 719 atomic_inc(&ctl_cp->n_control); 720 } 721 722 723 /* 724 * IPVS application functions 725 * (from ip_vs_app.c) 726 */ 727 #define IP_VS_APP_MAX_PORTS 8 728 extern int register_ip_vs_app(struct ip_vs_app *app); 729 extern void unregister_ip_vs_app(struct ip_vs_app *app); 730 extern int ip_vs_bind_app(struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 731 extern void ip_vs_unbind_app(struct ip_vs_conn *cp); 732 extern int 733 register_ip_vs_app_inc(struct ip_vs_app *app, __u16 proto, __u16 port); 734 extern int ip_vs_app_inc_get(struct ip_vs_app *inc); 735 extern void ip_vs_app_inc_put(struct ip_vs_app *inc); 736 737 extern int ip_vs_app_pkt_out(struct ip_vs_conn *, struct sk_buff *skb); 738 extern int ip_vs_app_pkt_in(struct ip_vs_conn *, struct sk_buff *skb); 739 extern int ip_vs_skb_replace(struct sk_buff *skb, gfp_t pri, 740 char *o_buf, int o_len, char *n_buf, int n_len); 741 extern int ip_vs_app_init(void); 742 extern void ip_vs_app_cleanup(void); 743 744 745 /* 746 * IPVS protocol functions (from ip_vs_proto.c) 747 */ 748 extern int ip_vs_protocol_init(void); 749 extern void ip_vs_protocol_cleanup(void); 750 extern void ip_vs_protocol_timeout_change(int flags); 751 extern int *ip_vs_create_timeout_table(int *table, int size); 752 extern int 753 ip_vs_set_state_timeout(int *table, int num, const char *const *names, 754 const char *name, int to); 755 extern void 756 ip_vs_tcpudp_debug_packet(struct ip_vs_protocol *pp, const struct sk_buff *skb, 757 int offset, const char *msg); 758 759 extern struct ip_vs_protocol ip_vs_protocol_tcp; 760 extern struct ip_vs_protocol ip_vs_protocol_udp; 761 extern struct ip_vs_protocol ip_vs_protocol_icmp; 762 extern struct ip_vs_protocol ip_vs_protocol_esp; 763 extern struct ip_vs_protocol ip_vs_protocol_ah; 764 extern struct ip_vs_protocol ip_vs_protocol_sctp; 765 766 /* 767 * Registering/unregistering scheduler functions 768 * (from ip_vs_sched.c) 769 */ 770 extern int register_ip_vs_scheduler(struct ip_vs_scheduler *scheduler); 771 extern int unregister_ip_vs_scheduler(struct ip_vs_scheduler *scheduler); 772 extern int ip_vs_bind_scheduler(struct ip_vs_service *svc, 773 struct ip_vs_scheduler *scheduler); 774 extern int ip_vs_unbind_scheduler(struct ip_vs_service *svc); 775 extern struct ip_vs_scheduler *ip_vs_scheduler_get(const char *sched_name); 776 extern void ip_vs_scheduler_put(struct ip_vs_scheduler *scheduler); 777 extern struct ip_vs_conn * 778 ip_vs_schedule(struct ip_vs_service *svc, const struct sk_buff *skb); 779 extern int ip_vs_leave(struct ip_vs_service *svc, struct sk_buff *skb, 780 struct ip_vs_protocol *pp); 781 782 783 /* 784 * IPVS control data and functions (from ip_vs_ctl.c) 785 */ 786 extern int sysctl_ip_vs_cache_bypass; 787 extern int sysctl_ip_vs_expire_nodest_conn; 788 extern int sysctl_ip_vs_expire_quiescent_template; 789 extern int sysctl_ip_vs_sync_threshold[2]; 790 extern int sysctl_ip_vs_nat_icmp_send; 791 extern struct ip_vs_stats ip_vs_stats; 792 extern const struct ctl_path net_vs_ctl_path[]; 793 794 extern struct ip_vs_service * 795 ip_vs_service_get(int af, __u32 fwmark, __u16 protocol, 796 const union nf_inet_addr *vaddr, __be16 vport); 797 798 static inline void ip_vs_service_put(struct ip_vs_service *svc) 799 { 800 atomic_dec(&svc->usecnt); 801 } 802 803 extern struct ip_vs_dest * 804 ip_vs_lookup_real_service(int af, __u16 protocol, 805 const union nf_inet_addr *daddr, __be16 dport); 806 807 extern int ip_vs_use_count_inc(void); 808 extern void ip_vs_use_count_dec(void); 809 extern int ip_vs_control_init(void); 810 extern void ip_vs_control_cleanup(void); 811 extern struct ip_vs_dest * 812 ip_vs_find_dest(int af, const union nf_inet_addr *daddr, __be16 dport, 813 const union nf_inet_addr *vaddr, __be16 vport, __u16 protocol); 814 extern struct ip_vs_dest *ip_vs_try_bind_dest(struct ip_vs_conn *cp); 815 816 817 /* 818 * IPVS sync daemon data and function prototypes 819 * (from ip_vs_sync.c) 820 */ 821 extern volatile int ip_vs_sync_state; 822 extern volatile int ip_vs_master_syncid; 823 extern volatile int ip_vs_backup_syncid; 824 extern char ip_vs_master_mcast_ifn[IP_VS_IFNAME_MAXLEN]; 825 extern char ip_vs_backup_mcast_ifn[IP_VS_IFNAME_MAXLEN]; 826 extern int start_sync_thread(int state, char *mcast_ifn, __u8 syncid); 827 extern int stop_sync_thread(int state); 828 extern void ip_vs_sync_conn(struct ip_vs_conn *cp); 829 830 831 /* 832 * IPVS rate estimator prototypes (from ip_vs_est.c) 833 */ 834 extern int ip_vs_estimator_init(void); 835 extern void ip_vs_estimator_cleanup(void); 836 extern void ip_vs_new_estimator(struct ip_vs_stats *stats); 837 extern void ip_vs_kill_estimator(struct ip_vs_stats *stats); 838 extern void ip_vs_zero_estimator(struct ip_vs_stats *stats); 839 840 /* 841 * Various IPVS packet transmitters (from ip_vs_xmit.c) 842 */ 843 extern int ip_vs_null_xmit 844 (struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 845 extern int ip_vs_bypass_xmit 846 (struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 847 extern int ip_vs_nat_xmit 848 (struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 849 extern int ip_vs_tunnel_xmit 850 (struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 851 extern int ip_vs_dr_xmit 852 (struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 853 extern int ip_vs_icmp_xmit 854 (struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, int offset); 855 extern void ip_vs_dst_reset(struct ip_vs_dest *dest); 856 857 #ifdef CONFIG_IP_VS_IPV6 858 extern int ip_vs_bypass_xmit_v6 859 (struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 860 extern int ip_vs_nat_xmit_v6 861 (struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 862 extern int ip_vs_tunnel_xmit_v6 863 (struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 864 extern int ip_vs_dr_xmit_v6 865 (struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp); 866 extern int ip_vs_icmp_xmit_v6 867 (struct sk_buff *skb, struct ip_vs_conn *cp, struct ip_vs_protocol *pp, 868 int offset); 869 #endif 870 871 /* 872 * This is a simple mechanism to ignore packets when 873 * we are loaded. Just set ip_vs_drop_rate to 'n' and 874 * we start to drop 1/rate of the packets 875 */ 876 extern int ip_vs_drop_rate; 877 extern int ip_vs_drop_counter; 878 879 static __inline__ int ip_vs_todrop(void) 880 { 881 if (!ip_vs_drop_rate) return 0; 882 if (--ip_vs_drop_counter > 0) return 0; 883 ip_vs_drop_counter = ip_vs_drop_rate; 884 return 1; 885 } 886 887 /* 888 * ip_vs_fwd_tag returns the forwarding tag of the connection 889 */ 890 #define IP_VS_FWD_METHOD(cp) (cp->flags & IP_VS_CONN_F_FWD_MASK) 891 892 static inline char ip_vs_fwd_tag(struct ip_vs_conn *cp) 893 { 894 char fwd; 895 896 switch (IP_VS_FWD_METHOD(cp)) { 897 case IP_VS_CONN_F_MASQ: 898 fwd = 'M'; break; 899 case IP_VS_CONN_F_LOCALNODE: 900 fwd = 'L'; break; 901 case IP_VS_CONN_F_TUNNEL: 902 fwd = 'T'; break; 903 case IP_VS_CONN_F_DROUTE: 904 fwd = 'R'; break; 905 case IP_VS_CONN_F_BYPASS: 906 fwd = 'B'; break; 907 default: 908 fwd = '?'; break; 909 } 910 return fwd; 911 } 912 913 extern void ip_vs_nat_icmp(struct sk_buff *skb, struct ip_vs_protocol *pp, 914 struct ip_vs_conn *cp, int dir); 915 916 #ifdef CONFIG_IP_VS_IPV6 917 extern void ip_vs_nat_icmp_v6(struct sk_buff *skb, struct ip_vs_protocol *pp, 918 struct ip_vs_conn *cp, int dir); 919 #endif 920 921 extern __sum16 ip_vs_checksum_complete(struct sk_buff *skb, int offset); 922 923 static inline __wsum ip_vs_check_diff4(__be32 old, __be32 new, __wsum oldsum) 924 { 925 __be32 diff[2] = { ~old, new }; 926 927 return csum_partial(diff, sizeof(diff), oldsum); 928 } 929 930 #ifdef CONFIG_IP_VS_IPV6 931 static inline __wsum ip_vs_check_diff16(const __be32 *old, const __be32 *new, 932 __wsum oldsum) 933 { 934 __be32 diff[8] = { ~old[3], ~old[2], ~old[1], ~old[0], 935 new[3], new[2], new[1], new[0] }; 936 937 return csum_partial(diff, sizeof(diff), oldsum); 938 } 939 #endif 940 941 static inline __wsum ip_vs_check_diff2(__be16 old, __be16 new, __wsum oldsum) 942 { 943 __be16 diff[2] = { ~old, new }; 944 945 return csum_partial(diff, sizeof(diff), oldsum); 946 } 947 948 #endif /* __KERNEL__ */ 949 950 #endif /* _NET_IP_VS_H */ 951