[babeltrace.git] / common / common.c

/*
 * Babeltrace common functions
 *
 * Copyright 2016 Philippe Proulx <pproulx@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <pwd.h>
#include <unistd.h>
#include <assert.h>
#include <ctype.h>
#include <glib.h>
#include <babeltrace/babeltrace-internal.h>
#include <babeltrace/common-internal.h>

#define SYSTEM_PLUGIN_PATH	INSTALL_LIBDIR "/babeltrace/plugins"
#define HOME_ENV_VAR		"HOME"
#define HOME_PLUGIN_SUBPATH	"/.local/lib/babeltrace/plugins"

BT_HIDDEN
const char *bt_common_get_system_plugin_path(void)
{
	return SYSTEM_PLUGIN_PATH;
}

BT_HIDDEN
bool bt_common_is_setuid_setgid(void)
{
	return (geteuid() != getuid() || getegid() != getgid());
}

static char *bt_secure_getenv(const char *name)
{
	if (bt_common_is_setuid_setgid()) {
		printf_error("Disregarding %s environment variable for setuid/setgid binary",
			name);
		return NULL;
	}
	return getenv(name);
}

static const char *get_home_dir(void)
{
	char *val = NULL;
	struct passwd *pwd;

	val = bt_secure_getenv(HOME_ENV_VAR);
	if (val) {
		goto end;
	}
	/* Fallback on password file. */
	pwd = getpwuid(getuid());
	if (!pwd) {
		goto end;
	}
	val = pwd->pw_dir;
end:
	return val;
}

BT_HIDDEN
char *bt_common_get_home_plugin_path(void)
{
	char *path = NULL;
	const char *home_dir;

	home_dir = get_home_dir();
	if (!home_dir) {
		goto end;
	}

	if (strlen(home_dir) + strlen(HOME_PLUGIN_SUBPATH) + 1 >= PATH_MAX) {
		printf_error("Home directory path is too long: `%s`\n",
			home_dir);
		goto end;
	}

	path = malloc(PATH_MAX);
	if (!path) {
		goto end;
	}

	strcpy(path, home_dir);
	strcat(path, HOME_PLUGIN_SUBPATH);

end:
	return path;
}

BT_HIDDEN
int bt_common_append_plugin_path_dirs(const char *paths, GPtrArray *dirs)
{
	int ret = 0;
	const char *at;
	const char *end;
	size_t init_dirs_len;

	assert(dirs);
	init_dirs_len = dirs->len;

	if (!paths) {
		/* Nothing to append */
		goto end;
	}

	at = paths;
	end = paths + strlen(paths);

	while (at < end) {
		GString *path;
		const char *next_colon;

		next_colon = strchr(at, ':');
		if (next_colon == at) {
			/*
			 * Empty path: try next character (supported
			 * to conform to the typical parsing of $PATH).
			 */
			at++;
			continue;
		} else if (!next_colon) {
			/* No more colon: use the remaining */
			next_colon = paths + strlen(paths);
		}

		path = g_string_new(NULL);
		if (!path) {
			goto error;
		}

		g_string_append_len(path, at, next_colon - at);
		at = next_colon + 1;
		g_ptr_array_add(dirs, path);
	}

	goto end;

error:
	ret = -1;

	/* Remove the new entries in dirs */
	while (dirs->len > init_dirs_len) {
		g_ptr_array_remove_index(dirs, init_dirs_len);
	}

end:
	return ret;
}

BT_HIDDEN
bool bt_common_colors_supported(void)
{
	static bool supports_colors = false;
	static bool supports_colors_set = false;
	const char *term;

	if (supports_colors_set) {
		goto end;
	}

	supports_colors_set = true;

	term = getenv("TERM");
	if (!term) {
		goto end;
	}

	if (strncmp(term, "xterm", 5) != 0 &&
			strncmp(term, "rxvt", 4) != 0 &&
			strncmp(term, "konsole", 7) != 0 &&
			strncmp(term, "gnome", 5) != 0 &&
			strncmp(term, "screen", 5) != 0 &&
			strncmp(term, "tmux", 4) != 0 &&
			strncmp(term, "putty", 5) != 0) {
		goto end;
	}

	if (!isatty(1)) {
		goto end;
	}

	supports_colors = true;

end:
	return supports_colors;
}

BT_HIDDEN
const char *bt_common_color_reset(void)
{
	return bt_common_colors_supported() ? BT_COMMON_COLOR_RESET : "";
}

BT_HIDDEN
const char *bt_common_color_bold(void)
{
	return bt_common_colors_supported() ? BT_COMMON_COLOR_BOLD : "";
}

BT_HIDDEN
const char *bt_common_color_fg_default(void)
{
	return bt_common_colors_supported() ? BT_COMMON_COLOR_FG_DEFAULT : "";
}

BT_HIDDEN
const char *bt_common_color_fg_red(void)
{
	return bt_common_colors_supported() ? BT_COMMON_COLOR_FG_RED : "";
}

BT_HIDDEN
const char *bt_common_color_fg_green(void)
{
	return bt_common_colors_supported() ? BT_COMMON_COLOR_FG_GREEN : "";
}

BT_HIDDEN
const char *bt_common_color_fg_yellow(void)
{
	return bt_common_colors_supported() ? BT_COMMON_COLOR_FG_YELLOW : "";
}

BT_HIDDEN
const char *bt_common_color_fg_blue(void)
{
	return bt_common_colors_supported() ? BT_COMMON_COLOR_FG_BLUE : "";
}

BT_HIDDEN
const char *bt_common_color_fg_magenta(void)
{
	return bt_common_colors_supported() ? BT_COMMON_COLOR_FG_MAGENTA : "";
}

BT_HIDDEN
const char *bt_common_color_fg_cyan(void)
{
	return bt_common_colors_supported() ? BT_COMMON_COLOR_FG_CYAN : "";
}

BT_HIDDEN
const char *bt_common_color_fg_light_gray(void)
{
	return bt_common_colors_supported() ?
		BT_COMMON_COLOR_FG_LIGHT_GRAY : "";
}

BT_HIDDEN
const char *bt_common_color_bg_default(void)
{
	return bt_common_colors_supported() ? BT_COMMON_COLOR_BG_DEFAULT : "";
}

BT_HIDDEN
const char *bt_common_color_bg_red(void)
{
	return bt_common_colors_supported() ? BT_COMMON_COLOR_BG_RED : "";
}

BT_HIDDEN
const char *bt_common_color_bg_green(void)
{
	return bt_common_colors_supported() ? BT_COMMON_COLOR_BG_GREEN : "";
}

BT_HIDDEN
const char *bt_common_color_bg_yellow(void)
{
	return bt_common_colors_supported() ? BT_COMMON_COLOR_BG_YELLOW : "";
}

BT_HIDDEN
const char *bt_common_color_bg_blue(void)
{
	return bt_common_colors_supported() ? BT_COMMON_COLOR_BG_BLUE : "";
}

BT_HIDDEN
const char *bt_common_color_bg_magenta(void)
{
	return bt_common_colors_supported() ? BT_COMMON_COLOR_BG_MAGENTA : "";
}

BT_HIDDEN
const char *bt_common_color_bg_cyan(void)
{
	return bt_common_colors_supported() ? BT_COMMON_COLOR_BG_CYAN : "";
}

BT_HIDDEN
const char *bt_common_color_bg_light_gray(void)
{
	return bt_common_colors_supported() ?
		BT_COMMON_COLOR_BG_LIGHT_GRAY : "";
}

BT_HIDDEN
GString *bt_common_string_until(const char *input, const char *escapable_chars,
		const char *end_chars, size_t *end_pos)
{
	GString *output = g_string_new(NULL);
	const char *ch;
	const char *es_char;
	const char *end_char;

	if (!output) {
		goto error;
	}

	for (ch = input; *ch != '\0'; ch++) {
		if (*ch == '\\') {
			bool continue_loop = false;

			if (ch[1] == '\0') {
				/* `\` at the end of the string: append `\` */
				g_string_append_c(output, *ch);
				ch++;
				goto set_end_pos;
			}

			for (es_char = escapable_chars; *es_char != '\0'; es_char++) {
				if (ch[1] == *es_char) {
					/*
					 * `\` followed by an escapable
					 * character: append the escaped
					 * character only.
					 */
					g_string_append_c(output, ch[1]);
					ch++;
					continue_loop = true;
					break;
				}
			}

			if (continue_loop) {
				continue;
			}

			/*
			 * `\` followed by a non-escapable character:
			 * append `\` and the character.
			 */
			g_string_append_c(output, *ch);
			g_string_append_c(output, ch[1]);
			ch++;
			continue;
		} else {
			for (end_char = end_chars; *end_char != '\0'; end_char++) {
				if (*ch == *end_char) {
					/*
					 * End character found:
					 * terminate this loop.
					 */
					goto set_end_pos;
				}
			}

			/* Normal character: append */
			g_string_append_c(output, *ch);
		}
	}

set_end_pos:
	if (end_pos) {
		*end_pos = ch - input;
	}

	goto end;

error:
	if (output) {
		g_string_free(output, TRUE);
	}

end:
	return output;
}

BT_HIDDEN
GString *bt_common_shell_quote(const char *input, bool with_single_quotes)
{
	GString *output = g_string_new(NULL);
	const char *ch;
	bool no_quote = true;

	if (!output) {
		goto end;
	}

	if (strlen(input) == 0) {
		if (with_single_quotes) {
			g_string_assign(output, "''");
		}

		goto end;
	}

	for (ch = input; *ch != '\0'; ch++) {
		const char c = *ch;

		if (!g_ascii_isalpha(c) && !g_ascii_isdigit(c) && c != '_' &&
				c != '@' && c != '%' && c != '+' && c != '=' &&
				c != ':' && c != ',' && c != '.' && c != '/' &&
				c != '-') {
			no_quote = false;
			break;
		}
	}

	if (no_quote) {
		g_string_assign(output, input);
		goto end;
	}

	if (with_single_quotes) {
		g_string_assign(output, "'");
	}

	for (ch = input; *ch != '\0'; ch++) {
		if (*ch == '\'') {
			g_string_append(output, "'\"'\"'");
		} else {
			g_string_append_c(output, *ch);
		}
	}

	if (with_single_quotes) {
		g_string_append_c(output, '\'');
	}

end:
	return output;
}

BT_HIDDEN
bool bt_common_string_is_printable(const char *input)
{
	const char *ch;
	bool printable = true;
	assert(input);

	for (ch = input; *ch != '\0'; ch++) {
		if (!isprint(*ch) && *ch != '\n' && *ch != '\r' &&
				*ch != '\t' && *ch != '\v') {
			printable = false;
			goto end;
		}
	}

end:
	return printable;
}

BT_HIDDEN
void bt_common_destroy_lttng_live_url_parts(
		struct bt_common_lttng_live_url_parts *parts)
{
	if (!parts) {
		goto end;
	}

	if (parts->proto) {
		g_string_free(parts->proto, TRUE);
		parts->proto = NULL;
	}

	if (parts->hostname) {
		g_string_free(parts->hostname, TRUE);
		parts->hostname = NULL;
	}

	if (parts->target_hostname) {
		g_string_free(parts->target_hostname, TRUE);
		parts->target_hostname = NULL;
	}

	if (parts->session_name) {
		g_string_free(parts->session_name, TRUE);
		parts->session_name = NULL;
	}

end:
	return;
}

BT_HIDDEN
struct bt_common_lttng_live_url_parts bt_common_parse_lttng_live_url(
		const char *url, char *error_buf, size_t error_buf_size)
{
	struct bt_common_lttng_live_url_parts parts;
	const char *at = url;
	size_t end_pos;

	assert(url);
	memset(&parts, 0, sizeof(parts));
	parts.port = -1;

	/* Protocol */
	parts.proto = bt_common_string_until(at, "", ":", &end_pos);
	if (!parts.proto || parts.proto->len == 0) {
		if (error_buf) {
			snprintf(error_buf, error_buf_size, "Missing protocol");
		}

		goto error;
	}

	if (strcmp(parts.proto->str, "net") == 0) {
		g_string_assign(parts.proto, "net4");
	}

	if (strcmp(parts.proto->str, "net4") != 0 &&
			strcmp(parts.proto->str, "net6") != 0) {
		if (error_buf) {
			snprintf(error_buf, error_buf_size,
				"Unknown protocol: `%s`", parts.proto->str);
		}

		goto error;
	}

	if (at[end_pos] != ':') {
		if (error_buf) {
			snprintf(error_buf, error_buf_size,
				"Expecting `:` after `%s`", parts.proto->str);
		}

		goto error;
	}

	at += end_pos;

	/* :// */
	if (strncmp(at, "://", 3) != 0) {
		if (error_buf) {
			snprintf(error_buf, error_buf_size,
				"Expecting `://` after protocol");
		}

		goto error;
	}

	at += 3;

	/* Hostname */
	parts.hostname = bt_common_string_until(at, "", ":/", &end_pos);
	if (!parts.hostname || parts.hostname->len == 0) {
		if (error_buf) {
			snprintf(error_buf, error_buf_size, "Missing hostname");
		}

		goto error;
	}

	if (at[end_pos] == ':') {
		/* Port */
		GString *port;

		at += end_pos + 1;
		port = bt_common_string_until(at, "", "/", &end_pos);
		if (!port || port->len == 0) {
			if (error_buf) {
				snprintf(error_buf, error_buf_size, "Missing port");
			}

			goto error;
		}

		if (sscanf(port->str, "%d", &parts.port) != 1) {
			if (error_buf) {
				snprintf(error_buf, error_buf_size,
					"Invalid port: `%s`", port->str);
			}

			g_string_free(port, TRUE);
			goto error;
		}

		g_string_free(port, TRUE);

		if (parts.port < 0 || parts.port >= 65536) {
			if (error_buf) {
				snprintf(error_buf, error_buf_size,
					"Invalid port: %d", parts.port);
			}

			goto error;
		}
	}

	if (at[end_pos] == '\0') {
		goto end;
	}

	at += end_pos;

	/* /host/ */
	if (strncmp(at, "/host/", 6) != 0) {
		if (error_buf) {
			snprintf(error_buf, error_buf_size,
				"Expecting `/host/` after hostname or port");
		}

		goto error;
	}

	at += 6;

	/* Target hostname */
	parts.target_hostname = bt_common_string_until(at, "", "/", &end_pos);
	if (!parts.target_hostname || parts.target_hostname->len == 0) {
		if (error_buf) {
			snprintf(error_buf, error_buf_size,
				"Missing target hostname");
		}

		goto error;
	}

	if (at[end_pos] == '\0') {
		goto end;
	}

	at += end_pos + 1;

	/* Session name */
	parts.session_name = bt_common_string_until(at, "", "/", &end_pos);
	if (!parts.session_name || parts.session_name->len == 0) {
		if (error_buf) {
			snprintf(error_buf, error_buf_size,
				"Missing session name");
		}

		goto error;
	}

	if (at[end_pos] == '/') {
		if (error_buf) {
			snprintf(error_buf, error_buf_size,
				"Unexpected `/` after session name (`%s`)",
				parts.session_name->str);
		}

		goto error;
	}

	goto end;

error:
	bt_common_destroy_lttng_live_url_parts(&parts);

end:
	return parts;
}
Commit	Line	Data
1670bffd PP	1	/*
	2	* Babeltrace common functions
	3	*
	4	* Copyright 2016 Philippe Proulx <pproulx@efficios.com>
	5	*
	6	* Permission is hereby granted, free of charge, to any person obtaining a copy
	7	* of this software and associated documentation files (the "Software"), to deal
	8	* in the Software without restriction, including without limitation the rights
	9	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	10	* copies of the Software, and to permit persons to whom the Software is
	11	* furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be included in
	14	* all copies or substantial portions of the Software.
	15	*
	16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	19	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	20	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	21	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	22	* SOFTWARE.
	23	*/
	24
290725f7	25	#include <unistd.h>
1670bffd PP	26	#include <string.h>
	27	#include <sys/types.h>
	28	#include <pwd.h>
	29	#include <unistd.h>
	30	#include <assert.h>
db0f160a	31	#include <ctype.h>
1670bffd PP	32	#include <glib.h>
1670bffd PP	33	#include <babeltrace/babeltrace-internal.h>
ad96d936	34	#include <babeltrace/common-internal.h>
1670bffd PP	35
	36	#define SYSTEM_PLUGIN_PATH INSTALL_LIBDIR "/babeltrace/plugins"
	37	#define HOME_ENV_VAR "HOME"
	38	#define HOME_PLUGIN_SUBPATH "/.local/lib/babeltrace/plugins"
	39
	40	BT_HIDDEN
	41	const char *bt_common_get_system_plugin_path(void)
	42	{
	43	return SYSTEM_PLUGIN_PATH;
	44	}
	45
	46	BT_HIDDEN
	47	bool bt_common_is_setuid_setgid(void)
	48	{
	49	return (geteuid() != getuid() \|\| getegid() != getgid());
	50	}
	51
	52	static char bt_secure_getenv(const char name)
	53	{
	54	if (bt_common_is_setuid_setgid()) {
	55	printf_error("Disregarding %s environment variable for setuid/setgid binary",
	56	name);
	57	return NULL;
	58	}
	59	return getenv(name);
	60	}
	61
	62	static const char *get_home_dir(void)
	63	{
	64	char *val = NULL;
	65	struct passwd *pwd;
	66
	67	val = bt_secure_getenv(HOME_ENV_VAR);
	68	if (val) {
	69	goto end;
	70	}
	71	/* Fallback on password file. */
	72	pwd = getpwuid(getuid());
	73	if (!pwd) {
	74	goto end;
	75	}
	76	val = pwd->pw_dir;
	77	end:
	78	return val;
	79	}
	80
	81	BT_HIDDEN
	82	char *bt_common_get_home_plugin_path(void)
	83	{
	84	char *path = NULL;
	85	const char *home_dir;
	86
	87	home_dir = get_home_dir();
	88	if (!home_dir) {
	89	goto end;
	90	}
	91
	92	if (strlen(home_dir) + strlen(HOME_PLUGIN_SUBPATH) + 1 >= PATH_MAX) {
	93	printf_error("Home directory path is too long: `%s`\n",
	94	home_dir);
	95	goto end;
	96	}
	97
	98	path = malloc(PATH_MAX);
99	if (!path) {
100	goto end;
101	}
102
103	strcpy(path, home_dir);
104	strcat(path, HOME_PLUGIN_SUBPATH);
105
106	end:
107	return path;
108	}
109
110	BT_HIDDEN
111	int bt_common_append_plugin_path_dirs(const char paths, GPtrArray dirs)
112	{
113	int ret = 0;
114	const char *at;
115	const char *end;
116	size_t init_dirs_len;
117
118	assert(dirs);
119	init_dirs_len = dirs->len;
120
121	if (!paths) {
122	/* Nothing to append */
123	goto end;
124	}
125
126	at = paths;
127	end = paths + strlen(paths);
128
129	while (at < end) {
130	GString *path;
131	const char *next_colon;
132
133	next_colon = strchr(at, ':');
134	if (next_colon == at) {
135	/*
136	* Empty path: try next character (supported
137	* to conform to the typical parsing of $PATH).
138	*/
139	at++;
140	continue;
141	} else if (!next_colon) {
142	/* No more colon: use the remaining */
143	next_colon = paths + strlen(paths);
144	}
145
146	path = g_string_new(NULL);
147	if (!path) {
148	goto error;
149	}
150
151	g_string_append_len(path, at, next_colon - at);
152	at = next_colon + 1;
153	g_ptr_array_add(dirs, path);
154	}
155
156	goto end;
157
158	error:
159	ret = -1;
160
161	/* Remove the new entries in dirs */
162	while (dirs->len > init_dirs_len) {
163	g_ptr_array_remove_index(dirs, init_dirs_len);
164	}
165
166	end:
167	return ret;
168	}
290725f7	169
ad96d936 PP	170	BT_HIDDEN
ad96d936 PP	171	bool bt_common_colors_supported(void)
290725f7 PP	172	{
	173	static bool supports_colors = false;
	174	static bool supports_colors_set = false;
	175	const char *term;
	176
	177	if (supports_colors_set) {
	178	goto end;
	179	}
	180
	181	supports_colors_set = true;
	182
	183	term = getenv("TERM");
	184	if (!term) {
	185	goto end;
	186	}
	187
	188	if (strncmp(term, "xterm", 5) != 0 &&
	189	strncmp(term, "rxvt", 4) != 0 &&
	190	strncmp(term, "konsole", 7) != 0 &&
69c72672 PP	191	strncmp(term, "gnome", 5) != 0 &&
	192	strncmp(term, "screen", 5) != 0 &&
	193	strncmp(term, "tmux", 4) != 0 &&
	194	strncmp(term, "putty", 5) != 0) {
290725f7 PP	195	goto end;
	196	}
	197
	198	if (!isatty(1)) {
	199	goto end;
	200	}
	201
	202	supports_colors = true;
	203
	204	end:
	205	return supports_colors;
	206	}
	207
	208	BT_HIDDEN
	209	const char *bt_common_color_reset(void)
	210	{
ad96d936	211	return bt_common_colors_supported() ? BT_COMMON_COLOR_RESET : "";
290725f7 PP	212	}
	213
	214	BT_HIDDEN
	215	const char *bt_common_color_bold(void)
	216	{
ad96d936	217	return bt_common_colors_supported() ? BT_COMMON_COLOR_BOLD : "";
290725f7 PP	218	}
	219
	220	BT_HIDDEN
	221	const char *bt_common_color_fg_default(void)
	222	{
ad96d936	223	return bt_common_colors_supported() ? BT_COMMON_COLOR_FG_DEFAULT : "";
290725f7 PP	224	}
	225
	226	BT_HIDDEN
	227	const char *bt_common_color_fg_red(void)
	228	{
ad96d936	229	return bt_common_colors_supported() ? BT_COMMON_COLOR_FG_RED : "";
290725f7 PP	230	}
	231
	232	BT_HIDDEN
	233	const char *bt_common_color_fg_green(void)
	234	{
ad96d936	235	return bt_common_colors_supported() ? BT_COMMON_COLOR_FG_GREEN : "";
290725f7 PP	236	}
	237
	238	BT_HIDDEN
	239	const char *bt_common_color_fg_yellow(void)
	240	{
ad96d936	241	return bt_common_colors_supported() ? BT_COMMON_COLOR_FG_YELLOW : "";
290725f7 PP	242	}
	243
	244	BT_HIDDEN
	245	const char *bt_common_color_fg_blue(void)
	246	{
ad96d936	247	return bt_common_colors_supported() ? BT_COMMON_COLOR_FG_BLUE : "";
290725f7 PP	248	}
	249
	250	BT_HIDDEN
	251	const char *bt_common_color_fg_magenta(void)
	252	{
ad96d936	253	return bt_common_colors_supported() ? BT_COMMON_COLOR_FG_MAGENTA : "";
290725f7 PP	254	}
	255
	256	BT_HIDDEN
	257	const char *bt_common_color_fg_cyan(void)
	258	{
ad96d936	259	return bt_common_colors_supported() ? BT_COMMON_COLOR_FG_CYAN : "";
290725f7 PP	260	}
	261
	262	BT_HIDDEN
	263	const char *bt_common_color_fg_light_gray(void)
	264	{
ad96d936 PP	265	return bt_common_colors_supported() ?
ad96d936 PP	266	BT_COMMON_COLOR_FG_LIGHT_GRAY : "";
290725f7 PP	267	}
	268
	269	BT_HIDDEN
	270	const char *bt_common_color_bg_default(void)
	271	{
ad96d936	272	return bt_common_colors_supported() ? BT_COMMON_COLOR_BG_DEFAULT : "";
290725f7 PP	273	}
	274
	275	BT_HIDDEN
	276	const char *bt_common_color_bg_red(void)
	277	{
ad96d936	278	return bt_common_colors_supported() ? BT_COMMON_COLOR_BG_RED : "";
290725f7 PP	279	}
	280
	281	BT_HIDDEN
	282	const char *bt_common_color_bg_green(void)
	283	{
ad96d936	284	return bt_common_colors_supported() ? BT_COMMON_COLOR_BG_GREEN : "";
290725f7 PP	285	}
	286
	287	BT_HIDDEN
	288	const char *bt_common_color_bg_yellow(void)
	289	{
ad96d936	290	return bt_common_colors_supported() ? BT_COMMON_COLOR_BG_YELLOW : "";
290725f7 PP	291	}
	292
	293	BT_HIDDEN
	294	const char *bt_common_color_bg_blue(void)
	295	{
ad96d936	296	return bt_common_colors_supported() ? BT_COMMON_COLOR_BG_BLUE : "";
290725f7 PP	297	}
	298
	299	BT_HIDDEN
	300	const char *bt_common_color_bg_magenta(void)
	301	{
ad96d936	302	return bt_common_colors_supported() ? BT_COMMON_COLOR_BG_MAGENTA : "";
290725f7 PP	303	}
	304
	305	BT_HIDDEN
	306	const char *bt_common_color_bg_cyan(void)
	307	{
ad96d936	308	return bt_common_colors_supported() ? BT_COMMON_COLOR_BG_CYAN : "";
290725f7 PP	309	}
	310
	311	BT_HIDDEN
	312	const char *bt_common_color_bg_light_gray(void)
	313	{
ad96d936 PP	314	return bt_common_colors_supported() ?
ad96d936 PP	315	BT_COMMON_COLOR_BG_LIGHT_GRAY : "";
290725f7	316	}
db0f160a PP	317
	318	BT_HIDDEN
	319	GString bt_common_string_until(const char input, const char *escapable_chars,
	320	const char end_chars, size_t end_pos)
	321	{
	322	GString *output = g_string_new(NULL);
	323	const char *ch;
	324	const char *es_char;
	325	const char *end_char;
	326
	327	if (!output) {
	328	goto error;
	329	}
	330
	331	for (ch = input; *ch != '\0'; ch++) {
	332	if (*ch == '\\') {
	333	bool continue_loop = false;
	334
	335	if (ch[1] == '\0') {
	336	/* `\` at the end of the string: append `\` */
	337	g_string_append_c(output, *ch);
	338	ch++;
	339	goto set_end_pos;
	340	}
	341
	342	for (es_char = escapable_chars; *es_char != '\0'; es_char++) {
	343	if (ch[1] == *es_char) {
	344	/*
	345	* `\` followed by an escapable
	346	* character: append the escaped
	347	* character only.
	348	*/
	349	g_string_append_c(output, ch[1]);
	350	ch++;
	351	continue_loop = true;
	352	break;
	353	}
	354	}
	355
	356	if (continue_loop) {
	357	continue;
	358	}
	359
	360	/*
	361	* `\` followed by a non-escapable character:
	362	* append `\` and the character.
	363	*/
	364	g_string_append_c(output, *ch);
	365	g_string_append_c(output, ch[1]);
	366	ch++;
	367	continue;
	368	} else {
	369	for (end_char = end_chars; *end_char != '\0'; end_char++) {
	370	if (ch == end_char) {
	371	/*
	372	* End character found:
	373	* terminate this loop.
	374	*/
	375	goto set_end_pos;
	376	}
	377	}
	378
	379	/* Normal character: append */
	380	g_string_append_c(output, *ch);
381	}
382	}
383
384	set_end_pos:
385	if (end_pos) {
386	*end_pos = ch - input;
387	}
388
389	goto end;
390
391	error:
392	if (output) {
393	g_string_free(output, TRUE);
394	}
395
396	end:
397	return output;
398	}
399
400	BT_HIDDEN
36b405c6	401	GString bt_common_shell_quote(const char input, bool with_single_quotes)
db0f160a PP	402	{
	403	GString *output = g_string_new(NULL);
	404	const char *ch;
	405	bool no_quote = true;
	406
	407	if (!output) {
	408	goto end;
	409	}
	410
	411	if (strlen(input) == 0) {
36b405c6 PP	412	if (with_single_quotes) {
	413	g_string_assign(output, "''");
	414	}
	415
db0f160a PP	416	goto end;
	417	}
	418
	419	for (ch = input; *ch != '\0'; ch++) {
	420	const char c = *ch;
	421
	422	if (!g_ascii_isalpha(c) && !g_ascii_isdigit(c) && c != '_' &&
	423	c != '@' && c != '%' && c != '+' && c != '=' &&
	424	c != ':' && c != ',' && c != '.' && c != '/' &&
	425	c != '-') {
	426	no_quote = false;
	427	break;
	428	}
	429	}
	430
	431	if (no_quote) {
	432	g_string_assign(output, input);
	433	goto end;
	434	}
	435
36b405c6 PP	436	if (with_single_quotes) {
	437	g_string_assign(output, "'");
	438	}
db0f160a PP	439
	440	for (ch = input; *ch != '\0'; ch++) {
	441	if (*ch == '\'') {
	442	g_string_append(output, "'\"'\"'");
	443	} else {
	444	g_string_append_c(output, *ch);
	445	}
	446	}
	447
36b405c6 PP	448	if (with_single_quotes) {
	449	g_string_append_c(output, '\'');
	450	}
db0f160a PP	451
	452	end:
	453	return output;
	454	}
	455
	456	BT_HIDDEN
	457	bool bt_common_string_is_printable(const char *input)
	458	{
	459	const char *ch;
	460	bool printable = true;
	461	assert(input);
	462
	463	for (ch = input; *ch != '\0'; ch++) {
	464	if (!isprint(ch) && ch != '\n' && *ch != '\r' &&
	465	ch != '\t' && ch != '\v') {
	466	printable = false;
	467	goto end;
	468	}
	469	}
	470
	471	end:
	472	return printable;
	473	}
	474
	475	BT_HIDDEN
	476	void bt_common_destroy_lttng_live_url_parts(
	477	struct bt_common_lttng_live_url_parts *parts)
	478	{
	479	if (!parts) {
	480	goto end;
	481	}
	482
	483	if (parts->proto) {
	484	g_string_free(parts->proto, TRUE);
	485	parts->proto = NULL;
	486	}
	487
	488	if (parts->hostname) {
	489	g_string_free(parts->hostname, TRUE);
	490	parts->hostname = NULL;
	491	}
	492
	493	if (parts->target_hostname) {
	494	g_string_free(parts->target_hostname, TRUE);
	495	parts->target_hostname = NULL;
	496	}
	497
	498	if (parts->session_name) {
	499	g_string_free(parts->session_name, TRUE);
	500	parts->session_name = NULL;
	501	}
	502
	503	end:
	504	return;
	505	}
	506
	507	BT_HIDDEN
	508	struct bt_common_lttng_live_url_parts bt_common_parse_lttng_live_url(
	509	const char url, char error_buf, size_t error_buf_size)
	510	{
	511	struct bt_common_lttng_live_url_parts parts;
	512	const char *at = url;
	513	size_t end_pos;
	514
515	assert(url);
516	memset(&parts, 0, sizeof(parts));
517	parts.port = -1;
518
519	/* Protocol */
520	parts.proto = bt_common_string_until(at, "", ":", &end_pos);
521	if (!parts.proto \|\| parts.proto->len == 0) {
522	if (error_buf) {
523	snprintf(error_buf, error_buf_size, "Missing protocol");
524	}
525
526	goto error;
527	}
528
529	if (strcmp(parts.proto->str, "net") == 0) {
530	g_string_assign(parts.proto, "net4");
531	}
532
533	if (strcmp(parts.proto->str, "net4") != 0 &&
534	strcmp(parts.proto->str, "net6") != 0) {
535	if (error_buf) {
536	snprintf(error_buf, error_buf_size,
537	"Unknown protocol: `%s`", parts.proto->str);
538	}
539
540	goto error;
541	}
542
543	if (at[end_pos] != ':') {
544	if (error_buf) {
545	snprintf(error_buf, error_buf_size,
546	"Expecting `:` after `%s`", parts.proto->str);
547	}
548
549	goto error;
550	}
551
552	at += end_pos;
553
554	/* :// */
555	if (strncmp(at, "://", 3) != 0) {
556	if (error_buf) {
557	snprintf(error_buf, error_buf_size,
558	"Expecting `://` after protocol");
559	}
560
561	goto error;
562	}
563
564	at += 3;
565
566	/* Hostname */
567	parts.hostname = bt_common_string_until(at, "", ":/", &end_pos);
568	if (!parts.hostname \|\| parts.hostname->len == 0) {
569	if (error_buf) {
570	snprintf(error_buf, error_buf_size, "Missing hostname");
571	}
572
573	goto error;
574	}
575
576	if (at[end_pos] == ':') {
577	/* Port */
578	GString *port;
579
580	at += end_pos + 1;
581	port = bt_common_string_until(at, "", "/", &end_pos);
582	if (!port \|\| port->len == 0) {
583	if (error_buf) {
584	snprintf(error_buf, error_buf_size, "Missing port");
585	}
586
587	goto error;
588	}
589
590	if (sscanf(port->str, "%d", &parts.port) != 1) {
591	if (error_buf) {
592	snprintf(error_buf, error_buf_size,
593	"Invalid port: `%s`", port->str);
594	}
595
596	g_string_free(port, TRUE);
597	goto error;
598	}
599
600	g_string_free(port, TRUE);
601
602	if (parts.port < 0 \|\| parts.port >= 65536) {
603	if (error_buf) {
604	snprintf(error_buf, error_buf_size,
605	"Invalid port: %d", parts.port);
606	}
607
608	goto error;
609	}
610	}
611
612	if (at[end_pos] == '\0') {
613	goto end;
614	}
615
616	at += end_pos;
617
618	/* /host/ */
619	if (strncmp(at, "/host/", 6) != 0) {
620	if (error_buf) {
621	snprintf(error_buf, error_buf_size,
622	"Expecting `/host/` after hostname or port");
623	}
624
625	goto error;
626	}
627
628	at += 6;
629
630	/* Target hostname */
631	parts.target_hostname = bt_common_string_until(at, "", "/", &end_pos);
632	if (!parts.target_hostname \|\| parts.target_hostname->len == 0) {
633	if (error_buf) {
634	snprintf(error_buf, error_buf_size,
635	"Missing target hostname");
636	}
637
638	goto error;
639	}
640
641	if (at[end_pos] == '\0') {
642	goto end;
643	}
644
645	at += end_pos + 1;
646
647	/* Session name */
648	parts.session_name = bt_common_string_until(at, "", "/", &end_pos);
649	if (!parts.session_name \|\| parts.session_name->len == 0) {
650	if (error_buf) {
651	snprintf(error_buf, error_buf_size,
652	"Missing session name");
653	}
654
655	goto error;
656	}
657
658	if (at[end_pos] == '/') {
659	if (error_buf) {
660	snprintf(error_buf, error_buf_size,
661	"Unexpected `/` after session name (`%s`)",
662	parts.session_name->str);
663	}
664
665	goto error;
666	}
667
668	goto end;
669
670	error:
671	bt_common_destroy_lttng_live_url_parts(&parts);
672
673	end:
674	return parts;
675	}