1 /* 2 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 3 * Use is subject to license terms. 4 */ 5 6 7 /* 8 * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC") 9 * Copyright (c) 1996-1999 by Internet Software Consortium. 10 * 11 * Permission to use, copy, modify, and distribute this software for any 12 * purpose with or without fee is hereby granted, provided that the above 13 * copyright notice and this permission notice appear in all copies. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES 16 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 17 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR 18 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 19 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 20 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT 21 * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 22 */ 23 24 /*! \file 25 * \brief 26 * this is the top level dispatcher 27 * 28 * The dispatcher is implemented as an accessor class; it is an 29 * accessor class that calls other accessor classes, as controlled by a 30 * configuration file. 31 * 32 * A big difference between this accessor class and others is that the 33 * map class initializers are NULL, and the map classes are already 34 * filled in with method functions that will do the right thing. 35 */ 36 37 /* Imports */ 38 39 #include "port_before.h" 40 41 #include <isc/assertions.h> 42 #include <ctype.h> 43 #include <errno.h> 44 #include <stdio.h> 45 #include <stdlib.h> 46 #include <string.h> 47 48 #include <sys/types.h> 49 #include <netinet/in.h> 50 #include <arpa/nameser.h> 51 #include <resolv.h> 52 53 #include <isc/memcluster.h> 54 #include <irs.h> 55 56 #include "port_after.h" 57 58 #include "irs_p.h" 59 #include "gen_p.h" 60 61 #ifdef SUNW_HOSTS_FALLBACK 62 extern int __res_no_hosts_fallback(void); 63 #endif /* SUNW_HOSTS_FALLBACK */ 64 65 /* Definitions */ 66 67 struct nameval { 68 const char * name; 69 int val; 70 }; 71 72 static const struct nameval acc_names[irs_nacc+1] = { 73 { "local", irs_lcl }, 74 { "dns", irs_dns }, 75 { "nis", irs_nis }, 76 { "irp", irs_irp }, 77 { NULL, irs_nacc } 78 }; 79 80 typedef struct irs_acc *(*accinit) __P((const char *options)); 81 82 static const accinit accs[irs_nacc+1] = { 83 irs_lcl_acc, 84 irs_dns_acc, 85 #ifdef WANT_IRS_NIS 86 irs_nis_acc, 87 #else 88 NULL, 89 #endif 90 irs_irp_acc, 91 NULL 92 }; 93 94 static const struct nameval map_names[irs_nmap+1] = { 95 { "group", irs_gr }, 96 { "passwd", irs_pw }, 97 { "services", irs_sv }, 98 { "protocols", irs_pr }, 99 { "hosts", irs_ho }, 100 { "networks", irs_nw }, 101 { "netgroup", irs_ng }, 102 { NULL, irs_nmap } 103 }; 104 105 static const struct nameval option_names[] = { 106 { "merge", IRS_MERGE }, 107 { "continue", IRS_CONTINUE }, 108 { NULL, 0 } 109 }; 110 111 /* Forward */ 112 113 static void gen_close(struct irs_acc *); 114 static struct __res_state * gen_res_get(struct irs_acc *); 115 static void gen_res_set(struct irs_acc *, struct __res_state *, 116 void (*)(void *)); 117 static int find_name(const char *, const struct nameval nv[]); 118 static void init_map_rules(struct gen_p *, const char *conf_file); 119 static struct irs_rule *release_rule(struct irs_rule *); 120 static int add_rule(struct gen_p *, 121 enum irs_map_id, enum irs_acc_id, 122 const char *); 123 124 /* Public */ 125 126 struct irs_acc * 127 irs_gen_acc(const char *options, const char *conf_file) { 128 struct irs_acc *acc; 129 struct gen_p *irs; 130 131 if (!(acc = memget(sizeof *acc))) { 132 errno = ENOMEM; 133 return (NULL); 134 } 135 memset(acc, 0x5e, sizeof *acc); 136 if (!(irs = memget(sizeof *irs))) { 137 errno = ENOMEM; 138 memput(acc, sizeof *acc); 139 return (NULL); 140 } 141 memset(irs, 0x5e, sizeof *irs); 142 irs->options = strdup(options); 143 irs->res = NULL; 144 irs->free_res = NULL; 145 memset(irs->accessors, 0, sizeof irs->accessors); 146 memset(irs->map_rules, 0, sizeof irs->map_rules); 147 init_map_rules(irs, conf_file); 148 acc->private = irs; 149 #ifdef WANT_IRS_GR 150 acc->gr_map = irs_gen_gr; 151 #else 152 acc->gr_map = NULL; 153 #endif 154 #ifdef WANT_IRS_PW 155 acc->pw_map = irs_gen_pw; 156 #else 157 acc->pw_map = NULL; 158 #endif 159 acc->sv_map = irs_gen_sv; 160 acc->pr_map = irs_gen_pr; 161 acc->ho_map = irs_gen_ho; 162 acc->nw_map = irs_gen_nw; 163 acc->ng_map = irs_gen_ng; 164 acc->res_get = gen_res_get; 165 acc->res_set = gen_res_set; 166 acc->close = gen_close; 167 return (acc); 168 } 169 170 /* Methods */ 171 172 static struct __res_state * 173 gen_res_get(struct irs_acc *this) { 174 struct gen_p *irs = (struct gen_p *)this->private; 175 176 if (irs->res == NULL) { 177 struct __res_state *res; 178 res = (struct __res_state *)malloc(sizeof *res); 179 if (res == NULL) 180 return (NULL); 181 memset(res, 0, sizeof *res); 182 gen_res_set(this, res, free); 183 } 184 185 if (((irs->res->options & RES_INIT) == 0U) && res_ninit(irs->res) < 0) 186 return (NULL); 187 188 return (irs->res); 189 } 190 191 static void 192 gen_res_set(struct irs_acc *this, struct __res_state *res, 193 void (*free_res)(void *)) { 194 struct gen_p *irs = (struct gen_p *)this->private; 195 #if 0 196 struct irs_rule *rule; 197 struct irs_ho *ho; 198 struct irs_nw *nw; 199 #endif 200 201 if (irs->res && irs->free_res) { 202 res_nclose(irs->res); 203 (*irs->free_res)(irs->res); 204 } 205 206 irs->res = res; 207 irs->free_res = free_res; 208 209 #if 0 210 for (rule = irs->map_rules[irs_ho]; rule; rule = rule->next) { 211 ho = rule->inst->ho; 212 213 (*ho->res_set)(ho, res, NULL); 214 } 215 for (rule = irs->map_rules[irs_nw]; rule; rule = rule->next) { 216 nw = rule->inst->nw; 217 218 (*nw->res_set)(nw, res, NULL); 219 } 220 #endif 221 } 222 223 static void 224 gen_close(struct irs_acc *this) { 225 struct gen_p *irs = (struct gen_p *)this->private; 226 int n; 227 228 /* Search rules. */ 229 for (n = 0; n < irs_nmap; n++) 230 while (irs->map_rules[n] != NULL) 231 irs->map_rules[n] = release_rule(irs->map_rules[n]); 232 233 /* Access methods. */ 234 for (n = 0; n < irs_nacc; n++) { 235 /* Map objects. */ 236 if (irs->accessors[n].gr != NULL) 237 (*irs->accessors[n].gr->close)(irs->accessors[n].gr); 238 if (irs->accessors[n].pw != NULL) 239 (*irs->accessors[n].pw->close)(irs->accessors[n].pw); 240 if (irs->accessors[n].sv != NULL) 241 (*irs->accessors[n].sv->close)(irs->accessors[n].sv); 242 if (irs->accessors[n].pr != NULL) 243 (*irs->accessors[n].pr->close)(irs->accessors[n].pr); 244 if (irs->accessors[n].ho != NULL) 245 (*irs->accessors[n].ho->close)(irs->accessors[n].ho); 246 if (irs->accessors[n].nw != NULL) 247 (*irs->accessors[n].nw->close)(irs->accessors[n].nw); 248 if (irs->accessors[n].ng != NULL) 249 (*irs->accessors[n].ng->close)(irs->accessors[n].ng); 250 /* Enclosing accessor. */ 251 if (irs->accessors[n].acc != NULL) 252 (*irs->accessors[n].acc->close)(irs->accessors[n].acc); 253 } 254 255 /* The options string was strdup'd. */ 256 free((void*)irs->options); 257 258 if (irs->res && irs->free_res) 259 (*irs->free_res)(irs->res); 260 261 /* The private data container. */ 262 memput(irs, sizeof *irs); 263 264 /* The object. */ 265 memput(this, sizeof *this); 266 } 267 268 /* Private */ 269 270 static int 271 find_name(const char *name, const struct nameval names[]) { 272 int n; 273 274 for (n = 0; names[n].name != NULL; n++) 275 if (strcmp(name, names[n].name) == 0) 276 return (names[n].val); 277 return (-1); 278 } 279 280 static struct irs_rule * 281 release_rule(struct irs_rule *rule) { 282 struct irs_rule *next = rule->next; 283 284 memput(rule, sizeof *rule); 285 return (next); 286 } 287 288 static int 289 add_rule(struct gen_p *irs, 290 enum irs_map_id map, enum irs_acc_id acc, 291 const char *options) 292 { 293 struct irs_rule **rules, *last, *tmp, *new; 294 struct irs_inst *inst; 295 const char *cp; 296 int n; 297 298 #ifndef WANT_IRS_GR 299 if (map == irs_gr) 300 return (-1); 301 #endif 302 #ifndef WANT_IRS_PW 303 if (map == irs_pw) 304 return (-1); 305 #endif 306 #ifndef WANT_IRS_NIS 307 if (acc == irs_nis) 308 return (-1); 309 #endif 310 new = memget(sizeof *new); 311 if (new == NULL) 312 return (-1); 313 memset(new, 0x5e, sizeof *new); 314 new->next = NULL; 315 316 new->inst = &irs->accessors[acc]; 317 318 new->flags = 0; 319 cp = options; 320 while (cp && *cp) { 321 char option[50], *next; 322 323 next = strchr(cp, ','); 324 if (next) 325 n = next++ - cp; 326 else 327 n = strlen(cp); 328 if ((size_t)n > sizeof option - 1) 329 n = sizeof option - 1; 330 strncpy(option, cp, n); 331 option[n] = '\0'; 332 333 n = find_name(option, option_names); 334 if (n >= 0) 335 new->flags |= n; 336 337 cp = next; 338 } 339 340 rules = &irs->map_rules[map]; 341 for (last = NULL, tmp = *rules; 342 tmp != NULL; 343 last = tmp, tmp = tmp->next) 344 (void)NULL; 345 if (last == NULL) 346 *rules = new; 347 else 348 last->next = new; 349 350 /* Try to instantiate map accessors for this if necessary & approp. */ 351 inst = &irs->accessors[acc]; 352 if (inst->acc == NULL && accs[acc] != NULL) 353 inst->acc = (*accs[acc])(irs->options); 354 if (inst->acc != NULL) { 355 if (inst->gr == NULL && inst->acc->gr_map != NULL) 356 inst->gr = (*inst->acc->gr_map)(inst->acc); 357 if (inst->pw == NULL && inst->acc->pw_map != NULL) 358 inst->pw = (*inst->acc->pw_map)(inst->acc); 359 if (inst->sv == NULL && inst->acc->sv_map != NULL) 360 inst->sv = (*inst->acc->sv_map)(inst->acc); 361 if (inst->pr == NULL && inst->acc->pr_map != NULL) 362 inst->pr = (*inst->acc->pr_map)(inst->acc); 363 if (inst->ho == NULL && inst->acc->ho_map != NULL) 364 inst->ho = (*inst->acc->ho_map)(inst->acc); 365 if (inst->nw == NULL && inst->acc->nw_map != NULL) 366 inst->nw = (*inst->acc->nw_map)(inst->acc); 367 if (inst->ng == NULL && inst->acc->ng_map != NULL) 368 inst->ng = (*inst->acc->ng_map)(inst->acc); 369 } 370 371 return (0); 372 } 373 374 static void 375 default_map_rules(struct gen_p *irs) { 376 /* Install time honoured and proved BSD style rules as default. */ 377 add_rule(irs, irs_gr, irs_lcl, ""); 378 add_rule(irs, irs_pw, irs_lcl, ""); 379 add_rule(irs, irs_sv, irs_lcl, ""); 380 add_rule(irs, irs_pr, irs_lcl, ""); 381 #ifdef SUNW_HOSTS_FALLBACK 382 if (__res_no_hosts_fallback()) 383 add_rule(irs, irs_ho, irs_dns, ""); 384 else { 385 add_rule(irs, irs_ho, irs_dns, "continue"); 386 add_rule(irs, irs_ho, irs_lcl, ""); 387 } 388 #else /* SUNW_HOSTS_FALLBACK */ 389 add_rule(irs, irs_ho, irs_dns, "continue"); 390 add_rule(irs, irs_ho, irs_lcl, ""); 391 #endif /* SUNW_HOSTS_FALLBACK */ 392 add_rule(irs, irs_nw, irs_dns, "continue"); 393 add_rule(irs, irs_nw, irs_lcl, ""); 394 add_rule(irs, irs_ng, irs_lcl, ""); 395 } 396 397 static void 398 init_map_rules(struct gen_p *irs, const char *conf_file) { 399 char line[1024], pattern[40], mapname[20], accname[20], options[100]; 400 FILE *conf; 401 402 #ifdef SUNW_HOSTS_FALLBACK 403 if (__res_no_hosts_fallback()) { 404 default_map_rules(irs); 405 return; 406 } 407 #endif /* SUNW_HOSTS_FALLBACK */ 408 409 if (conf_file == NULL) 410 conf_file = _PATH_IRS_CONF ; 411 412 /* A conf file of "" means compiled in defaults. Irpd wants this */ 413 if (conf_file[0] == '\0' || (conf = fopen(conf_file, "r")) == NULL) { 414 default_map_rules(irs); 415 return; 416 } 417 (void) sprintf(pattern, "%%%lus %%%lus %%%lus\n", 418 (unsigned long)sizeof mapname, 419 (unsigned long)sizeof accname, 420 (unsigned long)sizeof options); 421 while (fgets(line, sizeof line, conf)) { 422 enum irs_map_id map; 423 enum irs_acc_id acc; 424 char *tmp; 425 int n; 426 427 for (tmp = line; 428 isascii((unsigned char)*tmp) && 429 isspace((unsigned char)*tmp); 430 tmp++) 431 (void)NULL; 432 if (*tmp == '#' || *tmp == '\n' || *tmp == '\0') 433 continue; 434 n = sscanf(tmp, pattern, mapname, accname, options); 435 if (n < 2) 436 continue; 437 if (n < 3) 438 options[0] = '\0'; 439 440 n = find_name(mapname, map_names); 441 INSIST(n < irs_nmap); 442 if (n < 0) 443 continue; 444 map = (enum irs_map_id) n; 445 446 n = find_name(accname, acc_names); 447 INSIST(n < irs_nacc); 448 if (n < 0) 449 continue; 450 acc = (enum irs_acc_id) n; 451 452 add_rule(irs, map, acc, options); 453 } 454 fclose(conf); 455 } 456