C++ cfg_get_str函数代码示例

void    db_common_sql_build_query(VSTRING *query, CFG_PARSER *parser)
{
    const char *myname = "db_common_sql_build_query";
    char   *table;
    char   *select_field;
    char   *where_field;
    char   *additional_conditions;

    /*
     * Build "old style" query: "select %s from %s where %s"
     */
    if ((table = cfg_get_str(parser, "table", NULL, 1, 0)) == 0)
	msg_fatal("%s: 'table' parameter not defined", myname);

    if ((select_field = cfg_get_str(parser, "select_field", NULL, 1, 0)) == 0)
	msg_fatal("%s: 'select_field' parameter not defined", myname);

    if ((where_field = cfg_get_str(parser, "where_field", NULL, 1, 0)) == 0)
	msg_fatal("%s: 'where_field' parameter not defined", myname);

    additional_conditions = cfg_get_str(parser, "additional_conditions",
					"", 0, 0);

    vstring_sprintf(query, "SELECT %s FROM %s WHERE %s='%%s' %s",
		    select_field, table, where_field,
		    additional_conditions);

    myfree(table);
    myfree(select_field);
    myfree(where_field);
    myfree(additional_conditions);
}

void
influxdb_put(const char *id, double value)
{
  char url[1024];
  cfg_root(root);

  const char *urlprefix = cfg_get_str(root, CFG("influxdb", "url"), NULL);
  const char *db        = cfg_get_str(root, CFG("influxdb", "db"), NULL);
  const char *username  = cfg_get_str(root, CFG("influxdb", "username"), NULL);
  const char *password  = cfg_get_str(root, CFG("influxdb", "password"), NULL);
  if(urlprefix == NULL || db == NULL || username == NULL || password == NULL)
    return;

  snprintf(url, sizeof(url), "%s/db/%s/series?u=%s&p=%s",
           urlprefix, db, username, password);

  htsmsg_t *doc = htsmsg_create_list();
  htsmsg_t *item = htsmsg_create_map();

  htsmsg_add_str(item, "name", id);

  htsmsg_t *columns = htsmsg_create_list();
  htsmsg_add_str(columns, NULL, "value");
  htsmsg_add_msg(item, "columns", columns);

  htsmsg_t *points = htsmsg_create_list();
  htsmsg_t *point = htsmsg_create_list();
  htsmsg_add_dbl(point, NULL, value);
  htsmsg_add_msg(points, NULL, point);
  htsmsg_add_msg(item, "points", points);

  htsmsg_add_msg(doc, NULL, item);

  char *data = htsmsg_json_serialize_to_str(doc, 0);
  htsmsg_destroy(doc);

  size_t len = strlen(data);

  FILE *f = fmemopen(data, len, "r");

  CURL *curl = curl_easy_init();
  curl_easy_setopt(curl, CURLOPT_URL, url);
  curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
  curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1L);
  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &libsvc_curl_waste_output);
  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
  curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
  curl_easy_setopt(curl, CURLOPT_READDATA, (void *)f);
  curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)len);

  CURLcode result = curl_easy_perform(curl);

  curl_easy_cleanup(curl);

  if(result)
    trace(LOG_ERR, "CURL Failed %s error %d", url, result);
  fclose(f);
  free(data);
}

void load_app_locations()
{
  char buff[256];
  char *val;
  int i;
  
  for (i=0;i<NUM_APPS;i++)
  {
    sprintf(buff, "default_application_location_%s", app_names[i]);
    if (NULL != (val = cfg_get_str("ApplicationLocations",buff)))
    {
      if (val[0] == '/' || !strcmp(val, "not available"))
      {
        app_locations[i] = val;
        if (verbose)
           printf("%s - \'%s\' loaded\n", buff, val);
      }
      else
      {
        printf("Config file Error: %s == \'%s\' not allowed\n", buff, val);
      }
    }
    else
      if (verbose)
        printf("%s - default \'%s\' loaded\n", buff, app_locations[i]);
  }
}

static int
hexchat_pluginpref_get_str_real (hexchat_plugin *pl, const char *var, char *dest, int dest_len)
{
	char *confname, *canon, *cfg, *unescaped_value;
	char buf[512];

	canon = g_strdup (pl->name);
	canonalize_key (canon);
	confname = g_strdup_printf ("%s%caddon_%s.conf", get_xdir(), G_DIR_SEPARATOR, canon);
	g_free (canon);

	if (!g_file_get_contents (confname, &cfg, NULL, NULL))
	{
		g_free (confname);
		return 0;
	}
	g_free (confname);

	if (!cfg_get_str (cfg, var, buf, sizeof(buf)))
	{
		g_free (cfg);
		return 0;
	}

	unescaped_value = g_strcompress (buf);
	g_strlcpy (dest, unescaped_value, dest_len);

	g_free (unescaped_value);
	g_free (cfg);
	return 1;
}

static int
dotdoozer_parse(job_t *j, htsmsg_t *target)
{
  SHA_CTX ctx;
  uint8_t digest[20];

  const char *buildenv = htsmsg_get_str(target, "buildenv");
  if(buildenv == NULL)
    return 0;

  cfg_root(root);
  const char *source = cfg_get_str(root, CFG("buildenvs", buildenv, "source"),
                                   NULL);
  if(source == NULL) {
    snprintf(j->errmsg, sizeof(j->errmsg), "Don't know about buildenv: %s",
             buildenv);
    return DOOZER_PERMANENT_FAIL;
  }

  // We are going to build in a chroot
  j->projectdir_internal = "/project";

  j->buildenv_source = tstrdup(source);

  // Compute SHA1 of source URL, this is the source ID

  SHA1((void *)source, strlen(source), digest);
  bin2hex(j->buildenv_source_id, sizeof(j->buildenv_source_id),
          digest, sizeof(digest));

  // Compute SHA1 of source URL + all build deps, this is the modified ID

  SHA1_Init(&ctx);
  SHA1_Update(&ctx, source, strlen(source));
  htsmsg_t *builddeps = htsmsg_get_list(target, "builddeps");
  if(builddeps != NULL) {

    htsmsg_field_t *f;

    int count = 0;
    HTSMSG_FOREACH(f, builddeps) {
      if(f->hmf_type != HMF_STR) {
        snprintf(j->errmsg, sizeof(j->errmsg),
                 "Not all builddeps are strings");
        return DOOZER_PERMANENT_FAIL;
      }
      count++;
    }

    j->num_builddeps = count;

    const char **bds = talloc_zalloc(count * sizeof(char *));
    count = 0;
    HTSMSG_FOREACH(f, builddeps) {
      bds[count++] = tstrdup(f->hmf_str);
      SHA1_Update(&ctx, f->hmf_str, strlen(f->hmf_str));
    }

int cfg_get_int(FIL * fl, const char * section, const char * label, int def)
{
	char buf[16];

	if (cfg_get_str(fl, section, label, buf))
		return atoi(buf);
	else
		return def;
}

int
cfg_get_int (char *cfg, char *var)
{
	char str[128];

	if (!cfg_get_str (cfg, var, str, sizeof (str)))
		return 0;

	return atoi (str);
}

float
cfg_get_float(char *sec, char *ent)
{
    char *val;

    val = cfg_get_str(sec,ent);
    if (NULL == val)
	return -1;
    return atof(val);
}

static void
create_heaps(void)
{
  cfg_root(root);
  const char *d;

  d = cfg_get_str(root, CFG("projectdir"), NULL);
  if(d == NULL) {
    trace(LOG_ERR, "No 'projectdir' configured, giving up");
    exit(1);
  }
  project_heap_mgr = create_heap(d);

  d = cfg_get_str(root, CFG("buildenvdir"), NULL);
  if(d == NULL) {
    trace(LOG_ERR, "No 'buildenvdir' configured, giving up");
    exit(1);
  }
  buildenv_heap_mgr = create_heap(d);
}

int
cfg_get_color (char *cfg, char *var, int *r, int *g, int *b)
{
	char str[128];

	if (!cfg_get_str (cfg, var, str, sizeof (str)))
		return 0;

	sscanf (str, "%04x %04x %04x", r, g, b);
	return 1;
}

int
CfgQueryStringExamples(int verbose, struct cfg *cfg, char *args[])
{
	unsigned char buf[1024], *row[10];
	FILE *in;
	int ret;

	if ((in = fopen(args[0], "r")) == NULL) {
		PMNO(errno);
		return -1;
	}

	while ((ret = csv_row_fread(in, buf, 1024, row, 10, ',', CSV_QUOTES | CSV_TRIM)) > 0) {
    	int success = atoi(row[0]);

		tcase_printf(verbose, "%s:\n", row[1]);

		cfg_clear(cfg);

		if (cfg_load_cgi_query_string(cfg, row[1], row[1] + tcslen(row[1])) == -1) {
			if (success) {
				ret = -1;
				AMSG("");
				goto out;
			}
		} else if (!success) {
			ret = -1;
			AMSG("Supposed to fail");
			goto out;
		}

		if (verbose) {
			iter_t iter;
			const tchar *name;
			tchar dst[512];

			cfg_iterate(cfg, &iter);
			while ((name = cfg_next(cfg, &iter))) {
				if (cfg_get_str(cfg, dst, 512, NULL, name) == -1) {
					errno = ENOENT;
					PMNO(errno);
					return -1;
				}
				tcase_printf(verbose, "\t%s=%s\n", name, dst);
			}
		}
	}

out:
	fclose(in);

    return ret;
}

static char *
ignore_read_next_entry (char *my_cfg, struct ignore *ignore)
{
	char tbuf[1024];

	/* Casting to char * done below just to satisfy compiler */

	if (my_cfg)
	{
		my_cfg = cfg_get_str (my_cfg, "mask", tbuf, sizeof (tbuf));
		if (!my_cfg)
			return NULL;
		ignore->mask = g_strdup (tbuf);
	}
	if (my_cfg)
	{
		my_cfg = cfg_get_str (my_cfg, "type", tbuf, sizeof (tbuf));
		ignore->type = atoi (tbuf);
	}
	return my_cfg;
}

static void
get_uid_gid(void)
{
  cfg_root(root);

  const char *user  = cfg_get_str(root, CFG("user"),  "nobody");
  const char *group = cfg_get_str(root, CFG("group"), "nogroup");

  const struct passwd *p = getpwnam(user);
  if(p == NULL) {
    trace(LOG_ERR, "Unable to find UID for user %s. Exiting", user);
    exit(1);
  }
  build_uid = p->pw_uid;

  const struct group *g = getgrnam(group);
  if(g == NULL) {
    trace(LOG_ERR, "Unable to find GID for group %s. Exiting", group);
    exit(1);
  }
  build_gid = g->gr_gid;
}

/* load the common things */
void load_common()
{
char *val;
int i;

  if (NULL != (val = cfg_get_str("Studio","Encode_Input_file")))
      sprintf(enc_inputfile, val);
  else 
      sprintf(enc_inputfile, "test.avi");
 
  if (NULL != (val = cfg_get_str("Studio","Encode_Output_file")))
      sprintf(enc_outputfile, val);
  else 
      sprintf(enc_outputfile,"%s/output.mpg", getenv("HOME"));

  if (NULL != (val = cfg_get_str("Studio","Encode_Audio_file")))
      sprintf(enc_audiofile, val);
  else 
      sprintf(enc_audiofile, "/tmp/audio.mp2");

  if (NULL != (val = cfg_get_str("Studio","Encode_Video_file")))
      sprintf(enc_videofile, val);
  else 
      sprintf(enc_videofile, "/tmp/video.m1v");

  if (NULL != (val = cfg_get_str("Studio","Encode_Player_use")))
      sprintf(selected_player, val);
  else 
      sprintf(selected_player, "no player selected");

  if (NULL != (val = cfg_get_str("Studio","Encode_Video_Preview")))
    if ( 0 == strcmp(val,"yes"))
        use_yuvplay_pipe = 1;
    else 
        use_yuvplay_pipe = 0;

  if (-1 != (i = cfg_get_int("Studio","Encoding_four_pel_motion_compensation")))
    fourpelmotion = i;

  if (-1 != (i = cfg_get_int("Studio","Encoding_two_pel_motion_compensation")))
    twopelmotion = i;

  if (NULL != (val = cfg_get_str("Studio","Encode_Bicubic_Scaling")))
    if ( 0 == strcmp(val,"yes"))
        use_yuvplay_pipe = 1;
    else 
        use_yuvplay_pipe = 0;
  
  if (-1 != (i = cfg_get_int("Studio","Encoding_save_on_exit")))
    saveonexit = i;
  
  if (-1 != (i = cfg_get_int("Studio","Encoding_dist_enhanced_settings")))
    enhanced_settings = i;
}

int
hexchat_pluginpref_get_str (hexchat_plugin *pl, const char *var, char *dest)
{
	int fh;
	int l;
	char confname[64];
	char *canon;
	char *cfg;
	struct stat st;

	canon = g_strdup (pl->name);
	canonalize_key (canon);
	sprintf (confname, "addon_%s.conf", canon);
	g_free (canon);

	/* partly borrowed from palette.c */
	fh = hexchat_open_file (confname, O_RDONLY, 0, 0);

	if (fh == -1)
	{
		return 0;
	}

	fstat (fh, &st);
	cfg = malloc (st.st_size + 1);

	if (!cfg)
	{
		close (fh);
		return 0;
	}

	cfg[0] = '\0';
	l = read (fh, cfg, st.st_size);

	if (l >= 0)
	{
		cfg[l] = '\0';
	}

	if (!cfg_get_str (cfg, var, dest, 512)) /* dest_len is the same as buffer size in set */
	{
		free (cfg);
		close (fh);
		return 0;
	}

	free (cfg);
	close (fh);
	return 1;
}