/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
*/
#ifndef _ILBD_H
#define _ILBD_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
#include <ucred.h>
#include <pwd.h>
#include <priv.h>
#include <stdarg.h>
#include <syslog.h>
#include <sys/list.h>
#include <libscf.h>
#include <libintl.h>
#include <locale.h>
#include <libinetutil.h>
#include <auth_list.h>
#include <bsm/adt.h>
#include <bsm/adt_event.h>
#define SGNAME_SZ 80
#define ILB_FMRI "svc:/network/loadbalancer/ilb:default"
#define HC_ACTION ILB_SRV_DISABLED_HC
#define ADMIN_ACTION ILB_SRV_DISABLED_ADMIN
/* Max name and value length for scf properties */
#define ILBD_MAX_NAME_LEN ilbd_scf_limit(SCF_LIMIT_MAX_NAME_LENGTH)
#define ILBD_MAX_VALUE_LEN ilbd_scf_limit(SCF_LIMIT_MAX_VALUE_LENGTH)
/* Different events ILBD is interested in. */
typedef enum {
ILBD_EVENT_NEW_REQ, /* New client request */
ILBD_EVENT_REQ, /* Client request comes in */
ILBD_EVENT_REP_OK, /* Reply channel to client is writeable */
ILBD_EVENT_PROBE, /* A HC returns some result */
ILBD_EVENT_TIMER /* ilbd_timer_q fired */
} ilbd_event_t;
typedef enum {
ILBD_SCF_RULE, /* prop group for rules */
ILBD_SCF_SG, /* prop group for servergroups */
ILBD_SCF_HC /* prop group for healthchecks */
} ilbd_scf_pg_type_t;
typedef enum {
ILBD_SCF_CREATE,
ILBD_SCF_DESTROY,
ILBD_SCF_ENABLE_DISABLE
} ilbd_scf_cmd_t;
typedef enum {
ILBD_STRING, /* string */
ILBD_INT, /* int */
ILBD_ADDR_V4, /* ipv4 addr */
ILBD_ADDR_V6 /* ipv6 addr */
} ilbd_scf_data_type_t;
typedef enum {
stat_enable_server,
stat_disable_server,
stat_declare_srv_dead,
stat_declare_srv_alive
} ilbd_srv_status_ind_t;
/*
* All user struct pointer passed to port_associate() should have the first
* field as ilbd_event_t. The following struct can be used to find the
* event.
*/
typedef struct {
ilbd_event_t ev;
} ilbd_event_obj_t;
typedef struct {
ilbd_event_t ev;
timer_t timerid;
} ilbd_timer_event_obj_t;
typedef struct ilbd_srv {
list_node_t isv_srv_link;
ilb_sg_srv_t isv_srv;
#define isv_addr isv_srv.sgs_addr
#define isv_minport isv_srv.sgs_minport
#define isv_maxport isv_srv.sgs_maxport
#define isv_flags isv_srv.sgs_flags
#define isv_id isv_srv.sgs_id
#define isv_srvID isv_srv.sgs_srvID
} ilbd_srv_t;
#define MAX_SRVCOUNT 1000
#define MAX_SRVID (MAX_SRVCOUNT - 1)
#define BAD_SRVID (-1)
typedef struct ilbd_sg {
list_t isg_srvlist; /* list of ilbd_srv_t */
char isg_name[ILB_SGNAME_SZ];
int32_t isg_srvcount;
int32_t isg_max_id;
list_t isg_rulelist; /* list of ilbd_rule_t */
char isg_id_arr[MAX_SRVCOUNT]; /* for server ID allocation */
list_node_t isg_link; /* linkage for sg list */
} ilbd_sg_t;
typedef struct ilbd_rule {
list_node_t irl_link;
list_node_t irl_sglink;
ilbd_sg_t *irl_sg;
ilb_rule_info_t irl_info;
#define irl_flags irl_info.rl_flags
#define irl_name irl_info.rl_name
#define irl_vip irl_info.rl_vip
#define irl_proto irl_info.rl_proto
#define irl_ipversion irl_info.rl_ipversion
#define irl_minport irl_info.rl_minport
#define irl_maxport irl_info.rl_maxport
#define irl_algo irl_info.rl_algo
#define irl_topo irl_info.rl_topo
#define irl_nat_src_start irl_info.rl_nat_src_start
#define irl_nat_src_end irl_info.rl_nat_src_end
#define irl_stickymask irl_info.rl_stickymask
#define irl_conndrain irl_info.rl_conndrain
#define irl_nat_timeout irl_info.rl_nat_timeout
#define irl_sticky_timeout irl_info.rl_sticky_timeout
#define irl_hcport irl_info.rl_hcport
#define irl_hcpflag irl_info.rl_hcpflag
#define irl_sgname irl_info.rl_sgname
#define irl_hcname irl_info.rl_hcname
} ilbd_rule_t;
/*
* Health check related definitions
*/
/* Default health check probe program provided */
#define ILB_PROBE_PROTO "/usr/lib/inet/ilb/ilb_probe"
/* Command name (argv[0]) passed to ilb_probe to indicate a ping test */
#define ILB_PROBE_PING "ilb_ping"
/* Use the first character of the rule's hcname to decide if rule has HC. */
#define RULE_HAS_HC(irl) ((irl)->irl_info.rl_hcname[0] != '\0')
/* Type of probe test */
typedef enum {
ILBD_HC_PING = 1, /* ICMP Echo probe */
ILBD_HC_TCP, /* TCP connect probe */
ILBD_HC_UDP, /* UDP packet probe */
ILBD_HC_USER /* User supplied probe */
} ilbd_hc_test_t;
/* Struct representing a hc object in ilbd */
typedef struct {
list_node_t ihc_link; /* List linkage */
ilb_hc_info_t ihc_info;
/* Short hand for the fields inside ilb_hc_info_t */
#define ihc_name ihc_info.hci_name
#define ihc_test ihc_info.hci_test
#define ihc_timeout ihc_info.hci_timeout
#define ihc_count ihc_info.hci_count
#define ihc_interval ihc_info.hci_interval
#define ihc_def_ping ihc_info.hci_def_ping
ilbd_hc_test_t ihc_test_type; /* Type of probe test */
int ihc_rule_cnt; /* Num of rules associated with hc */
list_t ihc_rules; /* Rules associated with this hc */
} ilbd_hc_t;
struct ilbd_hc_srv_s;
/*
* Struct representing a hc rule object
*
* hcr_link: list linkage
* hcr_rule: pointer to the ilbd rule object
* hcr_servers: list of servers of this rule
*/
typedef struct {
list_node_t hcr_link;
ilbd_rule_t const *hcr_rule;
list_t hcr_servers;
} ilbd_hc_rule_t;
struct ilbd_hc_srv_s;
/*
* Struct representing a event of the probe process
*
* ihp_ev: the event type, which is ILBD_EVENT_PROBE
* ihp_srv: pointer to the hc server object
* ihp_pid: pid of the probe process
* ihp_done: is ilbd done reading the output of the probe process
*/
typedef struct {
ilbd_event_t ihp_ev;
struct ilbd_hc_srv_s *ihp_srv;
pid_t ihp_pid;
boolean_t ihp_done;
} ilbd_hc_probe_event_t;
/*
* ilbd_hc_srv_t state
*
* ihd_hc_def_pinging: the default ping should be run
* ihd-hc_probing: the probe process should be started
*/
enum ilbd_hc_state {
ilbd_hc_def_pinging,
ilbd_hc_probing
};
/*
* Struct representing a server associated with a hc object
*
* shc_srv_link: list linkage
* shc_hc: pointer to the hc object
* shc_hc_rule: pointer to the hc rule object
* shc_sg_srv: pointer to the server group object
* shc_tid: timeout ID
* shc_cur_cnt: number of times the hc probe has been run
* shc_fail_cnt: number of consecutive probe failure
* shc_status: health status
* shc_rtt: rtt (in micro sec) to the backend server
* shc_lasttimer: last time a probe sequence is executed
* shc_nexttime: next time a probe sequence is executed
* shc_state: hc probe state
* shc_child_pid: pid of the probe process
* shc_child_fd: fd to the output of the probe process
* shc_ev: event object of the probe process
* shc_ev_port: event port of the event object
*/
typedef struct ilbd_hc_srv_s {
list_node_t shc_srv_link;
ilbd_hc_t *shc_hc;
ilbd_hc_rule_t *shc_hc_rule;
ilb_sg_srv_t const *shc_sg_srv;
iu_timer_id_t shc_tid;
uint_t shc_cur_cnt;
uint_t shc_fail_cnt;
ilb_hc_srv_status_t shc_status;
uint32_t shc_rtt;
time_t shc_lasttime;
time_t shc_nexttime;
enum ilbd_hc_state shc_state;
pid_t shc_child_pid;
int shc_child_fd;
ilbd_hc_probe_event_t *shc_ev;
int shc_ev_port;
} ilbd_hc_srv_t;
/*
* Structure for holding audit server and servergroup event
* data. Not all events use all members of the structure.
*/
typedef struct audit_sg_event_data {
int32_t ed_ipaddr_type; /* ADT_IPv4 or ADT_IPv6 */
uint32_t ed_server_address[4]; /* server's IP address */
char *ed_serverid; /* serverid. */
uint16_t ed_minport; /* server's minport */
uint16_t ed_maxport; /* server's maxport */
char *ed_sgroup; /* servergroup */
} audit_sg_event_data_t;
/* Struct to store client info */
typedef struct {
ilbd_event_t cli_ev;
int cli_sd;
struct passwd cli_pw;
size_t cli_pw_bufsz;
char *cli_pw_buf;
ilbd_cmd_t cli_cmd;
ilb_comm_t *cli_saved_reply;
size_t cli_saved_size;
ucred_t *cli_peer_ucredp; /* needed for auditing */
} ilbd_client_t;
void ilbd_reply_ok(uint32_t *, size_t *);
void ilbd_reply_err(uint32_t *, size_t *, ilb_status_t);
ilb_status_t ilbd_check_client_config_auth(const struct passwd *);
ilb_status_t ilbd_check_client_enable_auth(const struct passwd *);
ilb_status_t ilbd_retrieve_names(ilbd_cmd_t, uint32_t *, size_t *);
void i_setup_sg_hlist(void);
void i_setup_rule_hlist(void);
void logperror(const char *);
ilb_status_t ilbd_add_server_to_group(ilb_sg_info_t *, int,
const struct passwd *, ucred_t *);
ilb_status_t ilbd_rem_server_from_group(ilb_sg_info_t *, int,
const struct passwd *, ucred_t *);
ilb_status_t ilbd_create_sg(ilb_sg_info_t *, int,
const struct passwd *, ucred_t *);
ilb_status_t ilbd_destroy_sg(const char *, const struct passwd *,
ucred_t *);
ilb_status_t ilbd_retrieve_sg_hosts(const char *, uint32_t *, size_t *);
ilb_status_t ilbd_enable_server(ilb_sg_info_t *, const struct passwd *,
ucred_t *);
ilb_status_t ilbd_disable_server(ilb_sg_info_t *, const struct passwd *,
ucred_t *);
ilb_status_t ilbd_k_Xable_server(const struct in6_addr *, const char *,
ilbd_srv_status_ind_t);
ilb_status_t i_add_srv2krules(list_t *, ilb_sg_srv_t *, int);
ilb_status_t i_rem_srv_frm_krules(list_t *, ilb_sg_srv_t *, int);
int ilbd_get_num_krules(void);
ilb_status_t ilbd_get_krule_names(ilbd_namelist_t **, int);
ilb_status_t ilb_get_krule_servers(ilb_sg_info_t *);
ilbd_sg_t *i_find_sg_byname(const char *);
ilb_status_t i_check_srv2rules(list_t *, ilb_sg_srv_t *);
ilb_status_t ilbd_address_to_srvID(ilb_sg_info_t *, uint32_t *, size_t *);
ilb_status_t ilbd_srvID_to_address(ilb_sg_info_t *, uint32_t *, size_t *);
ilb_status_t do_ioctl(void *, ssize_t);
ilb_status_t ilbd_create_rule(ilb_rule_info_t *, int, const struct passwd *,
ucred_t *);
ilb_status_t ilbd_retrieve_rule(ilbd_name_t, uint32_t *, size_t *);
ilb_status_t ilbd_destroy_rule(ilbd_name_t, const struct passwd *,
ucred_t *);
ilb_status_t ilbd_enable_rule(ilbd_name_t, const struct passwd *, ucred_t *);
ilb_status_t ilbd_disable_rule(ilbd_name_t, const struct passwd *,
ucred_t *);
boolean_t is_debugging_on(void);
ilb_status_t ilbd_sg_check_rule_port(ilbd_sg_t *, ilb_rule_info_t *);
void ilbd_enable_debug(void);
ilb_status_t ilb_map_errno2ilbstat(int);
ilb_status_t i_attach_rule2sg(ilbd_sg_t *, ilbd_rule_t *);
/* Logging routine and macros */
void ilbd_log(int, const char *, ...);
#define logerr(...) ilbd_log(LOG_ERR, __VA_ARGS__)
#define logdebug(...) ilbd_log(LOG_DEBUG, __VA_ARGS__)
/* Health check manipulation routines */
void i_ilbd_setup_hc_list(void);
ilb_status_t ilbd_create_hc(const ilb_hc_info_t *, int,
const struct passwd *, ucred_t *);
ilb_status_t ilbd_destroy_hc(const char *, const struct passwd *, ucred_t *);
ilbd_hc_t *ilbd_get_hc(const char *);
ilb_status_t ilbd_get_hc_info(const char *, uint32_t *, size_t *);
ilb_status_t ilbd_get_hc_srvs(const char *, uint32_t *, size_t *);
ilb_status_t ilbd_hc_associate_rule(const ilbd_rule_t *, int);
ilb_status_t ilbd_hc_dissociate_rule(const ilbd_rule_t *);
ilb_status_t ilbd_hc_add_server(const ilbd_rule_t *, const ilb_sg_srv_t *,
int);
ilb_status_t ilbd_hc_del_server(const ilbd_rule_t *, const ilb_sg_srv_t *);
ilb_status_t ilbd_hc_enable_rule(const ilbd_rule_t *);
ilb_status_t ilbd_hc_disable_rule(const ilbd_rule_t *);
ilb_status_t ilbd_hc_enable_server(const ilbd_rule_t *,
const ilb_sg_srv_t *);
ilb_status_t ilbd_hc_disable_server(const ilbd_rule_t *,
const ilb_sg_srv_t *);
/* Health check timer routines */
void ilbd_hc_probe_return(int, int, int, ilbd_hc_probe_event_t *);
void ilbd_hc_timer_init(int, ilbd_timer_event_obj_t *);
void ilbd_hc_timeout(void);
void ilbd_hc_timer_update(ilbd_timer_event_obj_t *);
/* Show NAT info routines */
ilb_status_t ilbd_show_nat(void *, const ilb_comm_t *, uint32_t *,
size_t *);
void ilbd_show_nat_cleanup(void);
/* Show sticky info routines */
ilb_status_t ilbd_show_sticky(void *, const ilb_comm_t *, uint32_t *,
size_t *);
void ilbd_show_sticky_cleanup(void);
ilb_status_t ilbd_create_pg(ilbd_scf_pg_type_t, void *);
ilb_status_t ilbd_destroy_pg(ilbd_scf_pg_type_t, const char *);
ilb_status_t ilbd_change_prop(ilbd_scf_pg_type_t, const char *,
const char *, void *);
void ilbd_scf_str_to_ip(int, char *, struct in6_addr *);
ilb_status_t ilbd_scf_ip_to_str(uint16_t, struct in6_addr *, scf_type_t *,
char *);
ilb_status_t ilbd_scf_add_srv(ilbd_sg_t *, ilbd_srv_t *);
ilb_status_t ilbd_scf_del_srv(ilbd_sg_t *, ilbd_srv_t *);
int ilbd_scf_limit(int);
ilb_status_t ilbd_walk_rule_pgs(ilb_status_t (*)(ilb_rule_info_t *, int,
const struct passwd *, ucred_t *), void *, void *);
ilb_status_t ilbd_walk_sg_pgs(ilb_status_t (*)(ilb_sg_info_t *, int,
const struct passwd *, ucred_t *), void *, void *);
ilb_status_t ilbd_walk_hc_pgs(ilb_status_t (*)(const ilb_hc_info_t *, int,
const struct passwd *, ucred_t *), void *, void *);
void ilbd_algo_to_str(ilb_algo_t, char *);
void ilbd_topo_to_str(ilb_topo_t, char *);
void ilbd_ip_to_str(uint16_t, struct in6_addr *, char *);
void cvt_addr(uint32_t *, int32_t, struct in6_addr);
int ilberror2auditerror(ilb_status_t);
#ifdef __cplusplus
}
#endif
#endif /* _ILBD_H */