Annotation of embedaddon/libpdel/config/app_config.c, revision 1.1
1.1 ! misho 1:
! 2: /*
! 3: * Copyright (c) 2001-2002 Packet Design, LLC.
! 4: * All rights reserved.
! 5: *
! 6: * Subject to the following obligations and disclaimer of warranty,
! 7: * use and redistribution of this software, in source or object code
! 8: * forms, with or without modifications are expressly permitted by
! 9: * Packet Design; provided, however, that:
! 10: *
! 11: * (i) Any and all reproductions of the source or object code
! 12: * must include the copyright notice above and the following
! 13: * disclaimer of warranties; and
! 14: * (ii) No rights are granted, in any manner or form, to use
! 15: * Packet Design trademarks, including the mark "PACKET DESIGN"
! 16: * on advertising, endorsements, or otherwise except as such
! 17: * appears in the above copyright notice or in the software.
! 18: *
! 19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
! 20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
! 21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
! 22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
! 23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
! 24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
! 25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
! 26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
! 27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
! 28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
! 29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
! 30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
! 31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
! 32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
! 33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
! 35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
! 36: * THE POSSIBILITY OF SUCH DAMAGE.
! 37: *
! 38: * Author: Archie Cobbs <archie@freebsd.org>
! 39: */
! 40:
! 41: #include <sys/types.h>
! 42: #include <sys/param.h>
! 43: #include <sys/stat.h>
! 44:
! 45: #include <netinet/in.h>
! 46:
! 47: #include <stdlib.h>
! 48: #include <stdio.h>
! 49: #include <signal.h>
! 50: #include <assert.h>
! 51: #include <string.h>
! 52: #include <errno.h>
! 53: #include <syslog.h>
! 54: #include <limits.h>
! 55: #include <unistd.h>
! 56:
! 57: #include <pthread.h>
! 58:
! 59: #include "structs/structs.h"
! 60: #include "structs/type/array.h"
! 61: #include "structs/xml.h"
! 62: #include "sys/alog.h"
! 63: #include "util/pevent.h"
! 64: #include "util/typed_mem.h"
! 65: #include "config/app_config.h"
! 66:
! 67: /************************************************************************
! 68: DEFINITIONS
! 69: ************************************************************************/
! 70:
! 71: #define MEM_TYPE "app_config"
! 72:
! 73: #define ATTR_VERSION "version"
! 74:
! 75: /* Info passed to restart thread */
! 76: struct app_restart {
! 77: u_int delay;
! 78: u_char have_mutex;
! 79: u_char writeback;
! 80: void *config;
! 81: };
! 82:
! 83: #define SS_NEED_STOP 0x01
! 84: #define SS_NEED_START 0x02
! 85: #define SS_RUNNING 0x04
! 86:
! 87: /* Configuration state flags */
! 88: #define CONFIG_PENDING 0x0001 /* c->pending is valid */
! 89: #define CONFIG_APPLYING 0x0002 /* c->applying is valid */
! 90: #define CONFIG_RESTARTING 0x0004 /* a thread is doing restarts */
! 91:
! 92: /* Application configuration state */
! 93: struct app_config_ctx {
! 94: struct pevent_ctx *ctx; /* event context */
! 95: struct app_config info; /* application info */
! 96: void *cookie; /* application cookie */
! 97: int flags; /* state flags */
! 98: const struct structs_type *type; /* config structs type */
! 99: int num_ss; /* length of info.slist */
! 100: void *current; /* current configuration */
! 101: void *pending; /* pending new config */
! 102: void *applying; /* config being applied */
! 103: u_char *ss_flags; /* subsystem state flags */
! 104: char *xml_path; /* xml file pathname */
! 105: int xml_writeback; /* allow xml writeback */
! 106: void *xml_cache; /* cached xml file contents */
! 107: pthread_mutex_t mutex; /* mutex for config state */
! 108: struct pevent *timer; /* pending restart timer */
! 109: };
! 110:
! 111: /************************************************************************
! 112: FUNCTIONS
! 113: ************************************************************************/
! 114:
! 115: /*
! 116: * Internal functions
! 117: */
! 118: static const void *app_config_get_last(struct app_config_ctx *c);
! 119: static int app_config_equal(struct app_config_ctx *c,
! 120: const void *config1, const void *config2);
! 121: static void app_config_restart(struct app_config_ctx *c);
! 122: static void app_config_store(struct app_config_ctx *c);
! 123:
! 124: static pevent_handler_t app_config_apply;
! 125: static structs_xmllog_t app_config_xml_logger;
! 126:
! 127: /*
! 128: * Initialize the application configuration framework.
! 129: */
! 130: struct app_config_ctx *
! 131: app_config_init(struct pevent_ctx *ctx,
! 132: const struct app_config *info, void *cookie)
! 133: {
! 134: struct app_config_ctx *c;
! 135: int i, j;
! 136:
! 137: /* Sanity check */
! 138: for (i = 0; i <= info->version; i++) {
! 139: if (info->types[i] == NULL) {
! 140: errno = EINVAL;
! 141: return (NULL);
! 142: }
! 143: }
! 144:
! 145: /* Check each subsystem has a unique name */
! 146: for (i = 0; info->slist[i] != NULL; i++) {
! 147: for (j = i + 1; info->slist[j] != NULL; j++) {
! 148: if (strcmp(info->slist[i]->name,
! 149: info->slist[j]->name) == 0) {
! 150: errno = EINVAL;
! 151: return (NULL);
! 152: }
! 153: }
! 154: }
! 155:
! 156: /* Create new state object */
! 157: if ((c = MALLOC(MEM_TYPE, sizeof(*c))) == NULL) {
! 158: alogf(LOG_ERR, "%s: %m", "malloc");
! 159: return (NULL);
! 160: }
! 161: memset(c, 0, sizeof(*c));
! 162: c->ctx = ctx;
! 163: c->cookie = cookie;
! 164:
! 165: /* Copy application config */
! 166: c->info = *info;
! 167: c->type = c->info.types[c->info.version];
! 168: c->info.slist = NULL;
! 169:
! 170: /* Copy subsystem list */
! 171: for (c->num_ss = 0; info->slist[c->num_ss] != NULL; c->num_ss++);
! 172: if ((c->info.slist = MALLOC(MEM_TYPE,
! 173: c->num_ss * sizeof(*c->info.slist))) == NULL) {
! 174: alogf(LOG_ERR, "%s: %m", "malloc");
! 175: goto fail;
! 176: }
! 177: memcpy(c->info.slist,
! 178: info->slist, c->num_ss * sizeof(*c->info.slist));
! 179:
! 180: /* Allocate subsystem flags list */
! 181: if ((c->ss_flags = MALLOC(MEM_TYPE,
! 182: c->num_ss * sizeof(*c->ss_flags))) == NULL) {
! 183: alogf(LOG_ERR, "%s: %m", "malloc");
! 184: goto fail;
! 185: }
! 186: memset(c->ss_flags, 0, c->num_ss * sizeof(*c->ss_flags));
! 187:
! 188: /* Initialize mutex */
! 189: if ((errno = pthread_mutex_init(&c->mutex, NULL)) != 0) {
! 190: alogf(LOG_ERR, "%s: %m", "pthread_mutex_init");
! 191: goto fail;
! 192: }
! 193:
! 194: /* Done */
! 195: return (c);
! 196:
! 197: fail:
! 198: /* Clean up after failure */
! 199: FREE(MEM_TYPE, c->ss_flags);
! 200: FREE(MEM_TYPE, c->info.slist);
! 201: FREE(MEM_TYPE, c);
! 202: return (NULL);
! 203: }
! 204:
! 205: /*
! 206: * Shutdown and free application configuration stuff.
! 207: */
! 208: int
! 209: app_config_uninit(struct app_config_ctx **cp)
! 210: {
! 211: struct app_config_ctx *const c = *cp;
! 212: int r;
! 213:
! 214: /* Sanity check */
! 215: if (c == NULL)
! 216: return (0);
! 217:
! 218: /* Acquire mutex */
! 219: r = pthread_mutex_lock(&c->mutex);
! 220: assert(r == 0);
! 221:
! 222: /* Check that nothing is happening and everything is shut down */
! 223: if (c->current != NULL
! 224: || (c->flags & (CONFIG_PENDING|CONFIG_RESTARTING)) != 0) {
! 225: r = pthread_mutex_unlock(&c->mutex);
! 226: assert(r == 0);
! 227: errno = EBUSY;
! 228: return (-1);
! 229: }
! 230:
! 231: /* Nuke caller's reference, release mutex */
! 232: *cp = NULL;
! 233: r = pthread_mutex_unlock(&c->mutex);
! 234: assert(r == 0);
! 235:
! 236: /* Destroy config state */
! 237: pevent_unregister(&c->timer); /* not really necessary */
! 238: app_config_free(c, &c->xml_cache);
! 239: FREE(MEM_TYPE, c->xml_path);
! 240: pthread_mutex_destroy(&c->mutex);
! 241: FREE(MEM_TYPE, c->ss_flags);
! 242: FREE(MEM_TYPE, c->info.slist);
! 243: FREE(MEM_TYPE, c);
! 244:
! 245: /* Done */
! 246: return (0);
! 247: }
! 248:
! 249: /*
! 250: * Get the application cookie.
! 251: */
! 252: void *
! 253: app_config_get_cookie(struct app_config_ctx *c)
! 254: {
! 255: return (c->cookie);
! 256: }
! 257:
! 258: /*
! 259: * Get the configuration object type.
! 260: */
! 261: const struct structs_type *
! 262: app_config_get_type(struct app_config_ctx *c)
! 263: {
! 264: return (c->type);
! 265: }
! 266:
! 267: /*
! 268: * Load in application configuration from an XML file and apply it.
! 269: * The named file becomes the implicit file for app_config_reload().
! 270: *
! 271: * If the file does not exist, one is automatically created after
! 272: * calling the applications "getnew" routine.
! 273: */
! 274: int
! 275: app_config_load(struct app_config_ctx *c, const char *path, int writeback)
! 276: {
! 277: void *old_config = NULL;
! 278: char *attrs = NULL;
! 279: u_int old_version;
! 280: FILE *fp = NULL;
! 281: struct stat sb;
! 282: int old_cstate;
! 283: char ebuf[128];
! 284: void *config;
! 285: int rtn = -1;
! 286: char *s;
! 287: int r;
! 288:
! 289: /* Block thread from being canceled */
! 290: pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_cstate);
! 291:
! 292: /* Create a new configuration with the default values */
! 293: if ((config = app_config_new(c)) == NULL)
! 294: goto fail;
! 295:
! 296: /* If configuration file is there but empty, remove it */
! 297: if (stat(path, &sb) == 0 && sb.st_size == 0) {
! 298: char resolved_path[MAXPATHLEN];
! 299:
! 300: if (realpath(path, resolved_path) == NULL)
! 301: goto fail;
! 302: (void)unlink(resolved_path);
! 303: }
! 304:
! 305: /* If configuration file doesn't exist, create one */
! 306: if (stat(path, &sb) == -1) {
! 307:
! 308: /* Bail on any wierd errors */
! 309: if (errno != ENOENT)
! 310: goto fail;
! 311:
! 312: /* Create new configuration */
! 313: if (c->info.getnew != NULL
! 314: && (*c->info.getnew)(c, config) == -1)
! 315: goto fail;
! 316:
! 317: /* Normalize it */
! 318: if (c->info.normalize != NULL)
! 319: (*c->info.normalize)(c, config);
! 320: goto ready;
! 321: }
! 322:
! 323: /* Open XML config file */
! 324: if ((fp = fopen(path, "r")) == NULL)
! 325: goto fail;
! 326:
! 327: /* Read top level XML attributes only */
! 328: r = structs_xml_input(NULL, APP_CONFIG_XML_TAG, &attrs,
! 329: TYPED_MEM_TEMP, fp, NULL, STRUCTS_XML_SCAN, app_config_xml_logger);
! 330: if (r == -1) {
! 331: alog(LOG_ERR, "error reading configuration from \"%s\"", path);
! 332: goto fail;
! 333: }
! 334:
! 335: /* Find the version number attribute and parse version */
! 336: for (s = attrs, old_version = 0; *s != '\0'; s += strlen(s) + 1) {
! 337: u_long vers;
! 338: char *eptr;
! 339: int match;
! 340:
! 341: match = (strcmp(s, ATTR_VERSION) == 0);
! 342: s += strlen(s) + 1;
! 343: if (!match)
! 344: continue;
! 345: vers = strtoul(s, &eptr, 10);
! 346: if (*s == '\0' || *eptr != '\0') {
! 347: alog(LOG_ERR, "\"%s\" contains invalid version \"%s\"",
! 348: path, s);
! 349: FREE(TYPED_MEM_TEMP, attrs);
! 350: errno = EPROGMISMATCH;
! 351: goto fail;
! 352: }
! 353: old_version = vers;
! 354: break;
! 355: }
! 356: FREE(TYPED_MEM_TEMP, attrs);
! 357:
! 358: /* Sanity check version and rewind file */
! 359: if (old_version > c->info.version) {
! 360: alog(LOG_ERR, "\"%s\" contains newer version %d > %u",
! 361: path, old_version, c->info.version);
! 362: errno = EPROGMISMATCH;
! 363: goto fail;
! 364: }
! 365: if (fseek(fp, 0, SEEK_SET) == -1)
! 366: goto fail;
! 367:
! 368: /* Upgrade older format if necessary */
! 369: if (old_version < c->info.version) {
! 370: const struct structs_type *const old_type
! 371: = c->info.types[old_version];
! 372:
! 373: /* Do we have an upgrade method? */
! 374: if (c->info.upgrade == NULL) {
! 375: alog(LOG_ERR,
! 376: "\"%s\" contains obsolete version %d < %u",
! 377: path, old_version, c->info.version);
! 378: errno = EPROGMISMATCH;
! 379: goto fail;
! 380: }
! 381:
! 382: /* Log it */
! 383: alog(LOG_INFO, "\"%s\" contains old version %d < %u, upgrading",
! 384: path, old_version, c->info.version);
! 385:
! 386: /* Create an (uninitialized) old config structure */
! 387: if ((old_config = MALLOC(MEM_TYPE, old_type->size)) == NULL)
! 388: goto fail;
! 389:
! 390: /* Read in the old version XML (and initialize) */
! 391: r = structs_xml_input(old_type, APP_CONFIG_XML_TAG, NULL,
! 392: TYPED_MEM_TEMP, fp, old_config,
! 393: STRUCTS_XML_UNINIT | STRUCTS_XML_LOOSE,
! 394: app_config_xml_logger);
! 395: fclose(fp);
! 396: fp = NULL;
! 397: if (r == -1) {
! 398: alog(LOG_ERR,
! 399: "error reading configuration from \"%s\"", path);
! 400: FREE(MEM_TYPE, old_config);
! 401: goto fail;
! 402: }
! 403:
! 404: /* Upgrade from the old version to the new version */
! 405: r = (*c->info.upgrade)(c, old_config, old_version, config);
! 406: structs_free(old_type, NULL, old_config);
! 407: FREE(MEM_TYPE, old_config);
! 408: if (r == -1) {
! 409: alog(LOG_ERR,
! 410: "error upgrading configuration \"%s\" version"
! 411: " from %d -> %u", path,
! 412: old_version, c->info.version);
! 413: goto fail;
! 414: }
! 415: } else {
! 416:
! 417: /* Version is correct, read in configuration */
! 418: r = structs_xml_input(c->type, APP_CONFIG_XML_TAG, NULL,
! 419: TYPED_MEM_TEMP, fp, config, STRUCTS_XML_LOOSE,
! 420: app_config_xml_logger);
! 421: fclose(fp);
! 422: fp = NULL;
! 423: if (r == -1) {
! 424: alog(LOG_ERR,
! 425: "error reading configuration from \"%s\"", path);
! 426: goto fail;
! 427: }
! 428: }
! 429:
! 430: ready:
! 431: /* Remember path and writeback settings */
! 432: r = pthread_mutex_lock(&c->mutex);
! 433: assert(r == 0);
! 434: FREE(MEM_TYPE, c->xml_path);
! 435: if ((c->xml_path = STRDUP(MEM_TYPE, path)) == NULL)
! 436: alogf(LOG_ERR, "%s: %m", "strdup");
! 437: app_config_free(c, &c->xml_cache);
! 438: c->xml_writeback = writeback;
! 439: r = pthread_mutex_unlock(&c->mutex);
! 440: assert(r == 0);
! 441:
! 442: /* Apply configuration read from file */
! 443: if ((rtn = app_config_set(c, config, 0, ebuf, sizeof(ebuf))) == -1) {
! 444: alog(LOG_ERR, "error applying configuration from \"%s\": %s",
! 445: path, ebuf);
! 446: }
! 447:
! 448: fail:
! 449: /* Done */
! 450: app_config_free(c, &config);
! 451: if (fp != NULL)
! 452: fclose(fp);
! 453: pthread_setcancelstate(old_cstate, NULL);
! 454: return (rtn);
! 455: }
! 456:
! 457: /*
! 458: * Re-read the XML file passed to app_config_load() and reconfigure
! 459: * as appropriate.
! 460: */
! 461: int
! 462: app_config_reload(struct app_config_ctx *c)
! 463: {
! 464: int writeback;
! 465: char *path;
! 466: int rtn;
! 467: int r;
! 468:
! 469: /* Get the relevant info */
! 470: r = pthread_mutex_lock(&c->mutex);
! 471: assert(r == 0);
! 472: if (c->xml_path == NULL) {
! 473: r = pthread_mutex_unlock(&c->mutex);
! 474: assert(r == 0);
! 475: errno = ENXIO;
! 476: return (-1);
! 477: }
! 478: if ((path = STRDUP(TYPED_MEM_TEMP, c->xml_path)) == NULL) {
! 479: r = pthread_mutex_unlock(&c->mutex);
! 480: assert(r == 0);
! 481: return (-1);
! 482: }
! 483: writeback = c->xml_writeback;
! 484: r = pthread_mutex_unlock(&c->mutex);
! 485: assert(r == 0);
! 486:
! 487: /* Apply it */
! 488: rtn = app_config_load(c, path, writeback);
! 489:
! 490: /* Done */
! 491: FREE(TYPED_MEM_TEMP, path);
! 492: return (rtn);
! 493: }
! 494:
! 495: /*
! 496: * Function to create a configuration structure. This structure will
! 497: * have the application's default values.
! 498: */
! 499: void *
! 500: app_config_new(struct app_config_ctx *c)
! 501: {
! 502: static int did_check;
! 503: void *config;
! 504:
! 505: /* Create initialized structure */
! 506: if ((config = MALLOC(MEM_TYPE, c->type->size)) == NULL)
! 507: return (NULL);
! 508: if (structs_init(c->type, NULL, config) == -1) {
! 509: FREE(MEM_TYPE, config);
! 510: return (NULL);
! 511: }
! 512:
! 513: /* Apply application defaults */
! 514: if (c->info.init != NULL && (*c->info.init)(c, config) == -1) {
! 515: structs_free(c->type, NULL, config);
! 516: FREE(MEM_TYPE, config);
! 517: return (NULL);
! 518: }
! 519:
! 520: /* Sanity check that default configuration is really valid */
! 521: if (!did_check) {
! 522: char buf[512];
! 523:
! 524: snprintf(buf, sizeof(buf), "generic problem");
! 525: if (c->info.checker != NULL
! 526: && !(*c->info.checker)(c, config, buf, sizeof(buf))) {
! 527: alog(LOG_CRIT,
! 528: "default configuration is invalid: %s", buf);
! 529: }
! 530: did_check = 1;
! 531: }
! 532: return (config);
! 533: }
! 534:
! 535: /*
! 536: * Get the application's most recently applied configuration.
! 537: *
! 538: * This assumes the mutex is held.
! 539: */
! 540: static const void *
! 541: app_config_get_last(struct app_config_ctx *c)
! 542: {
! 543: return (((c->flags & CONFIG_PENDING) != 0) ? c->pending
! 544: : ((c->flags & CONFIG_APPLYING) != 0) ? c->applying
! 545: : c->current);
! 546: }
! 547:
! 548: /*
! 549: * Compare two configurations, either of which may be NULL.
! 550: */
! 551: static int
! 552: app_config_equal(struct app_config_ctx *c,
! 553: const void *config1, const void *config2)
! 554: {
! 555: if (config1 == NULL && config2 == NULL)
! 556: return (1);
! 557: if (config1 == NULL || config2 == NULL)
! 558: return (0);
! 559: return (structs_equal(c->type, NULL, config1, config2));
! 560: }
! 561:
! 562: /*
! 563: * Get a copy of the application's current or pending configuration.
! 564: */
! 565: void *
! 566: app_config_get(struct app_config_ctx *c, int pending)
! 567: {
! 568: void *copy;
! 569: int r;
! 570:
! 571: /* Get copy of config */
! 572: r = pthread_mutex_lock(&c->mutex);
! 573: assert(r == 0);
! 574: copy = app_config_copy(c, pending ?
! 575: app_config_get_last(c) : c->current);
! 576: r = pthread_mutex_unlock(&c->mutex);
! 577: assert(r == 0);
! 578:
! 579: /* Done */
! 580: return (copy);
! 581: }
! 582:
! 583: /*
! 584: * Get a copy of a configuration.
! 585: */
! 586: void *
! 587: app_config_copy(struct app_config_ctx *c, const void *config)
! 588: {
! 589: void *copy;
! 590:
! 591: if (config == NULL)
! 592: return (NULL);
! 593: if ((copy = MALLOC(MEM_TYPE, c->type->size)) == NULL) {
! 594: alogf(LOG_ERR, "%s: %m", "malloc");
! 595: return (NULL);
! 596: }
! 597: if (structs_get(c->type, NULL, config, copy) == -1) {
! 598: alogf(LOG_ERR, "%s: %m", "structs_get");
! 599: FREE(MEM_TYPE, copy);
! 600: return (NULL);
! 601: }
! 602: return (copy);
! 603: }
! 604:
! 605: /*
! 606: * Free a configuration.
! 607: */
! 608: void
! 609: app_config_free(struct app_config_ctx *c, void **configp)
! 610: {
! 611: void *const config = *configp;
! 612:
! 613: if (config == NULL)
! 614: return;
! 615: *configp = NULL;
! 616: structs_free(c->type, NULL, config);
! 617: FREE(MEM_TYPE, config);
! 618: }
! 619:
! 620: /*
! 621: * Change the application's current configuration.
! 622: */
! 623: int
! 624: app_config_set(struct app_config_ctx *c,
! 625: const void *config0, u_long delay, char *ebuf, int emax)
! 626: {
! 627: struct pevent_info info;
! 628: char buf[512];
! 629: void *config;
! 630: int rtn = 0;
! 631: int r;
! 632:
! 633: /* Allow NULL error buffer to be passed; initialize buffer */
! 634: if (ebuf == NULL) {
! 635: ebuf = buf;
! 636: emax = sizeof(buf);
! 637: }
! 638: snprintf(ebuf, emax, "unknown problem");
! 639:
! 640: /* Copy config */
! 641: if (config0 == NULL)
! 642: config = NULL;
! 643: else if ((config = app_config_copy(c, config0)) == NULL)
! 644: return (-1);
! 645:
! 646: /* Normalize it */
! 647: if (config != NULL && c->info.normalize != NULL)
! 648: (*c->info.normalize)(c, config);
! 649:
! 650: /* Validate the new configuration */
! 651: if (config != NULL
! 652: && c->info.checker != NULL
! 653: && !(*c->info.checker)(c, config, ebuf, emax)) {
! 654: app_config_free(c, &config);
! 655: errno = EINVAL;
! 656: return (-1);
! 657: }
! 658:
! 659: /* Acquire mutex */
! 660: r = pthread_mutex_lock(&c->mutex);
! 661: assert(r == 0);
! 662:
! 663: /* Ignore new configs while a shutdown is pending */
! 664: if ((c->timer != NULL && c->pending == NULL)
! 665: || ((c->flags & CONFIG_RESTARTING) != 0 && c->applying == NULL)) {
! 666: app_config_free(c, &config);
! 667: goto done;
! 668: }
! 669:
! 670: /* See if new config is really new */
! 671: if (app_config_equal(c, config, app_config_get_last(c))) {
! 672: app_config_free(c, &config); /* same as what we got */
! 673: goto done;
! 674: }
! 675:
! 676: /* Update pending configuration */
! 677: app_config_free(c, &c->pending);
! 678: c->pending = config;
! 679: c->flags |= CONFIG_PENDING;
! 680:
! 681: /* If a previous restart thread is still running, we're done */
! 682: if ((c->flags & CONFIG_RESTARTING) != 0)
! 683: goto done;
! 684:
! 685: /* If the restart timer is not running, need to start it */
! 686: if (c->timer == NULL)
! 687: goto start_timer;
! 688:
! 689: /* Get time remaining on the restart timer */
! 690: if (pevent_get_info(c->timer, &info) == -1) {
! 691: alogf(LOG_ERR, "%s: %m", "pevent_get_info");
! 692: goto start_timer;
! 693: }
! 694:
! 695: /* See if we need a shorter delay */
! 696: if (delay > INT_MAX || delay >= info.u.millis)
! 697: goto done; /* existing timeout is sufficient */
! 698:
! 699: start_timer:
! 700: /* Cancel previous timer */
! 701: pevent_unregister(&c->timer);
! 702:
! 703: /* Start restart timer */
! 704: if (pevent_register(c->ctx, &c->timer, PEVENT_OWN_THREAD,
! 705: &c->mutex, app_config_apply, c, PEVENT_TIME, delay) == -1) {
! 706: alogf(LOG_ERR, "%s: %m", "pevent_register");
! 707: rtn = -1;
! 708: goto done;
! 709: }
! 710:
! 711: done:
! 712: /* Done */
! 713: r = pthread_mutex_unlock(&c->mutex);
! 714: assert(r == 0);
! 715: return (rtn);
! 716: }
! 717:
! 718: /*
! 719: * Write the current configuration back out to XML config file.
! 720: *
! 721: * This assumes c->current != NULL and the mutex is locked.
! 722: */
! 723: static void
! 724: app_config_store(struct app_config_ctx *c)
! 725: {
! 726: char attrs[sizeof(ATTR_VERSION) + 32];
! 727: char *tpath = NULL;
! 728: FILE *fp = NULL;
! 729: int old_cstate;
! 730:
! 731: /* Get configuration and XML pathname */
! 732: assert(c->xml_path != NULL);
! 733:
! 734: /* Block thread from being canceled */
! 735: pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_cstate);
! 736:
! 737: /* Check if configuration is different from cached file contents */
! 738: if (c->xml_cache != NULL
! 739: && structs_equal(c->type, NULL, c->current, c->xml_cache))
! 740: goto done;
! 741:
! 742: /* Set version attribute */
! 743: snprintf(attrs, sizeof(attrs), "%s%c%u%c",
! 744: ATTR_VERSION, '\0', c->info.version, '\0');
! 745:
! 746: /* Write out temporary new file */
! 747: ASPRINTF(TYPED_MEM_TEMP, &tpath, "%s.new", c->xml_path);
! 748: if (tpath == NULL) {
! 749: alogf(LOG_ERR, "%s: %m", "asprintf");
! 750: goto done;
! 751: }
! 752: if ((fp = fopen(tpath, "w")) == NULL) {
! 753: alogf(LOG_ERR, "%s: %m", tpath);
! 754: goto done;
! 755: }
! 756: if (structs_xml_output(c->type, APP_CONFIG_XML_TAG,
! 757: attrs, c->current, fp, NULL, STRUCTS_XML_FULL) == -1) {
! 758: alogf(LOG_ERR, "%s: %m", "structs_xml_output");
! 759: (void)unlink(tpath);
! 760: goto done;
! 761: }
! 762: fflush(fp);
! 763: fsync(fileno(fp));
! 764: fclose(fp);
! 765: fp = NULL;
! 766:
! 767: /* Atomically overwrite exsting file with new file using rename(2) */
! 768: if (rename(tpath, c->xml_path) == -1) {
! 769: alogf(LOG_ERR, "%s(%s, %s): %m", "rename", tpath, c->xml_path);
! 770: (void)unlink(tpath);
! 771: goto done;
! 772: }
! 773:
! 774: /* Cache file contents */
! 775: app_config_free(c, &c->xml_cache);
! 776: if ((c->xml_cache = app_config_copy(c, c->current)) == NULL)
! 777: alogf(LOG_ERR, "%s: %m", "app_config_copy");
! 778:
! 779: done:
! 780: /* Clean up */
! 781: if (fp != NULL)
! 782: fclose(fp);
! 783: if (tpath != NULL)
! 784: FREE(TYPED_MEM_TEMP, tpath);
! 785: pthread_setcancelstate(old_cstate, NULL);
! 786: }
! 787:
! 788: /*
! 789: * Entry point for restarter thread.
! 790: *
! 791: * The mutex will be acquired when we enter and released when we return.
! 792: */
! 793: static void
! 794: app_config_apply(void *arg)
! 795: {
! 796: struct app_config_ctx *const c = arg;
! 797:
! 798: /* Sanity checks */
! 799: assert((c->flags & CONFIG_APPLYING) == 0);
! 800: assert((c->flags & CONFIG_RESTARTING) == 0);
! 801: assert(c->applying == NULL);
! 802:
! 803: /* Set flag indicating this thread is applying new configs */
! 804: c->flags |= CONFIG_RESTARTING;
! 805:
! 806: /* Keep applying configurations until there are no more new ones */
! 807: while ((c->flags & CONFIG_PENDING) != 0) {
! 808: int r;
! 809:
! 810: /* Make sure latest new configuration is different */
! 811: if (app_config_equal(c, c->pending, c->current)) {
! 812: app_config_free(c, &c->pending);
! 813: c->flags &= ~CONFIG_PENDING;
! 814: goto done;
! 815: }
! 816:
! 817: /* Grab pending config and apply it */
! 818: c->applying = c->pending;
! 819: c->pending = NULL;
! 820: c->flags &= ~CONFIG_PENDING;
! 821: c->flags |= CONFIG_APPLYING;
! 822:
! 823: /* Restart subsystems */
! 824: r = pthread_mutex_unlock(&c->mutex);
! 825: assert(r == 0);
! 826: app_config_restart(c);
! 827: r = pthread_mutex_lock(&c->mutex);
! 828: assert(r == 0);
! 829: }
! 830:
! 831: /* Save new configuration to disk */
! 832: if (c->xml_writeback && c->current != NULL)
! 833: app_config_store(c);
! 834:
! 835: done:
! 836: /* Done */
! 837: c->flags &= ~CONFIG_RESTARTING;
! 838: }
! 839:
! 840: /*
! 841: * Restart subsystems to effect the new configuration 'config'.
! 842: *
! 843: * This assumes the mutex is NOT locked.
! 844: */
! 845: static void
! 846: app_config_restart(struct app_config_ctx *c)
! 847: {
! 848: int i;
! 849: int r;
! 850:
! 851: /* Initialize actions */
! 852: for (i = 0; i < c->num_ss; i++)
! 853: c->ss_flags[i] &= ~(SS_NEED_STOP|SS_NEED_START);
! 854:
! 855: /* Determine what needs to be shutdown and started up */
! 856: for (i = 0; i < c->num_ss; i++) {
! 857: const struct app_subsystem *const ss = c->info.slist[i];
! 858:
! 859: /* Do simple analysis */
! 860: if (c->current != NULL
! 861: && (c->ss_flags[i] & SS_RUNNING) != 0)
! 862: c->ss_flags[i] |= SS_NEED_STOP;
! 863: if (c->applying != NULL
! 864: && (ss->willrun == NULL
! 865: || (*ss->willrun)(c, ss, c->applying) != 0))
! 866: c->ss_flags[i] |= SS_NEED_START;
! 867:
! 868: /* Optimize away unnecessary restarts */
! 869: if ((c->ss_flags[i] & (SS_NEED_STOP|SS_NEED_START))
! 870: == (SS_NEED_STOP|SS_NEED_START)) {
! 871:
! 872: /* If either is NULL, the other isn't, so must do it */
! 873: if (c->current == NULL || c->applying == NULL)
! 874: goto no_optimize;
! 875:
! 876: /* Check dependency list */
! 877: if (ss->deplist != NULL) {
! 878: int j;
! 879:
! 880: for (j = 0; ss->deplist[j] != NULL; j++) {
! 881: if ((r = structs_equal(c->type,
! 882: ss->deplist[j], c->current,
! 883: c->applying)) != 1) {
! 884: if (r != -1)
! 885: goto no_optimize;
! 886: alogf(LOG_ERR, "%s(%s): %m",
! 887: "structs_equal",
! 888: ss->deplist[j]);
! 889: }
! 890: }
! 891: }
! 892:
! 893: /* Check using subsystem's method */
! 894: if (ss->changed != NULL
! 895: && (*ss->changed)(c, ss, c->current, c->applying))
! 896: goto no_optimize;
! 897:
! 898: /* Optimize away restart because it's not needed */
! 899: c->ss_flags[i] &= ~(SS_NEED_STOP|SS_NEED_START);
! 900: no_optimize:;
! 901: }
! 902: }
! 903:
! 904: /* Shut stuff down */
! 905: for (i = c->num_ss - 1; i >= 0; i--) {
! 906: const struct app_subsystem *const ss = c->info.slist[i];
! 907:
! 908: if ((c->ss_flags[i] & SS_NEED_STOP) != 0) {
! 909: alog(LOG_DEBUG, "stopping subsystem \"%s\"", ss->name);
! 910: if (ss->stop != NULL)
! 911: (*ss->stop)(c, ss, c->current);
! 912: c->ss_flags[i] &= ~SS_RUNNING;
! 913: }
! 914: }
! 915:
! 916: /* Update current configuration */
! 917: r = pthread_mutex_lock(&c->mutex);
! 918: assert(r == 0);
! 919: assert((c->flags & CONFIG_APPLYING) != 0);
! 920: assert((c->flags & CONFIG_RESTARTING) != 0);
! 921: app_config_free(c, &c->current);
! 922: c->current = c->applying;
! 923: c->applying = NULL;
! 924: c->flags &= ~CONFIG_APPLYING;
! 925: r = pthread_mutex_unlock(&c->mutex);
! 926: assert(r == 0);
! 927:
! 928: /* If new config is NULL, we've just successfully shut down */
! 929: if (c->current == NULL)
! 930: return;
! 931:
! 932: /* Start stuff up */
! 933: for (i = 0; i < c->num_ss; i++) {
! 934: const struct app_subsystem *const ss = c->info.slist[i];
! 935:
! 936: if ((c->ss_flags[i] & SS_NEED_START) != 0) {
! 937: alog(LOG_DEBUG, "starting subsystem \"%s\"", ss->name);
! 938: if (ss->start != NULL
! 939: && (*ss->start)(c, ss, c->current) == -1) {
! 940: alog(LOG_ERR, "subsystem \"%s\" startup failed",
! 941: ss->name);
! 942: continue;
! 943: }
! 944: c->ss_flags[i] |= SS_RUNNING;
! 945: }
! 946: }
! 947: }
! 948:
! 949: /*
! 950: * Logger for XML parsing
! 951: */
! 952: static void
! 953: app_config_xml_logger(int sev, const char *fmt, ...)
! 954: {
! 955: char buf[512];
! 956: va_list args;
! 957:
! 958: snprintf(buf, sizeof(buf), "XML error: ");
! 959: va_start(args, fmt);
! 960: vsnprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), fmt, args);
! 961: va_end(args);
! 962: alog(sev, "%s", buf);
! 963: }
! 964:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to app_config.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / config