C++ config_destroy函数代码示例

static int __config_read(config_t *config, FILE *stream, const char *filename,
                         const char *str)
{
  yyscan_t scanner;
  struct scan_context scan_ctx;
  struct parse_context parse_ctx;
  YY_BUFFER_STATE buffer = NULL;
  int r;

  /* Reinitialize the config */
  void (*destructor)(void *) = config->destructor;
  unsigned short tab_width = config->tab_width;
  unsigned short flags = config->flags;

  config_destroy(config);
  config_init(config);

  config->destructor = destructor;
  config->tab_width = tab_width;
  config->flags = flags;

  parsectx_init(&parse_ctx);
  parse_ctx.config = config;
  parse_ctx.parent = config->root;
  parse_ctx.setting = config->root;

  __config_locale_override();

  scanctx_init(&scan_ctx, filename);
  scan_ctx.config = config;
  libconfig_yylex_init_extra(&scan_ctx, &scanner);

  if(stream)
    libconfig_yyrestart(stream, scanner);
  else /* read from string */
    buffer = libconfig_yy_scan_string(str, scanner);

  r = libconfig_yyparse(scanner, &parse_ctx, &scan_ctx);

  if(r != 0)
  {
    config->error_file = scanctx_current_filename(&scan_ctx);
    config->error_type = CONFIG_ERR_PARSE;
  }

  libconfig_yylex_destroy(scanner);
  config->filenames = scanctx_cleanup(&scan_ctx, &(config->num_filenames));
  parsectx_cleanup(&parse_ctx);

  __config_locale_restore();

  return(r == 0 ? CONFIG_TRUE : CONFIG_FALSE);
}

int readCfgCond (void) {
	config_t cfg;
	config_init(&cfg);

	/* Read the file. If there is an error, report it and exit. */
	if (!config_read_file(&cfg, config_cond_path)) {
		printf("\n%s:%d - %s", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
		config_destroy(&cfg);
		return -1;
	}

	/*  */
	if (!config_lookup_int(&cfg, "minTemp", &minTemp))  printf("\nNo 'minTemp' setting in configuration file.");
	if (!config_lookup_int(&cfg, "maxTemp", &maxTemp)) printf("\nNo 'maxTemp' setting in configuration file.");
	if (!config_lookup_int(&cfg, "minHum", &minHum)) printf("\nNo 'minHum' setting in configuration file.");
	if (!config_lookup_int(&cfg, "maxHum", &maxHum)) printf("\nNo 'maxHum' setting in configuration file.");
	if (!config_lookup_int(&cfg, "webOR", &webOR)) printf("\nNo 'webOR' setting in configuration file.");

	config_destroy(&cfg);
	return 0;
}

/**
 * Main test function
 */
int main(int argc, char **argv)
{
    int err = FALSE;

    config_init(&cfg);
    config_check(&cfg);

    err |= test_compare();

    config_destroy(&cfg);
    return err;
}

int bot_destroy(struct bot* b)
{
	config_write(b->conf, "config.conf");
	conn_destroy(b->conn);
	config_destroy(b->conf);
	free(b->conn);
	free(b->conf);
	b->conn=NULL;
	b->conf=NULL;
	if(!b->conn && !b->conf) return 0;
	else return -1;
}

static int unload_module(void) {
	struct DFITCUserLogoutField req = { 0 };

	strncat(req.AccountID, userid, sizeof req.AccountID - 1);
	xspeed_l2api_user_logout(l2api, &req);
	/* FIXME: ?! */
	sleep(1);
	xspeed_l2api_destory(l2api);
	xspeed_l2spi_destroy(l2spi);
	config_destroy(cfg);
	return unregister_application(app);
}

void terminarCPUSinPCB() {
	t_datosEnviar* info1 = pedirPaquete("a", CPU_PCP_DISCONNECTION, 2);
	t_datosEnviar* info = pedirPaquete("a", UMV_CAE_CPU, 2);
	common_send(umvSocket, info, NULL );
	common_send(pcpSocket, info1, NULL );
	destruirPaquete(info1);
	destruirPaquete(info);
	close(umvSocket);
	close(pcpSocket);
	config_destroy(configuracion_CPU);
	exit(0);
}

int read_local_config_from_file(const char * local_path)
{
	int rv;

	config_t config;
	config_init(&config);

	rv = config_read_file(&config, local_path);
	if (rv != CONFIG_TRUE)
	{
		config_log_error(&config);
		config_destroy(&config);
		return rv;
	}

	rv = read_local_config(&config);
	
	config_destroy(&config);

	return rv;
}

static int read_config_auth(char config_file[BUFSIZE], struct config_auth* s_auth)
{
    config_t cfg;
    const char* buf;

    config_init(&cfg);

    if (!config_read_file(&cfg, config_file)) {
        pam_http_syslog(LOG_ALERT, "%s:%d - %s\n", config_error_file(&cfg),
            config_error_line(&cfg), config_error_text(&cfg));
        config_destroy(&cfg);
        return 0;
    }

    if (!config_lookup_string(&cfg, "auth_url", &buf)) {
        pam_http_syslog(LOG_ALERT, "No 'auth_url' setting in configuration file.");
        config_destroy(&cfg);
        return 0;
    }
    s_auth->c_auth_url = strndup(buf, BUFSIZE);

    s_auth->c_method = config_get_string(&cfg, "auth_method", DEFAULT_METHOD);
    if (strncmp(s_auth->c_method, HTTP_METHOD_GET, 3) != 0 && strncmp(s_auth->c_method, HTTP_METHOD_POST, 4) != 0) {
        pam_http_syslog(LOG_ALERT, "Wrong 'auth_method' setting in configuration file (%s).", s_auth->c_method);
        config_destroy(&cfg);
        return 0;
    }

    s_auth->c_username_field = config_get_string(&cfg, "auth_username_field", DEFAULT_USERNAME_FIELD);
    s_auth->c_password_field = config_get_string(&cfg, "auth_password_field", DEFAULT_PASSWORD_FIELD);
    if (!config_lookup_int64(&cfg, "auth_timeout", &s_auth->timeout)) {
        s_auth->timeout = DEFAULT_CURL_TIMEOUT;
    }
    if (!config_lookup_int64(&cfg, "auth_success_code", &s_auth->success_code)) {
        s_auth->success_code = DEFAULT_HTTP_SUCCESS_CODE;
    }

    config_destroy(&cfg);
    return 1;
}

void dhcp_edit_read_cfg(void)
{
        config_t cfg, *cf;
        int i, r;
        char token[MAX_LEN];
        const char *file = NULL;
        const char *name = NULL;

        cf = &cfg;
        config_init(cf);
 
        if (!config_read_file(cf, "configuracion.cfg"))
		goto error;

        /* Buscamos redes de hosts para leer desde configuracion.cfg */
        for (i=0;i<MAX_N_REDES;i++) {

        	sprintf(token,"dhcpdconf%i", i);
		r = config_lookup_string(cf, token, &file);
                if (r == 0)
                        break;

        	sprintf(token,"network%i", i);
		r = config_lookup_string(cf, token, &name);
                if (r == 0)
                        goto error;

		strcpy(redes[i].file, file);
		strcpy(redes[i].name, name);
        }

        config_destroy(cf);
        return;
                
error:
        perror("Error al leer la configuracion\n");
        config_destroy(cf);

        exit(1);
}

int main (int argc, char **argv) {
    int error = 0;
    char *config_file = NULL;
    struct config_t cfg;
    int result;
    int i;
    int c;

    while ((c = getopt_long (argc, argv,
                    "h" /* help */
                    "c:", /* config file */
                    long_options, (int *) 0)) != EOF) {
        switch (c) {
            case 'h':
                usage (0);

            case 'c':
                config_file = optarg;
                break;

        }
    }

    config_init(&cfg);
    if (config_file == NULL) {
        config_file = CONFIG_FILENAME;
    }
    if (config_read_file(&cfg, config_file) != CONFIG_TRUE) {
        fprintf(stderr, "config parse error in %s:%d - %s\n",
            config_file,
            config_error_line(&cfg),
            config_error_text(&cfg));
        config_destroy(&cfg);
        exit(EXIT_FAILURE);
    }

    if (error = eosimias_init(&state, &cfg)) {
        fprintf (stderr, "eosimias_init returned: %s", eosimias_error_string(error));
    }

//    if (error = eocene_init(state)) {
//        fprintf (stderr, "eocene_init returned: %s", eosimias_error_string(error));
//    }

    if (error = eonessa_init(state)) {
        fprintf (stderr, "eonessa_init returned: %s", eosimias_error_string(error));
    }

    state->run();

    return(0);
}

void get_conf_string (char *key, char *value) {
  config_t *conf = &(config_t) {};
  config_init (conf);
  config_read_file (conf, "TSECDecoder.conf");
  char *tmp;
  if (config_lookup (conf, key) == NULL)
    return;
  config_lookup_string (conf, key, (const char **)&tmp);
  if (tmp == NULL)
    return;
  memcpy (value, tmp, strlen (tmp));
  config_destroy (conf);
}

void upd8_config_destroy(upd8_config_t *config) {
  if (config == NULL) {
    return;
  }
  for (int i = 0; i > config->num_sources; ++i) {
    upd8_source_destroy(&(config->sources[i]));
  }
  free(config->sources);
  config->sources = NULL;

  config_destroy(config->cfg);
  config->cfg = NULL;
}

int conf_read_file (config_t *config, const char *config_filename)
{
	config_init (config);

	if (!config_read_file (config, config_filename)) {
		ShowError ("%s:%d - %s\n", config_error_file (config),
				   config_error_line (config), config_error_text (config));
		config_destroy (config);
		return 1;
	}

	return 0;
}

static void init(void)
{
  int i;
  double bpm;
  double decay;
  int samp_rate;
  int min_burst;
  int burst_increase;
  int min_gain;
  int gain_increase;
  int detune;

  config_init(&cfg);
  if(!config_read_file(&cfg, CONFIG_FILE))
  {
    fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg),
            config_error_line(&cfg), config_error_text(&cfg));
    config_destroy(&cfg);
    exit(EXIT_FAILURE);
  }

  if(!config_lookup_float(&cfg, "bpm", &bpm))
    config_die("bpm");
  if(!config_lookup_float(&cfg, "subdiv", &subdiv))
    config_die("subdiv");
  if(!config_lookup_int(&cfg, "samp_rate", &samp_rate))
    config_die("samp_rate");
  if(!config_lookup_int(&cfg, "min_burst", &min_burst))
    config_die("min_burst");
  if(!config_lookup_int(&cfg, "burst_increase", &burst_increase))
    config_die("burst_increase");
  if(!config_lookup_float(&cfg, "decay", &decay))
    config_die("decay");
  if(!config_lookup_int(&cfg, "min_gain", &min_gain))
    config_die("min_gain");
  if(!config_lookup_int(&cfg, "gain_increase", &gain_increase))
    config_die("gain_increase");
  if(!config_lookup_int(&cfg, "detune", &detune))
    config_die("detune");

  note_length = (float)samp_rate * 60 * subdiv / bpm;
  system_init();
  agent_count = system_get_agent_count();

  synths = calloc(agent_count, sizeof(Synth *));
  for(i = 0; i < agent_count; i ++) {
    float pan = ((float)i / 20) * ((i % 2) * 2 - 1) + .5;
    synths[i] = synth_create(samp_rate, min_burst + i * burst_increase,
                             decay, pan, min_gain + gain_increase * i, detune);
  }
}

int get_server_config(s_config *c, char *config_path)
{
	config_t cfg;
	config_setting_t *modules_setting, *module_setting;
	unsigned int count, i;
	const char *module_name;

	config_init(&cfg);

	if (!config_read_file(&cfg, config_path)) {
		config_destroy(&cfg);
		return CONFIG_FILE_READ_ERROR;
	}

	if (config_lookup_int(&cfg, "port", &(c->port))
		&& config_lookup_string(&cfg, "host", &(c->host))
		&& config_lookup_string(&cfg, "web_root", &(c->web_root))
		&& config_lookup_string(&cfg, "web_prefix", &(c->web_prefix))
		&& config_lookup_string(&cfg, "api_prefix", &(c->api_prefix))
		&& config_lookup_string(&cfg, "index_file", &(c->index_file))
		&& config_lookup_string(&cfg, "api_modules_path", &(c->api_modules_path))
		&& config_lookup_int(&cfg, "buffer_size", &(c->buffer_size))
		&& config_lookup_int(&cfg, "api_modules_number", &(c->api_modules_number))
	) {
		c->buffer = (char*) calloc((size_t) c->buffer_size, sizeof(char));

		/* Output a list of all movies in the inventory. */
		modules_setting = config_lookup(&cfg, "api_modules");
		if (modules_setting != NULL) {
			count = (unsigned int) config_setting_length(modules_setting);
			if (count != (unsigned int) c->api_modules_number)
				return CONFIG_INCONSISTENT_DATA;
			else if (count == 0)
				return CONFIG_FILE_READ_OK;

			c->api_modules_names = malloc(count * sizeof(char*));
			for (i = 0; i < count; ++i) {
				module_setting = config_setting_get_elem(modules_setting, i);
				module_name = config_setting_get_string(module_setting);

				c->api_modules_names[i] = module_name;
			}

			map_init(&c->api_modules, c->api_modules_number);
		}

		return CONFIG_FILE_READ_OK;
	}
	else
		return CONFIG_MISSING_KEY;
}