carp.c revision 1.1.20.1
1 /* $NetBSD: carp.c,v 1.1.20.1 2008/06/02 13:21:22 mjf Exp $ */ 2 3 /* 4 * Copyright (c) 2002 Michael Shalayeff. All rights reserved. 5 * Copyright (c) 2003 Ryan McBride. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT, 20 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 22 * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 24 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 25 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 26 * THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/param.h> 30 #include <sys/ioctl.h> 31 #include <sys/socket.h> 32 #include <sys/sockio.h> 33 34 #include <net/if.h> 35 #include <netinet/ip_carp.h> 36 #include <net/route.h> 37 38 #include <stdio.h> 39 #include <string.h> 40 #include <stdlib.h> 41 #include <unistd.h> 42 #include <err.h> 43 #include <errno.h> 44 #include <util.h> 45 46 #include "env.h" 47 #include "parse.h" 48 #include "extern.h" 49 #include "carp.h" 50 51 static const char *carp_states[] = { CARP_STATES }; 52 53 #ifndef INET_ONLY 54 struct kwinst carpstatekw[] = { 55 {.k_word = "INIT", .k_nextparser = &command_root.pb_parser} 56 , {.k_word = "BACKUP", .k_nextparser = &command_root.pb_parser} 57 , {.k_word = "MASTER", .k_nextparser = &command_root.pb_parser} 58 }; 59 60 struct pinteger parse_advbase = PINTEGER_INITIALIZER1(&parse_advbase, "advbase", 61 0, 255, 10, setcarp_advbase, "advbase", &command_root.pb_parser); 62 63 struct pinteger parse_advskew = PINTEGER_INITIALIZER1(&parse_advskew, "advskew", 64 0, 254, 10, setcarp_advskew, "advskew", &command_root.pb_parser); 65 66 struct piface carpdev = PIFACE_INITIALIZER(&carpdev, "carpdev", setcarpdev, 67 "carpdev", &command_root.pb_parser); 68 69 struct pkw carpstate = PKW_INITIALIZER(&carpstate, "carp state", NULL, 70 "carp_state", carpstatekw, __arraycount(carpstatekw), 71 &command_root.pb_parser); 72 73 struct pstr pass = PSTR_INITIALIZER(&pass, "pass", setcarp_passwd, 74 "pass", &command_root.pb_parser); 75 76 struct pinteger parse_vhid = PINTEGER_INITIALIZER1(&vhid, "vhid", 77 0, 255, 10, setcarp_vhid, "vhid", &command_root.pb_parser); 78 79 static const struct kwinst carpkw[] = { 80 {.k_word = "advbase", .k_nextparser = &parse_advbase.pi_parser} 81 , {.k_word = "advskew", .k_nextparser = &parse_advskew.pi_parser} 82 , {.k_word = "carpdev", .k_nextparser = &carpdev.pif_parser} 83 , {.k_word = "-carpdev", .k_key = "carpdev", .k_type = KW_T_STR, 84 .k_str = "", .k_exec = setcarpdev, 85 .k_nextparser = &command_root.pb_parser} 86 , {.k_word = "pass", .k_nextparser = &pass.ps_parser} 87 , {.k_word = "state", .k_nextparser = &carpstate.pk_parser} 88 , {.k_word = "vhid", .k_nextparser = &parse_vhid.pi_parser} 89 }; 90 91 struct pkw carp = PKW_INITIALIZER(&carp, "CARP", NULL, NULL, 92 carpkw, __arraycount(carpkw), NULL); 93 94 #endif 95 96 void 97 carp_status(prop_dictionary_t env, prop_dictionary_t oenv) 98 { 99 const char *state; 100 struct carpreq carpr; 101 102 memset(&carpr, 0, sizeof(carpr)); 103 104 if (indirect_ioctl(env, SIOCGVH, &carpr) == -1) 105 return; 106 107 if (carpr.carpr_vhid <= 0) 108 return; 109 if (carpr.carpr_state > CARP_MAXSTATE) 110 state = "<UNKNOWN>"; 111 else 112 state = carp_states[carpr.carpr_state]; 113 114 printf("\tcarp: %s carpdev %s vhid %d advbase %d advskew %d\n", 115 state, carpr.carpr_carpdev[0] != '\0' ? 116 carpr.carpr_carpdev : "none", carpr.carpr_vhid, 117 carpr.carpr_advbase, carpr.carpr_advskew); 118 } 119 120 int 121 setcarp_passwd(prop_dictionary_t env, prop_dictionary_t xenv) 122 { 123 struct carpreq carpr; 124 prop_data_t data; 125 126 data = (prop_data_t)prop_dictionary_get(env, "pass"); 127 if (data == NULL) { 128 errno = ENOENT; 129 return -1; 130 } 131 132 memset(&carpr, 0, sizeof(carpr)); 133 134 if (indirect_ioctl(env, SIOCGVH, &carpr) == -1) 135 err(EXIT_FAILURE, "SIOCGVH"); 136 137 memset(carpr.carpr_key, 0, sizeof(carpr.carpr_key)); 138 /* XXX Should hash the password into the key here, perhaps? */ 139 strlcpy((char *)carpr.carpr_key, prop_data_data_nocopy(data), 140 MIN(CARP_KEY_LEN, prop_data_size(data))); 141 142 if (indirect_ioctl(env, SIOCSVH, &carpr) == -1) 143 err(EXIT_FAILURE, "SIOCSVH"); 144 return 0; 145 } 146 147 int 148 setcarp_vhid(prop_dictionary_t env, prop_dictionary_t xenv) 149 { 150 struct carpreq carpr; 151 int64_t vhid; 152 153 if (!prop_dictionary_get_int64(env, "vhid", &vhid)) { 154 errno = ENOENT; 155 return -1; 156 } 157 158 memset(&carpr, 0, sizeof(struct carpreq)); 159 160 if (indirect_ioctl(env, SIOCGVH, &carpr) == -1) 161 err(EXIT_FAILURE, "SIOCGVH"); 162 163 carpr.carpr_vhid = vhid; 164 165 if (indirect_ioctl(env, SIOCSVH, &carpr) == -1) 166 err(EXIT_FAILURE, "SIOCSVH"); 167 return 0; 168 } 169 170 int 171 setcarp_advskew(prop_dictionary_t env, prop_dictionary_t xenv) 172 { 173 struct carpreq carpr; 174 int64_t advskew; 175 176 if (!prop_dictionary_get_int64(env, "advskew", &advskew)) { 177 errno = ENOENT; 178 return -1; 179 } 180 181 memset(&carpr, 0, sizeof(carpr)); 182 183 if (indirect_ioctl(env, SIOCGVH, &carpr) == -1) 184 err(EXIT_FAILURE, "SIOCGVH"); 185 186 carpr.carpr_advskew = advskew; 187 188 if (indirect_ioctl(env, SIOCSVH, &carpr) == -1) 189 err(EXIT_FAILURE, "SIOCSVH"); 190 return 0; 191 } 192 193 /* ARGSUSED */ 194 int 195 setcarp_advbase(prop_dictionary_t env, prop_dictionary_t xenv) 196 { 197 struct carpreq carpr; 198 int64_t advbase; 199 200 if (!prop_dictionary_get_int64(env, "advbase", &advbase)) { 201 errno = ENOENT; 202 return -1; 203 } 204 205 memset(&carpr, 0, sizeof(carpr)); 206 207 if (indirect_ioctl(env, SIOCGVH, &carpr) == -1) 208 err(EXIT_FAILURE, "SIOCGVH"); 209 210 carpr.carpr_advbase = advbase; 211 212 if (indirect_ioctl(env, SIOCSVH, &carpr) == -1) 213 err(EXIT_FAILURE, "SIOCSVH"); 214 return 0; 215 } 216 217 /* ARGSUSED */ 218 int 219 setcarp_state(prop_dictionary_t env, prop_dictionary_t xenv) 220 { 221 struct carpreq carpr; 222 int64_t carp_state; 223 224 if (!prop_dictionary_get_int64(env, "carp_state", &carp_state)) { 225 errno = ENOENT; 226 return -1; 227 } 228 229 memset(&carpr, 0, sizeof(carpr)); 230 231 if (indirect_ioctl(env, SIOCGVH, &carpr) == -1) 232 err(EXIT_FAILURE, "SIOCGVH"); 233 234 carpr.carpr_state = carp_state; 235 236 if (indirect_ioctl(env, SIOCSVH, &carpr) == -1) 237 err(EXIT_FAILURE, "SIOCSVH"); 238 return 0; 239 } 240 241 /* ARGSUSED */ 242 int 243 setcarpdev(prop_dictionary_t env, prop_dictionary_t xenv) 244 { 245 struct carpreq carpr; 246 prop_data_t data; 247 248 data = (prop_data_t)prop_dictionary_get(env, "carpdev"); 249 if (data == NULL) { 250 errno = ENOENT; 251 return -1; 252 } 253 254 memset(&carpr, 0, sizeof(carpr)); 255 256 if (indirect_ioctl(env, SIOCGVH, &carpr) == -1) 257 err(EXIT_FAILURE, "SIOCGVH"); 258 259 strlcpy(carpr.carpr_carpdev, prop_data_data_nocopy(data), 260 MIN(sizeof(carpr.carpr_carpdev), prop_data_size(data))); 261 262 if (indirect_ioctl(env, SIOCSVH, &carpr) == -1) 263 err(EXIT_FAILURE, "SIOCSVH"); 264 return 0; 265 } 266
Indexes created Wed Oct 22 06:10:02 GMT 2025