Beispiel #1
0
void config_cred(char *header, char *base, struct config_cred *cred)
{
	char *s;
	char *name;

	asprintf(&name, "%s-user", base);
	if ((s = config_string(header, name)) != NULL) {
		struct passwd *pw;
		if (!strcmp(s, "*"))
			cred->uid = -1U;
		else if ((pw = getpwnam(s)) == NULL)
			Eprintf("Unknown user `%s' in %s:%s config entry\n",
				s, header, name);
		else
		        cred->uid = pw->pw_uid;
	}
	free(name);
	asprintf(&name, "%s-group", base);
	if ((s = config_string(header, name)) != NULL) {
		struct group *gr;
		if (!strcmp(s, "*"))
			cred->gid = -1U;
		else if ((gr = getgrnam(s)) == NULL)
			Eprintf("Unknown group `%s' in %s:%s config entry\n",
				header, name, s);
		else
			cred->gid = gr->gr_gid;
	}
	free(name);
}
Beispiel #2
0
TEST_F(NginxStringConfigTest, Comment) {
    std::string config_string("foo bar; # comment here");
    EXPECT_TRUE(ParseString(config_string));
    EXPECT_EQ(1, config_.statements_.size());
    EXPECT_EQ("foo", config_.statements_.at(0)->tokens_.at(0));
    EXPECT_EQ("bar", config_.statements_.at(0)->tokens_.at(1));
}
Beispiel #3
0
void client_cleanup(void)
{
	char *path = config_string("server", "socket-path");
	if (!path)
		path = SOCKET_PATH;
	unlink(path);
}
Beispiel #4
0
void bus_setup(void)
{
	bus_trigger = config_string("socket", "bus-uc-threshold-trigger");
	if (bus_trigger && trigger_check(bus_trigger) < 0) {
		SYSERRprintf("Cannot access bus threshold trigger `%s'",
				bus_trigger);
		exit(1);
	}

	iomca_trigger = config_string("socket", "iomca-threshold-trigger");
	if (iomca_trigger && trigger_check(iomca_trigger) < 0) {
		SYSERRprintf("Cannot access iomca threshold trigger `%s'",
				iomca_trigger);
		exit(1);
	}
}
Beispiel #5
0
TEST_F(NginxStringConfigTest, StatementQuotes) {
    std::string config_string("foo bar \"\'quotes\'\";");
    EXPECT_TRUE(ParseString(config_string));
    EXPECT_EQ("foo", config_.statements_.at(0)->tokens_.at(0));
    EXPECT_EQ("bar", config_.statements_.at(0)->tokens_.at(1));
    EXPECT_EQ("\"\'quotes\'\"", config_.statements_.at(0)->tokens_.at(2));
}
Beispiel #6
0
int main(int ac, char **av)
{
	if (!av[1])
		printf("need config file\n"), exit(1);
	if (parse_config_file(av[1]) < 0)
		printf("cannot parse config file\n"), exit(1);
	char *type;
	char *header;
	char *name;
	int n;
	while (scanf("%as %as %as", &type, &header, &name) == 3) {
		switch (type[0]) {
		case 'n':
			if (config_number(header, name, "%d", &n) < 0)
				printf("Cannot parse number %s %s\n", header, name);
			else
				printf("res %d\n", n);
			break;
		case 's':
			printf("res %s\n", config_string(header, name));
			break;
		case 'b':
			printf("res %d\n", config_bool(header, name));
			break;
		default:
			printf("unknown type %s\n", type);
			break;
		}
		free(type);
		free(header);
		free(name);
	}
	return 0;
}
Beispiel #7
0
TEST_F(NginxStringConfigTest, ComplexStatement) {
    std::string config_string("foo bar 127.0.0.1 loo=dar;");
    EXPECT_TRUE(ParseString(config_string));
    EXPECT_EQ("foo", config_.statements_.at(0)->tokens_.at(0));
    EXPECT_EQ("bar", config_.statements_.at(0)->tokens_.at(1));
    EXPECT_EQ("127.0.0.1", config_.statements_.at(0)->tokens_.at(2));
    EXPECT_EQ("loo=dar", config_.statements_.at(0)->tokens_.at(3));
}
Beispiel #8
0
TEST_F(NginxStringConfigTest, NestedBlock) {
    std::string config_string("foo { bar loo; }");
    EXPECT_TRUE(ParseString(config_string));
    EXPECT_EQ("foo", config_.statements_.at(0)->tokens_.at(0));
    EXPECT_EQ("bar", config_.statements_.at(0)->child_block_.get()
                        ->statements_.at(0)->tokens_.at(0));
    EXPECT_EQ("loo", config_.statements_.at(0)->child_block_.get()
                        ->statements_.at(0)->tokens_.at(1));
}
Beispiel #9
0
int config_number(const char *header, const char *name, char *fmt, void *val)
{
	char *str = config_string(header, name);
	if (str == NULL)
		return -1;
	if (sscanf(str, fmt, val) != 1) {
		unparseable("numerical", header, name);
		return -1;
	}
	return 0;
}
Beispiel #10
0
int config_choice(const char *header, const char *name, const struct config_choice *c)
{
	char *str = config_string(header, name);
	if (!str)
		return -1;
	for (; c->name; c++) {
		if (!strcasecmp(str, c->name))
			return c->val;
	}
	unparseable("choice", header, name);
	return -1;
}
Beispiel #11
0
Datei: disk.c Projekt: balr0g/cw
/****************************************************************************
 * config_disk_info
 ****************************************************************************/
static cw_bool_t
config_disk_info(
	struct config			*cfg,
	struct disk			*dsk)

	{
	cw_char_t			info[GLOBAL_MAX_NAME_SIZE];

	config_string(cfg, info, sizeof (info));
	if (! disk_set_info(dsk, info)) debug_error();
	return (CW_BOOL_OK);
	}
Beispiel #12
0
uint32_t system_locale( void )
{
	uint32_t localeval = 0;
	char localestr[4];
	
	const char* locale = config_string( HASH_USER, HASH_LOCALE );
	if( ( locale == LOCALE_BLANK ) || ( string_length( locale ) != 4 ) )
		locale = config_string( HASH_APPLICATION, HASH_LOCALE );
	if( ( locale == LOCALE_BLANK ) || ( string_length( locale ) != 4 ) )
		locale = config_string( HASH_FOUNDATION, HASH_LOCALE );
	if( ( locale == LOCALE_BLANK ) || ( string_length( locale ) != 4 ) )
		return _system_user_locale();
	
#define _LOCALE_CHAR_TO_LOWERCASE(x)   (((unsigned char)(x) >= 'A') && ((unsigned char)(x) <= 'Z')) ? (((unsigned char)(x)) | (32)) : (x)
#define _LOCALE_CHAR_TO_UPPERCASE(x)   (((unsigned char)(x) >= 'a') && ((unsigned char)(x) <= 'z')) ? (((unsigned char)(x)) & (~32)) : (x)
	localestr[0] = _LOCALE_CHAR_TO_LOWERCASE( locale[0] );
	localestr[1] = _LOCALE_CHAR_TO_LOWERCASE( locale[1] );
	localestr[2] = _LOCALE_CHAR_TO_UPPERCASE( locale[2] );
	localestr[3] = _LOCALE_CHAR_TO_UPPERCASE( locale[3] );

	memcpy( &localeval, localestr, 4 );
	return localeval;
}
Beispiel #13
0
static NOINLINE char* _expand_string( hash_t section_current, char* str )
{
	char* expanded;
	char* variable;
	unsigned int var_pos, var_end_pos, variable_length, separator, var_offset;
	hash_t section, key;

	expanded = str;
	var_pos = string_find_string( expanded, "$(", 0 );

	while( var_pos != STRING_NPOS )
	{
		var_end_pos = string_find( expanded, ')', var_pos + 2 );
		FOUNDATION_ASSERT_MSG( var_end_pos != STRING_NPOS, "Malformed config variable statement" );
		variable = string_substr( expanded, var_pos, ( var_end_pos != STRING_NPOS ) ? ( 1 + var_end_pos - var_pos ) : STRING_NPOS );

		section = section_current;
		key = 0;
		variable_length = string_length( variable );
		separator = string_find( variable, ':', 0 );
		if( separator != STRING_NPOS )
		{
			if( separator != 2 )
				section = hash( variable + 2, separator - 2 );
			var_offset = separator + 1;
		}
		else
		{
			var_offset = 2;
		}
		key = hash( variable + var_offset, variable_length - ( var_offset + ( variable[ variable_length - 1 ] == ')' ? 1 : 0 ) ) );

		if( expanded == str )
			expanded = string_clone( str );

		if( section != HASH_ENVIRONMENT )
			expanded = string_replace( expanded, variable, config_string( section, key ), false );
		else
			expanded = string_replace( expanded, variable, _expand_environment( key, variable + var_offset ), false );
		string_deallocate( variable );

		var_pos = string_find_string( expanded, "$(", 0 );
	}
#if BUILD_ENABLE_DEBUG_CONFIG
	if( str != expanded )
		log_debugf( HASH_CONFIG, "Expanded config value \"%s\" to \"%s\"", str, expanded );
#endif

	return expanded;
}
Beispiel #14
0
int config_trigger(const char *header, const char *base, struct bucket_conf *bc)
{
	char *s;
	char *name;
	int n;

	asprintf(&name, "%s-threshold", base);
	s = config_string(header, name);
	if (s) {
		if (bucket_conf_init(bc, s) < 0) {
			unparseable("trigger", header, name);
			return -1;
		}
	}
	free(name);

	asprintf(&name, "%s-trigger", base);
	s = config_string(header, name);
	if (s) {
		/* no $PATH */
		if (trigger_check(s) != 0) {
			SYSERRprintf("Trigger `%s' not executable\n", s);
			exit(1);
		}
		bc->trigger = s;
	}
	free(name);

	bc->log = 0;
	asprintf(&name, "%s-log", base);
	n = config_bool(header, name);
	if (n >= 0)
		bc->log = n;
	free(name);

	return 0;
}
Beispiel #15
0
static sp_session *
create_session(PyObject *client, PyObject *settings)
{
    sp_session_config config;
    sp_session* session;
    sp_error error;

    memset(&config, 0, sizeof(config));
    config.api_version = SPOTIFY_API_VERSION;
    config.userdata = (void*)client;
    config.callbacks = &g_callbacks;
    config.cache_location = "";
    config.user_agent = "pyspotify-fallback";

    config_data(settings, "application_key", &config.application_key, &config.application_key_size);
    config_string(settings, "cache_location", &config.cache_location);
    config_string(settings, "settings_location", &config.settings_location);
    config_string(settings, "user_agent", &config.user_agent);
    config_string(client, "proxy", &config.proxy);
    config_string(client, "proxy_username", &config.proxy_username);
    config_string(client, "proxy_password", &config.proxy_password);

    debug_printf("cache_location = %s", config.cache_location);
    debug_printf("settings_location = %s", config.settings_location);
    debug_printf("user_agent = %s", config.user_agent);
    debug_printf("proxy = %s", config.proxy);
    debug_printf("proxy_username = %s", config.proxy_username);
    debug_printf("proxy_password = %s", config.proxy_password);
    debug_printf("application_key_size = %zu", config.application_key_size);

    if (PyErr_Occurred() != NULL) {
        return NULL;
    }

    if (strlen(config.user_agent) > 255) {
        PyErr_SetString(SpotifyError, "user_agent may not be longer than 255.");
        return NULL;
    }

    if (config.application_key_size == 0) {
        PyErr_SetString(SpotifyError, "application_key must be provided.");
        return NULL;
    }

    debug_printf("creating session...");
    /* TODO: Figure out if we should ever release the session */
    error = sp_session_create(&config, &session);
    if (error != SP_ERROR_OK) {
        PyErr_SetString(SpotifyError, sp_error_message(error));
        return NULL;
    }
    session_constructed = 1;
    g_session = session;
    return session;
}
Beispiel #16
0
bool config_int(config_t c, const char* name, int* ret)
{
	const char *str = config_string(c, name);
	if (!str) return false;

	char *eptr = NULL;
	errno = 0;
	*ret = strtol(str, &eptr, 10);
	if (*eptr || errno)
	{
		fprintf(stderr, "Configuration parameter %s value is invalid\n", name);
		return false;
	}

	return true;
}
Beispiel #17
0
char *config_string(const char *header, const char *name)
{
	struct header *hdr;
	unsigned h = hash(name);
	for (hdr = hlist; hdr; hdr = hdr->next) {
		if (!strcmp(hdr->name, header)) {
			struct opt *o;
			for (o = hdr->opts[h]; o; o = o->next) {
				if (!strcmp(o->name, name))
					return o->val;
			}
		}
	}
	if (strcmp(header, "global"))
		return config_string("global", name);
	return NULL;
}
Beispiel #18
0
/* Send a command to the mcelog server and dump output */
void ask_server(char *command) 
{
	struct sockaddr_un sun;
	int fd;
	FILE * fp;
	int n;
	char buf[1024];
	char *path = config_string("server", "socket-path");
	if (!path)
		path = SOCKET_PATH;

	fd = socket(PF_UNIX, SOCK_STREAM, 0);
	if (fd < 0) {
		SYSERRprintf("client socket");
		return;
	}

	sun.sun_family = AF_UNIX;
	sun.sun_path[sizeof(sun.sun_path)-1] = 0;
	strncpy(sun.sun_path, path, sizeof(sun.sun_path)-1);

	if (connect(fd, (struct sockaddr *)&sun, 
			sizeof(struct sockaddr_un)) < 0)
		SYSERRprintf("client connect");
	
	n = strlen(command);
	if (write(fd, command, n) != n)
		SYSERRprintf("client command write");

	if ((fp = fdopen(fd, "r")) != NULL) {
		while (fgets(buf, sizeof buf, fp)) {
			n = strlen(buf);
			if (n >= 5 && !memcmp(buf + n - 5, "done\n", 5)) {
				fclose(fp);
				return;
			}

			fputs(buf, stdout);
		}
		fclose(fp);
	}

	SYSERRprintf("client read");
}
Beispiel #19
0
/* Use getopt_long struct option array to process config file */
void config_options(struct option *opts, int (*func)(int))
{
	for (; opts->name; opts++) {
		if (!opts->has_arg) {
			if (config_bool("global", opts->name) != 1)
				continue;
			if (opts->flag) {
				*(opts->flag) = opts->val;
				continue;
			}
		} else {
			char *s = config_string("global", opts->name);
			if (s == NULL)
				continue;
			optarg = s;
		}
		func(opts->val);
	}
}
Beispiel #20
0
TEST_F(NginxStringConfigTest, ParseEmpty) {
    std::string config_string("");
    EXPECT_FALSE(ParseString(config_string));
}
Beispiel #21
0
static int
bootstrap_pkg(void)
{
	struct url *u;
	FILE *remote;
	FILE *config;
	char *site;
	struct dns_srvinfo *mirrors, *current;
	/* To store _https._tcp. + hostname + \0 */
	char zone[MAXHOSTNAMELEN + 13];
	char url[MAXPATHLEN];
	char conf[MAXPATHLEN];
	char tmppkg[MAXPATHLEN];
	const char *packagesite, *mirror_type;
	char buf[10240];
	char pkgstatic[MAXPATHLEN];
	int fd, retry, ret, max_retry;
	struct url_stat st;
	off_t done, r;
	time_t now;
	time_t last;

	done = 0;
	last = 0;
	max_retry = 3;
	ret = -1;
	remote = NULL;
	config = NULL;
	current = mirrors = NULL;

	printf("Bootstrapping pkg please wait\n");

	if (config_string(PACKAGESITE, &packagesite) != 0) {
		warnx("No PACKAGESITE defined");
		return (-1);
	}
	if (config_string(MIRROR_TYPE, &mirror_type) != 0) {
		warnx("No MIRROR_TYPE defined");
		return (-1);
	}
	snprintf(url, MAXPATHLEN, "%s/Latest/pkg.txz", packagesite);

	snprintf(tmppkg, MAXPATHLEN, "%s/pkg.txz.XXXXXX",
	    getenv("TMPDIR") ? getenv("TMPDIR") : _PATH_TMP);

	if ((fd = mkstemp(tmppkg)) == -1) {
		warn("mkstemp()");
		return (-1);
	}

	retry = max_retry;

	u = fetchParseURL(url);
	while (remote == NULL) {
		if (retry == max_retry) {
			if (strcmp(u->scheme, "file") != 0 &&
			    strcasecmp(mirror_type, "srv") == 0) {
				snprintf(zone, sizeof(zone),
				    "_%s._tcp.%s", u->scheme, u->host);
				mirrors = dns_getsrvinfo(zone);
				current = mirrors;
			}
		}

		if (mirrors != NULL)
			strlcpy(u->host, current->host, sizeof(u->host));

		remote = fetchXGet(u, &st, "");
		if (remote == NULL) {
			--retry;
			if (retry <= 0)
				goto fetchfail;
			if (mirrors == NULL) {
				sleep(1);
			} else {
				current = current->next;
				if (current == NULL)
					current = mirrors;
			}
		}
	}

	if (remote == NULL)
		goto fetchfail;

	while (done < st.size) {
		if ((r = fread(buf, 1, sizeof(buf), remote)) < 1)
			break;

		if (write(fd, buf, r) != r) {
			warn("write()");
			goto cleanup;
		}

		done += r;
		now = time(NULL);
		if (now > last || done == st.size)
			last = now;
	}

	if (ferror(remote))
		goto fetchfail;

	if ((ret = extract_pkg_static(fd, pkgstatic, MAXPATHLEN)) == 0)
		ret = install_pkg_static(pkgstatic, tmppkg);

	snprintf(conf, MAXPATHLEN, "%s/etc/pkg.conf",
	    getenv("LOCALBASE") ? getenv("LOCALBASE") : _LOCALBASE);

	if (access(conf, R_OK) == -1) {
		site = strrchr(url, '/');
		if (site == NULL)
			goto cleanup;
		site[0] = '\0';
		site = strrchr(url, '/');
		if (site == NULL)
			goto cleanup;
		site[0] = '\0';

		config = fopen(conf, "w+");
		if (config == NULL)
			goto cleanup;
		fprintf(config, "packagesite: %s\n", url);
		fclose(config);
	}

	goto cleanup;

fetchfail:
	warnx("Error fetching %s: %s", url, fetchLastErrString);
	fprintf(stderr, "A pre-built version of pkg could not be found for your system.\n");
	fprintf(stderr, "Consider changing PACKAGESITE or installing it from ports: 'ports-mgmt/pkg'.\n");

cleanup:
	if (remote != NULL)
		fclose(remote);
	close(fd);
	unlink(tmppkg);

	return (ret);
}
Beispiel #22
0
hash_t config_string_hash( hash_t section, hash_t key )
{
	const char* value = config_string( section, key );
	return value ? hash( value, string_length( value ) ) : HASH_EMPTY_STRING;
}
Beispiel #23
0
static const char *config_control(struct control **as)
{
	const char *t = 0;
	struct control *a, *b;
	struct simple_list *l;

	b = *as;
	while (b && b->locations)
		b = b->next;
	MAKE(a, struct control);
	a->locations = 0;
	a->alias = 0;
	a->clients = 0;
	if (b) {
		a->index_names = b->index_names;
		a->accesses = b->accesses;
		a->mimes = b->mimes;
		a->symlinksok = b->symlinksok;
		a->path_args_ok = b->path_args_ok;
		a->loglevel = b->loglevel;
		a->admin = b->admin;
		a->refresh = b->refresh;
	}
	else {
		a->index_names = 0;
		a->accesses = 0;
		a->mimes = 0;
		a->symlinksok = 0;
		a->path_args_ok = 0;
		a->loglevel = 0;
		a->admin = 0;
		a->refresh = 0;
	}
	a->next = *as;
	*as = a;
	GETOPEN();
	while (NOTCLOSE()) {
		REQWORD();
		if (strceq(tokbuf, c_location)) {
			MAKE(l, struct simple_list);
			GETSTRING();
			chopslash(tokbuf);
			COPY(l->name, tokbuf);
			if (a->locations) {
				l->next = a->locations->next;
				a->locations->next = l;
			} else {
				l->next = l;
				a->locations = l;
			}
		}
		else if (strceq(tokbuf, c_alias)) {
			GETSTRING();
			chopslash(tokbuf);
			COPY(a->alias, tokbuf);
		}
		else if (strceq(tokbuf, c_symlinks))
			t = config_flag(&a->symlinksok);
		else if (strceq(tokbuf, c_path_args))
			t = config_flag(&a->path_args_ok);
		else if (strceq(tokbuf, c_loglevel))
			t = config_int(&a->loglevel);
		else if (strceq(tokbuf, c_index_names))
			t = config_list(&a->index_names);
		else if (strceq(tokbuf, c_access))
			t = config_access(&a->accesses);
		else if (strceq(tokbuf, c_clients))
			t = config_access(&a->clients);
		else if (strceq(tokbuf, c_types))
			t = config_mime(&a->mimes, M_TYPE);
		else if (strceq(tokbuf, c_specials))
			t = config_mime(&a->mimes, M_SPECIAL);
		else if (strceq(tokbuf, c_admin))
			t = config_string(&a->admin);
		else if (strceq(tokbuf, c_refresh))
			t = config_int(&a->refresh);
		else
			t = e_keyword;
		if (t)
			return t;
	}
	if (a->alias && (a->locations == 0))
		return e_bad_alias;
	return 0;
}