Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/doas/env.c	Lines:	0	76	0.0 %
Date:	2017-11-07	Branches:	0	210	0.0 %


/* $OpenBSD: env.c,v 1.6 2017/04/06 21:12:06 tedu Exp $ */
/*
 * Copyright (c) 2016 Ted Unangst <tedu@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>
#include <sys/tree.h>

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <err.h>
#include <unistd.h>
#include <errno.h>

#include "doas.h"

struct envnode {
	RB_ENTRY(envnode) node;
	const char *key;
	const char *value;
};

struct env {
	RB_HEAD(envtree, envnode) root;
	u_int count;
};

static int
envcmp(struct envnode *a, struct envnode *b)
{
	return strcmp(a->key, b->key);
}
RB_GENERATE_STATIC(envtree, envnode, node, envcmp)

static struct envnode *
createnode(const char *key, const char *value)
{
	struct envnode *node;

	node = malloc(sizeof(*node));
	if (!node)
		err(1, NULL);
	node->key = strdup(key);
	node->value = strdup(value);
	if (!node->key || !node->value)
		err(1, NULL);
	return node;
}

static void
freenode(struct envnode *node)
{
	free((char *)node->key);
	free((char *)node->value);
	free(node);
}

static struct env *
createenv(const struct rule *rule)
{
	struct env *env;
	u_int i;

	env = malloc(sizeof(*env));
	if (!env)
		err(1, NULL);
	RB_INIT(&env->root);
	env->count = 0;

	if (rule->options & KEEPENV) {
		extern const char **environ;

		for (i = 0; environ[i] != NULL; i++) {
			struct envnode *node;
			const char *e, *eq;
			size_t len;
			char name[1024];

			e = environ[i];

			/* ignore invalid or overlong names */
			if ((eq = strchr(e, '=')) == NULL || eq == e)
				continue;
			len = eq - e;
			if (len > sizeof(name) - 1)
				continue;
			memcpy(name, e, len);
			name[len] = '\0';

			node = createnode(name, eq + 1);
			if (RB_INSERT(envtree, &env->root, node)) {
				/* ignore any later duplicates */
				freenode(node);
			} else {
				env->count++;
			}
		}
	}

	return env;
}

static char **
flattenenv(struct env *env)
{
	char **envp;
	struct envnode *node;
	u_int i;

	envp = reallocarray(NULL, env->count + 1, sizeof(char *));
	if (!envp)
		err(1, NULL);
	i = 0;
	RB_FOREACH(node, envtree, &env->root) {
		if (asprintf(&envp[i], "%s=%s", node->key, node->value) == -1)
			err(1, NULL);
		i++;
	}
	envp[i] = NULL;
	return envp;
}

static void
fillenv(struct env *env, const char **envlist)
{
	struct envnode *node, key;
	const char *e, *eq;
	const char *val;
	char name[1024];
	u_int i;
	size_t len;

	for (i = 0; envlist[i]; i++) {
		e = envlist[i];

		/* parse out env name */
		if ((eq = strchr(e, '=')) == NULL)
			len = strlen(e);
		else
			len = eq - e;
		if (len > sizeof(name) - 1)
			continue;
		memcpy(name, e, len);
		name[len] = '\0';

		/* delete previous copies */
		key.key = name;
		if (*name == '-')
			key.key = name + 1;
		if ((node = RB_FIND(envtree, &env->root, &key))) {
			RB_REMOVE(envtree, &env->root, node);
			freenode(node);
			env->count--;
		}
		if (*name == '-')
			continue;

		/* assign value or inherit from environ */
		if (eq) {
			val = eq + 1;
			if (*val == '$')
				val = getenv(val + 1);
		} else {
			val = getenv(name);
		}
		/* at last, we have something to insert */
		if (val) {
			node = createnode(name, val);
			RB_INSERT(envtree, &env->root, node);
			env->count++;
		}
	}
}

char **
prepenv(const struct rule *rule)
{
	static const char *safeset[] = {
		"DISPLAY", "HOME", "LOGNAME", "MAIL",
		"PATH", "TERM", "USER", "USERNAME",
		NULL
	};
	struct env *env;

	env = createenv(rule);

	/* if we started with blank, fill some defaults then apply rules */
	if (!(rule->options & KEEPENV))
		fillenv(env, safeset);
	if (rule->envlist)
		fillenv(env, rule->envlist);

	return flattenenv(env);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: env.c,v 1.6 2017/04/06 21:12:06 tedu Exp $ */
2			/*
3			* Copyright (c) 2016 Ted Unangst <tedu@openbsd.org>
4			*
5			* Permission to use, copy, modify, and distribute this software for any
6			* purpose with or without fee is hereby granted, provided that the above
7			* copyright notice and this permission notice appear in all copies.
8			*
9			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16			*/
17
18			#include <sys/types.h>
19			#include <sys/tree.h>
20
21			#include <string.h>
22			#include <stdio.h>
23			#include <stdlib.h>
24			#include <err.h>
25			#include <unistd.h>
26			#include <errno.h>
27
28			#include "doas.h"
29
30			struct envnode {
31			RB_ENTRY(envnode) node;
32			const char *key;
33			const char *value;
34			};
35
36			struct env {
37			RB_HEAD(envtree, envnode) root;
38			u_int count;
39			};
40
41			static int
42			envcmp(struct envnode a, struct envnode b)
43			{
44			return strcmp(a->key, b->key);
45			}
46			RB_GENERATE_STATIC(envtree, envnode, node, envcmp)
47
48			static struct envnode *
49			createnode(const char key, const char value)
50			{
51			struct envnode *node;
52
53			node = malloc(sizeof(*node));
54			if (!node)
55			err(1, NULL);
56			node->key = strdup(key);
57			node->value = strdup(value);
58			if (!node->key \|\| !node->value)
59			err(1, NULL);
60			return node;
61			}
62
63			static void
64			freenode(struct envnode *node)
65			{
66			free((char *)node->key);
67			free((char *)node->value);
68			free(node);
69			}
70
71			static struct env *
72			createenv(const struct rule *rule)
73			{
74			struct env *env;
75			u_int i;
76
77			env = malloc(sizeof(*env));
78			if (!env)
79			err(1, NULL);
80			RB_INIT(&env->root);
81			env->count = 0;
82
83			if (rule->options & KEEPENV) {
84			extern const char **environ;
85
86			for (i = 0; environ[i] != NULL; i++) {
87			struct envnode *node;
88			const char e, eq;
89			size_t len;
90			char name[1024];
91
92			e = environ[i];
93
94			/* ignore invalid or overlong names */
95			if ((eq = strchr(e, '=')) == NULL \|\| eq == e)
96			continue;
97			len = eq - e;
98			if (len > sizeof(name) - 1)
99			continue;
100			memcpy(name, e, len);
101			name[len] = '\0';
102
103			node = createnode(name, eq + 1);
104			if (RB_INSERT(envtree, &env->root, node)) {
105			/* ignore any later duplicates */
106			freenode(node);
107			} else {
108			env->count++;
109			}
110			}
111			}
112
113			return env;
114			}
115
116			static char **
117			flattenenv(struct env *env)
118			{
119			char **envp;
120			struct envnode *node;
121			u_int i;
122
123			envp = reallocarray(NULL, env->count + 1, sizeof(char *));
124			if (!envp)
125			err(1, NULL);
126			i = 0;
127			RB_FOREACH(node, envtree, &env->root) {
128			if (asprintf(&envp[i], "%s=%s", node->key, node->value) == -1)
129			err(1, NULL);
130			i++;
131			}
132			envp[i] = NULL;
133			return envp;
134			}
135
136			static void
137			fillenv(struct env env, const char *envlist)
138			{
139			struct envnode *node, key;
140			const char e, eq;
141			const char *val;
142			char name[1024];
143			u_int i;
144			size_t len;
145
146			for (i = 0; envlist[i]; i++) {
147			e = envlist[i];
148
149			/* parse out env name */
150			if ((eq = strchr(e, '=')) == NULL)
151			len = strlen(e);
152			else
153			len = eq - e;
154			if (len > sizeof(name) - 1)
155			continue;
156			memcpy(name, e, len);
157			name[len] = '\0';
158
159			/* delete previous copies */
160			key.key = name;
161			if (*name == '-')
162			key.key = name + 1;
163			if ((node = RB_FIND(envtree, &env->root, &key))) {
164			RB_REMOVE(envtree, &env->root, node);
165			freenode(node);
166			env->count--;
167			}
168			if (*name == '-')
169			continue;
170
171			/* assign value or inherit from environ */
172			if (eq) {
173			val = eq + 1;
174			if (*val == '$')
175			val = getenv(val + 1);
176			} else {
177			val = getenv(name);
178			}
179			/* at last, we have something to insert */
180			if (val) {
181			node = createnode(name, val);
182			RB_INSERT(envtree, &env->root, node);
183			env->count++;
184			}
185			}
186			}
187
188			char **
189			prepenv(const struct rule *rule)
190			{
191			static const char *safeset[] = {
192			"DISPLAY", "HOME", "LOGNAME", "MAIL",
193			"PATH", "TERM", "USER", "USERNAME",
194			NULL
195			};
196			struct env *env;
197
198			env = createenv(rule);
199
200			/* if we started with blank, fill some defaults then apply rules */
201			if (!(rule->options & KEEPENV))
202			fillenv(env, safeset);
203			if (rule->envlist)
204			fillenv(env, rule->envlist);
205
206			return flattenenv(env);
207			}