1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #ifndef _LIBVRRPADM_H 28 #define _LIBVRRPADM_H 29 30 #include <sys/types.h> 31 #include <sys/socket.h> 32 #include <netinet/in.h> /* in(6)_addr_t */ 33 #include <arpa/inet.h> 34 #include <net/if.h> /* LIFNAMSIZ */ 35 #include <limits.h> 36 #include <netinet/vrrp.h> 37 #include <syslog.h> 38 #include <libdladm.h> 39 40 #ifdef __cplusplus 41 extern "C" { 42 #endif 43 44 #define VRRP_NAME_MAX 32 45 #define VRRPD_SOCKET "/var/run/vrrpd.socket" 46 47 /* 48 * to store the IP addresses 49 */ 50 typedef struct vrrp_addr { 51 union { 52 struct sockaddr_in a4; 53 struct sockaddr_in6 a6; 54 } in; 55 #define in4 in.a4 56 #define in6 in.a6 57 } vrrp_addr_t; 58 59 /* 60 * VRRP instance (configuration information). 61 * Passed to vrrp_create(), returned by vrrp_query(). 62 */ 63 typedef struct vrrp_vr_conf_s { 64 char vvc_name[VRRP_NAME_MAX]; /* VRRP router name */ 65 char vvc_link[MAXLINKNAMELEN]; /* data-link name */ 66 vrid_t vvc_vrid; /* VRID */ 67 int vvc_af; /* IPv4/IPv6 */ 68 int vvc_pri; 69 uint32_t vvc_adver_int; /* in ms */ 70 boolean_t vvc_preempt; 71 boolean_t vvc_accept; 72 boolean_t vvc_enabled; 73 } vrrp_vr_conf_t; 74 75 /* 76 * VRRP state machine 77 */ 78 typedef enum { 79 VRRP_STATE_NONE = -1, 80 VRRP_STATE_INIT, 81 VRRP_STATE_MASTER, 82 VRRP_STATE_BACKUP 83 } vrrp_state_t; 84 85 /* 86 * VRRP status structure 87 * Returned by vrrp_query() as part of vrrp_queryinfo_t. 88 */ 89 typedef struct vrrp_statusinfo_s { 90 vrrp_state_t vs_state; 91 vrrp_state_t vs_prev_state; 92 struct timeval vs_st_time; /* timestamp of last state trans */ 93 } vrrp_stateinfo_t; 94 95 /* 96 * The information obtained from peer's advertisements 97 * Returned by vrrp_query() as part of vrrp_queryinfo_t. 98 */ 99 typedef struct vrrp_peer_s { 100 vrrp_addr_t vp_addr; /* source IP addr of the message */ 101 int vp_prio; /* priority in adv message */ 102 struct timeval vp_time; /* timestamp of the adv message */ 103 int vp_adver_int; /* adv interval in adv message */ 104 } vrrp_peer_t; 105 106 /* 107 * Useful timer information, in ms 108 */ 109 typedef struct vrrp_timeinfo_s { 110 int vt_since_last_tran; /* time since last state transition */ 111 int vt_since_last_adv; /* time since last advertisement */ 112 int vt_master_down_intv; /* timer interval for backup to */ 113 /* declare master down */ 114 } vrrp_timerinfo_t; 115 116 /* 117 * Address information 118 */ 119 typedef struct vrrp_addrinfo_s { 120 char va_vnic[MAXLINKNAMELEN]; 121 vrrp_addr_t va_primary; 122 uint32_t va_vipcnt; 123 vrrp_addr_t va_vips[1]; 124 } vrrp_addrinfo_t; 125 126 /* 127 * VRRP instance configuration and run-time states information 128 * Returned by vrrp_query(). 129 */ 130 typedef struct vrrp_queryinfo { 131 vrrp_vr_conf_t show_vi; 132 vrrp_stateinfo_t show_vs; 133 vrrp_peer_t show_vp; 134 vrrp_timerinfo_t show_vt; 135 vrrp_addrinfo_t show_va; 136 } vrrp_queryinfo_t; 137 138 /* 139 * flags sent with the VRRP_CMD_MODIFY command. Used in vrrp_setprop(). 140 */ 141 #define VRRP_CONF_PRIORITY 0x01 142 #define VRRP_CONF_INTERVAL 0x02 143 #define VRRP_CONF_PREEMPT 0x04 144 #define VRRP_CONF_ACCEPT 0x08 145 146 /* 147 * Errors 148 */ 149 typedef enum { 150 VRRP_SUCCESS = 0, 151 VRRP_EINVAL, /* invalid parameter */ 152 VRRP_EINVALVRNAME, /* invalid router name */ 153 VRRP_ENOMEM, /* no memory */ 154 VRRP_ENOVIRT, /* no virtual IP addresses */ 155 VRRP_ENOPRIM, /* no primary IP address */ 156 VRRP_ENOVNIC, /* no vnic created */ 157 VRRP_ENOLINK, /* the link does not exist */ 158 VRRP_EINVALLINK, /* invalid link */ 159 VRRP_EINVALADDR, /* invalid IP address */ 160 VRRP_EINVALAF, /* invalid IP address familty */ 161 VRRP_EDB, /* configuration error */ 162 VRRP_EPERM, /* permission denied */ 163 VRRP_EBADSTATE, /* VRRP router in bad state */ 164 VRRP_EVREXIST, /* <vrid, intf, af> three-tuple exists */ 165 VRRP_EINSTEXIST, /* router name already exists */ 166 VRRP_EEXIST, /* already exists */ 167 VRRP_ENOTFOUND, /* vrrp router not found */ 168 VRRP_ETOOSMALL, /* too small space */ 169 VRRP_EAGAIN, /* Try again */ 170 VRRP_EALREADY, /* already */ 171 VRRP_EDLADM, /* dladm failure */ 172 VRRP_EIPADM, /* ipadm failure */ 173 VRRP_ESYS, /* system error */ 174 VRRP_ECMD /* command request error */ 175 } vrrp_err_t; 176 177 /* 178 * Internal commands used between vrrpadm and vrrpd. 179 */ 180 typedef enum { 181 VRRP_CMD_RETURN = 0, 182 VRRP_CMD_CREATE, 183 VRRP_CMD_DELETE, 184 VRRP_CMD_ENABLE, 185 VRRP_CMD_DISABLE, 186 VRRP_CMD_MODIFY, 187 VRRP_CMD_LIST, 188 VRRP_CMD_QUERY 189 } vrrp_cmd_type_t; 190 191 #define addr_len(af) ((af) == AF_INET ? sizeof (in_addr_t): sizeof (in6_addr_t)) 192 193 #define VRRPADDR_UNSPECIFIED(af, addr) \ 194 (((af) == AF_INET6 && IN6_IS_ADDR_UNSPECIFIED( \ 195 &(addr)->in6.sin6_addr)) || ((af) == AF_INET && \ 196 ((addr)->in4.sin_addr.s_addr == INADDR_ANY))) 197 198 #define VRRPADDR2STR(af, addr, abuf, size, append) { \ 199 char ap[INET6_ADDRSTRLEN]; \ 200 \ 201 if (VRRPADDR_UNSPECIFIED(af, addr)) { \ 202 (void) strlcpy(ap, "--", INET6_ADDRSTRLEN); \ 203 } else if ((af) == AF_INET) { \ 204 (void) inet_ntop((af), &(addr)->in4.sin_addr, ap, \ 205 INET6_ADDRSTRLEN); \ 206 } else { \ 207 (void) inet_ntop((af), &(addr)->in6.sin6_addr, ap, \ 208 INET6_ADDRSTRLEN); \ 209 } \ 210 if (append) \ 211 (void) strlcat(abuf, ap, size); \ 212 else \ 213 (void) strlcpy(abuf, ap, size); \ 214 } 215 216 typedef struct vrrp_cmd_create_s { 217 uint32_t vcc_cmd; 218 vrrp_vr_conf_t vcc_conf; 219 } vrrp_cmd_create_t; 220 221 typedef struct vrrp_ret_create_s { 222 vrrp_err_t vrc_err; 223 } vrrp_ret_create_t; 224 225 typedef struct vrrp_cmd_delete_s { 226 uint32_t vcd_cmd; 227 char vcd_name[VRRP_NAME_MAX]; 228 } vrrp_cmd_delete_t; 229 230 typedef struct vrrp_ret_delete_s { 231 vrrp_err_t vrd_err; 232 } vrrp_ret_delete_t; 233 234 typedef struct vrrp_cmd_enable_s { 235 uint32_t vcs_cmd; 236 char vcs_name[VRRP_NAME_MAX]; 237 } vrrp_cmd_enable_t; 238 239 typedef struct vrrp_ret_enable_s { 240 vrrp_err_t vrs_err; 241 } vrrp_ret_enable_t; 242 243 typedef struct vrrp_cmd_disable_s { 244 uint32_t vcx_cmd; 245 char vcx_name[VRRP_NAME_MAX]; 246 } vrrp_cmd_disable_t; 247 248 typedef struct vrrp_ret_disable_s { 249 vrrp_err_t vrx_err; 250 } vrrp_ret_disable_t; 251 252 typedef struct vrrp_cmd_modify_s { 253 uint32_t vcm_cmd; 254 uint32_t vcm_mask; 255 vrrp_vr_conf_t vcm_conf; 256 } vrrp_cmd_modify_t; 257 258 typedef struct vrrp_ret_modify_s { 259 vrrp_err_t vrm_err; 260 } vrrp_ret_modify_t; 261 262 typedef struct vrrp_cmd_list_s { 263 uint32_t vcl_cmd; 264 vrid_t vcl_vrid; 265 char vcl_ifname[LIFNAMSIZ]; 266 int vcl_af; 267 } vrrp_cmd_list_t; 268 269 typedef struct vrrp_ret_list_s { 270 vrrp_err_t vrl_err; 271 uint32_t vrl_cnt; 272 /* 273 * When vrl_cnt is non-zero, the return structure will be followed 274 * by the list of router names, separated by '\0'. Its size will 275 * be vrl_cnt * VRRP_NAME_MAX. 276 */ 277 } vrrp_ret_list_t; 278 279 typedef struct vrrp_cmd_query_s { 280 uint32_t vcq_cmd; 281 char vcq_name[VRRP_NAME_MAX]; 282 } vrrp_cmd_query_t; 283 284 typedef struct vrrp_ret_query_s { 285 vrrp_err_t vrq_err; 286 vrrp_queryinfo_t vrq_qinfo; 287 } vrrp_ret_query_t; 288 289 /* 290 * Union of all VRRP commands 291 */ 292 typedef union vrrp_cmd_s { 293 uint32_t vc_cmd; 294 vrrp_cmd_create_t vc_cmd_create; 295 vrrp_cmd_delete_t vc_cmd_delete; 296 vrrp_cmd_enable_t vc_cmd_enable; 297 vrrp_cmd_disable_t vc_cmd_disable; 298 vrrp_cmd_modify_t vc_cmd_modify; 299 vrrp_cmd_list_t vc_cmd_list; 300 } vrrp_cmd_t; 301 302 /* 303 * Union of all VRRP replies of the VRRP commands 304 */ 305 typedef union vrrp_ret_s { 306 vrrp_err_t vr_err; 307 vrrp_ret_create_t vr_ret_create; 308 vrrp_ret_delete_t vr_ret_delete; 309 vrrp_ret_enable_t vr_ret_enable; 310 vrrp_ret_disable_t vr_ret_disable; 311 vrrp_ret_modify_t vr_ret_modify; 312 vrrp_ret_list_t vr_ret_list; 313 vrrp_ret_query_t vr_ret_query; 314 } vrrp_ret_t; 315 316 /* 317 * Public APIs 318 */ 319 struct vrrp_handle { 320 dladm_handle_t vh_dh; 321 }; 322 typedef struct vrrp_handle *vrrp_handle_t; 323 324 const char *vrrp_err2str(vrrp_err_t); 325 const char *vrrp_state2str(vrrp_state_t); 326 327 vrrp_err_t vrrp_open(vrrp_handle_t *); 328 void vrrp_close(vrrp_handle_t); 329 330 boolean_t vrrp_valid_name(const char *); 331 332 vrrp_err_t vrrp_create(vrrp_handle_t, vrrp_vr_conf_t *); 333 vrrp_err_t vrrp_delete(vrrp_handle_t, const char *); 334 335 vrrp_err_t vrrp_enable(vrrp_handle_t, const char *); 336 vrrp_err_t vrrp_disable(vrrp_handle_t, const char *); 337 338 vrrp_err_t vrrp_modify(vrrp_handle_t, vrrp_vr_conf_t *, uint32_t); 339 340 vrrp_err_t vrrp_query(vrrp_handle_t, const char *, vrrp_queryinfo_t **); 341 342 vrrp_err_t vrrp_list(vrrp_handle_t, vrid_t, const char *, int, 343 uint32_t *, char *); 344 345 boolean_t vrrp_is_vrrp_vnic(vrrp_handle_t, datalink_id_t, 346 datalink_id_t *, uint16_t *, vrid_t *, int *); 347 348 vrrp_err_t vrrp_get_vnicname(vrrp_handle_t, vrid_t, int, char *, 349 datalink_id_t *, uint16_t *, char *, size_t); 350 351 #ifdef __cplusplus 352 } 353 #endif 354 355 #endif /* _LIBVRRPADM_H */ 356