X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=src%2Fcommon%2Fcommon.c;h=048e3d27ce4001ca6a6c443239106b7d6764095c;hp=3c48e84f31bc6d8b1a6209441b7e4e6817972ef8;hb=0235b0db7de5bcacdb3650c92461f2ce5eb2143d;hpb=3f7d4d90b0456de9d34fac337350818ef06163bd diff --git a/src/common/common.c b/src/common/common.c index 3c48e84f..048e3d27 100644 --- a/src/common/common.c +++ b/src/common/common.c @@ -1,29 +1,14 @@ /* - * Babeltrace common functions + * SPDX-License-Identifier: MIT * * Copyright 2016 Philippe Proulx * - * 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. + * Babeltrace common functions */ +#define BT_LOG_OUTPUT_LEVEL log_level #define BT_LOG_TAG "COMMON" -#include "logging.h" +#include "logging/log.h" #include #include @@ -45,9 +30,10 @@ #ifndef __MINGW32__ #include +#include #endif -#define SYSTEM_PLUGIN_PATH INSTALL_LIBDIR "/babeltrace2/plugins" +#define SYSTEM_PLUGIN_PATH BABELTRACE_PLUGINS_DIR #define HOME_ENV_VAR "HOME" #define HOME_PLUGIN_SUBPATH "/.local/lib/babeltrace2/plugins" @@ -61,6 +47,13 @@ static const char *bt_common_color_code_fg_blue = ""; static const char *bt_common_color_code_fg_magenta = ""; static const char *bt_common_color_code_fg_cyan = ""; static const char *bt_common_color_code_fg_light_gray = ""; +static const char *bt_common_color_code_fg_bright_red = ""; +static const char *bt_common_color_code_fg_bright_green = ""; +static const char *bt_common_color_code_fg_bright_yellow = ""; +static const char *bt_common_color_code_fg_bright_blue = ""; +static const char *bt_common_color_code_fg_bright_magenta = ""; +static const char *bt_common_color_code_fg_bright_cyan = ""; +static const char *bt_common_color_code_fg_bright_light_gray = ""; static const char *bt_common_color_code_bg_default = ""; static const char *bt_common_color_code_bg_red = ""; static const char *bt_common_color_code_bg_green = ""; @@ -70,9 +63,106 @@ static const char *bt_common_color_code_bg_magenta = ""; static const char *bt_common_color_code_bg_cyan = ""; static const char *bt_common_color_code_bg_light_gray = ""; +/* + * A color codes structure always filled with the proper color codes for the + * terminal. + */ +static struct bt_common_color_codes color_codes; + +/* + * A color codes structure always filled with empty strings, for when we want no + * colors. + */ +static struct bt_common_color_codes no_color_codes = { + "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", +}; + static void __attribute__((constructor)) bt_common_color_ctor(void) { + const char *term_env_var; + const char *bright_means_bold_env_var; + bool bright_means_bold = true; + const char *code_fg_bright_red; + const char *code_fg_bright_green; + const char *code_fg_bright_yellow; + const char *code_fg_bright_blue; + const char *code_fg_bright_magenta; + const char *code_fg_bright_cyan; + const char *code_fg_bright_light_gray; + + /* + * Check whether or not the terminal supports having + * bold foreground colors which do _not_ become bright + * colors, that is, the lines + * + * $ echo -e "\033[31mTHIS\n\033[1mTHAT\033[0m" + * + * have the _same_ color, but `THAT` uses a bold font. + * + * This is the case of the kitty terminal emulator. + * + * It's also possible with GNOME Terminal since 3.27.2 + * and xfce4-terminal since 0.8.7 (and GNOME VTE since + * 0.51.2), but it's user-configurable. Since we don't + * have this configuration value here, assume it's not + * the case to support old versions of GNOME Terminal. + * + * Any user can set the + * `BABELTRACE_TERM_COLOR_BRIGHT_MEANS_BOLD` environment + * variable to `0` to use the bright foreground color + * codes instead of making the normal foreground color + * codes bold. + * + * Summary: + * + * With kitty or when + * `BABELTRACE_TERM_COLOR_BRIGHT_MEANS_BOLD` is `0`: + * Output bright colors using dedicated SGR codes + * 90 to 97. + * + * Otherwise: + * Output bright colors with bold + SGR codes 30 to + * 37. + */ + term_env_var = getenv("TERM"); + + if (term_env_var && strcmp(term_env_var, "xterm-kitty") == 0) { + /* + * The kitty terminal emulator supports + * non-bright bold foreground colors. + */ + bright_means_bold = false; + } + + bright_means_bold_env_var = + getenv("BABELTRACE_TERM_COLOR_BRIGHT_MEANS_BOLD"); + + if (bright_means_bold_env_var) { + bright_means_bold = + !(strcmp(bright_means_bold_env_var, "0") == 0); + } + + if (bright_means_bold) { + code_fg_bright_red = BT_COMMON_COLOR_FG_BOLD_RED; + code_fg_bright_green = BT_COMMON_COLOR_FG_BOLD_GREEN; + code_fg_bright_yellow = BT_COMMON_COLOR_FG_BOLD_YELLOW; + code_fg_bright_blue = BT_COMMON_COLOR_FG_BOLD_BLUE; + code_fg_bright_magenta = BT_COMMON_COLOR_FG_BOLD_MAGENTA; + code_fg_bright_cyan = BT_COMMON_COLOR_FG_BOLD_CYAN; + code_fg_bright_light_gray = BT_COMMON_COLOR_FG_BOLD_LIGHT_GRAY; + } else { + code_fg_bright_red = BT_COMMON_COLOR_FG_BRIGHT_RED; + code_fg_bright_green = BT_COMMON_COLOR_FG_BRIGHT_GREEN; + code_fg_bright_yellow = BT_COMMON_COLOR_FG_BRIGHT_YELLOW; + code_fg_bright_blue = BT_COMMON_COLOR_FG_BRIGHT_BLUE; + code_fg_bright_magenta = BT_COMMON_COLOR_FG_BRIGHT_MAGENTA; + code_fg_bright_cyan = BT_COMMON_COLOR_FG_BRIGHT_CYAN; + code_fg_bright_light_gray = BT_COMMON_COLOR_FG_BRIGHT_LIGHT_GRAY; + } + if (bt_common_colors_supported()) { bt_common_color_code_reset = BT_COMMON_COLOR_RESET; bt_common_color_code_bold = BT_COMMON_COLOR_BOLD; @@ -84,6 +174,15 @@ void __attribute__((constructor)) bt_common_color_ctor(void) bt_common_color_code_fg_magenta = BT_COMMON_COLOR_FG_MAGENTA; bt_common_color_code_fg_cyan = BT_COMMON_COLOR_FG_CYAN; bt_common_color_code_fg_light_gray = BT_COMMON_COLOR_FG_LIGHT_GRAY; + + bt_common_color_code_fg_bright_red = code_fg_bright_red; + bt_common_color_code_fg_bright_green = code_fg_bright_green; + bt_common_color_code_fg_bright_yellow = code_fg_bright_yellow; + bt_common_color_code_fg_bright_blue = code_fg_bright_blue; + bt_common_color_code_fg_bright_magenta = code_fg_bright_magenta; + bt_common_color_code_fg_bright_cyan = code_fg_bright_cyan; + bt_common_color_code_fg_bright_light_gray = code_fg_bright_light_gray; + bt_common_color_code_bg_default = BT_COMMON_COLOR_BG_DEFAULT; bt_common_color_code_bg_red = BT_COMMON_COLOR_BG_RED; bt_common_color_code_bg_green = BT_COMMON_COLOR_BG_GREEN; @@ -93,6 +192,32 @@ void __attribute__((constructor)) bt_common_color_ctor(void) bt_common_color_code_bg_cyan = BT_COMMON_COLOR_BG_CYAN; bt_common_color_code_bg_light_gray = BT_COMMON_COLOR_BG_LIGHT_GRAY; } + + color_codes.reset = BT_COMMON_COLOR_RESET; + color_codes.bold = BT_COMMON_COLOR_BOLD; + color_codes.fg_default = BT_COMMON_COLOR_FG_DEFAULT; + color_codes.fg_red = BT_COMMON_COLOR_FG_RED; + color_codes.fg_green = BT_COMMON_COLOR_FG_GREEN; + color_codes.fg_yellow = BT_COMMON_COLOR_FG_YELLOW; + color_codes.fg_blue = BT_COMMON_COLOR_FG_BLUE; + color_codes.fg_magenta = BT_COMMON_COLOR_FG_MAGENTA; + color_codes.fg_cyan = BT_COMMON_COLOR_FG_CYAN; + color_codes.fg_light_gray = BT_COMMON_COLOR_FG_LIGHT_GRAY; + color_codes.fg_bright_red = code_fg_bright_red; + color_codes.fg_bright_green = code_fg_bright_green; + color_codes.fg_bright_yellow = code_fg_bright_yellow; + color_codes.fg_bright_blue = code_fg_bright_blue; + color_codes.fg_bright_magenta = code_fg_bright_magenta; + color_codes.fg_bright_cyan = code_fg_bright_cyan; + color_codes.fg_bright_light_gray = code_fg_bright_light_gray; + color_codes.bg_default = BT_COMMON_COLOR_BG_DEFAULT; + color_codes.bg_red = BT_COMMON_COLOR_BG_RED; + color_codes.bg_green = BT_COMMON_COLOR_BG_GREEN; + color_codes.bg_yellow = BT_COMMON_COLOR_BG_YELLOW; + color_codes.bg_blue = BT_COMMON_COLOR_BG_BLUE; + color_codes.bg_magenta = BT_COMMON_COLOR_BG_MAGENTA; + color_codes.bg_cyan = BT_COMMON_COLOR_BG_CYAN; + color_codes.bg_light_gray = BT_COMMON_COLOR_BG_LIGHT_GRAY; } BT_HIDDEN @@ -115,8 +240,15 @@ bool bt_common_is_setuid_setgid(void) } #endif /* __MINGW32__ */ +#ifdef __MINGW32__ static -char *bt_secure_getenv(const char *name) +const char *bt_get_home_dir(int log_level) +{ + return g_get_home_dir(); +} +#else /* __MINGW32__ */ +static +char *bt_secure_getenv(const char *name, int log_level) { if (bt_common_is_setuid_setgid()) { BT_LOGD("Disregarding environment variable for setuid/setgid binary: " @@ -126,20 +258,13 @@ char *bt_secure_getenv(const char *name) return getenv(name); } -#ifdef __MINGW32__ -static -const char *bt_get_home_dir(void) -{ - return g_get_home_dir(); -} -#else /* __MINGW32__ */ static -const char *bt_get_home_dir(void) +const char *bt_get_home_dir(int log_level) { char *val = NULL; struct passwd *pwd; - val = bt_secure_getenv(HOME_ENV_VAR); + val = bt_secure_getenv(HOME_ENV_VAR, log_level); if (val) { goto end; } @@ -155,13 +280,13 @@ end: #endif /* __MINGW32__ */ BT_HIDDEN -char *bt_common_get_home_plugin_path(void) +char *bt_common_get_home_plugin_path(int log_level) { char *path = NULL; const char *home_dir; size_t length; - home_dir = bt_get_home_dir(); + home_dir = bt_get_home_dir(log_level); if (!home_dir) { goto end; } @@ -386,6 +511,48 @@ const char *bt_common_color_fg_light_gray(void) return bt_common_color_code_fg_light_gray; } +BT_HIDDEN +const char *bt_common_color_fg_bright_red(void) +{ + return bt_common_color_code_fg_bright_red; +} + +BT_HIDDEN +const char *bt_common_color_fg_bright_green(void) +{ + return bt_common_color_code_fg_bright_green; +} + +BT_HIDDEN +const char *bt_common_color_fg_bright_yellow(void) +{ + return bt_common_color_code_fg_bright_yellow; +} + +BT_HIDDEN +const char *bt_common_color_fg_bright_blue(void) +{ + return bt_common_color_code_fg_bright_blue; +} + +BT_HIDDEN +const char *bt_common_color_fg_bright_magenta(void) +{ + return bt_common_color_code_fg_bright_magenta; +} + +BT_HIDDEN +const char *bt_common_color_fg_bright_cyan(void) +{ + return bt_common_color_code_fg_bright_cyan; +} + +BT_HIDDEN +const char *bt_common_color_fg_bright_light_gray(void) +{ + return bt_common_color_code_fg_bright_light_gray; +} + BT_HIDDEN const char *bt_common_color_bg_default(void) { @@ -434,6 +601,25 @@ const char *bt_common_color_bg_light_gray(void) return bt_common_color_code_bg_light_gray; } +BT_HIDDEN +void bt_common_color_get_codes(struct bt_common_color_codes *codes, + enum bt_common_color_when use_colors) +{ + if (use_colors == BT_COMMON_COLOR_WHEN_ALWAYS) { + *codes = color_codes; + } else if (use_colors == BT_COMMON_COLOR_WHEN_NEVER) { + *codes = no_color_codes; + } else { + BT_ASSERT(use_colors == BT_COMMON_COLOR_WHEN_AUTO); + + if (bt_common_colors_supported()) { + *codes = color_codes; + } else { + *codes = no_color_codes; + } + } +} + BT_HIDDEN GString *bt_common_string_until(const char *input, const char *escapable_chars, const char *end_chars, size_t *end_pos) @@ -510,6 +696,7 @@ set_end_pos: error: if (output) { g_string_free(output, TRUE); + output = NULL; } end: @@ -577,10 +764,10 @@ bool bt_common_string_is_printable(const char *input) { const char *ch; bool printable = true; - BT_ASSERT(input); + BT_ASSERT_DBG(input); for (ch = input; *ch != '\0'; ch++) { - if (!isprint(*ch) && *ch != '\n' && *ch != '\r' && + if (!isprint((unsigned char) *ch) && *ch != '\n' && *ch != '\r' && *ch != '\t' && *ch != '\v') { printable = false; goto end; @@ -670,7 +857,7 @@ struct bt_common_lttng_live_url_parts bt_common_parse_lttng_live_url( at += end_pos; - /* :// */ + /* `://` */ if (strncmp(at, "://", 3) != 0) { if (error_buf) { snprintf(error_buf, error_buf_size, @@ -680,6 +867,7 @@ struct bt_common_lttng_live_url_parts bt_common_parse_lttng_live_url( goto error; } + /* Skip `://` */ at += 3; /* Hostname */ @@ -729,12 +917,13 @@ struct bt_common_lttng_live_url_parts bt_common_parse_lttng_live_url( } if (at[end_pos] == '\0') { + /* Relay daemon hostname and ports provided only */ goto end; } at += end_pos; - /* /host/ */ + /* `/host/` */ if (strncmp(at, "/host/", 6) != 0) { if (error_buf) { snprintf(error_buf, error_buf_size, @@ -758,9 +947,16 @@ struct bt_common_lttng_live_url_parts bt_common_parse_lttng_live_url( } if (at[end_pos] == '\0') { - goto end; + if (error_buf) { + snprintf(error_buf, error_buf_size, + "Missing `/` after target hostname (`%s`)", + parts.target_hostname->str); + } + + goto error; } + /* Skip `/` */ at += end_pos + 1; /* Session name */ @@ -1087,6 +1283,36 @@ end_of_pattern: return p[-1] == '*' && at_end_of_pattern(p, pattern, pattern_len); } +#ifdef __MINGW32__ +BT_HIDDEN +GString *bt_common_normalize_path(const char *path, const char *wd) +{ + char *tmp; + GString *norm_path = NULL; + + BT_ASSERT(path); + + tmp = _fullpath(NULL, path, PATH_MAX); + if (!tmp) { + goto error; + } + + norm_path = g_string_new(tmp); + if (!norm_path) { + goto error; + } + + goto end; +error: + if (norm_path) { + g_string_free(norm_path, TRUE); + norm_path = NULL; + } +end: + free(tmp); + return norm_path; +} +#else static void append_path_parts(const char *path, GPtrArray *parts) { @@ -1120,38 +1346,6 @@ void destroy_gstring(void *gstring) (void) g_string_free(gstring, TRUE); } -#ifdef __MINGW32__ -BT_HIDDEN -GString *bt_common_normalize_path(const char *path, const char *wd) -{ - char *tmp; - GString *norm_path = NULL; - - BT_ASSERT(path); - - tmp = _fullpath(NULL, path, PATH_MAX); - if (!tmp) { - goto error; - } - - norm_path = g_string_new(tmp); - if (!norm_path) { - goto error; - } - - goto end; -error: - if (norm_path) { - g_string_free(norm_path, TRUE); - norm_path = NULL; - } -end: - if (tmp) { - free(tmp); - } - return norm_path; -} -#else BT_HIDDEN GString *bt_common_normalize_path(const char *path, const char *wd) { @@ -1238,7 +1432,7 @@ end: #endif BT_HIDDEN -size_t bt_common_get_page_size(void) +size_t bt_common_get_page_size(int log_level) { int page_size; @@ -1246,7 +1440,7 @@ size_t bt_common_get_page_size(void) if (page_size < 0) { BT_LOGF("Cannot get system's page size: ret=%d", page_size); - abort(); + bt_common_abort(); } return page_size; @@ -1261,7 +1455,7 @@ size_t bt_common_get_page_size(void) strncpy(_tmp_fmt, *out_fmt_ch, _tmp_fmt_size); \ _tmp_fmt[_tmp_fmt_size] = '\0'; \ _count = snprintf(*buf_ch, _size, _tmp_fmt, __VA_ARGS__); \ - BT_ASSERT(_count >= 0); \ + BT_ASSERT_DBG(_count >= 0); \ *buf_ch += MIN(_count, _size); \ } while (0) @@ -1403,13 +1597,11 @@ static inline void handle_conversion_specifier_std(char *buf, char **buf_ch, switch (length_mod) { case LENGTH_MOD_NONE: - BUF_STD_APPEND_SINGLE_ARG(int); - break; case LENGTH_MOD_LOW_L: - BUF_STD_APPEND_SINGLE_ARG(wint_t); + BUF_STD_APPEND_SINGLE_ARG(int); break; default: - abort(); + bt_common_abort(); } break; } @@ -1424,7 +1616,7 @@ static inline void handle_conversion_specifier_std(char *buf, char **buf_ch, BUF_STD_APPEND_SINGLE_ARG(wchar_t *); break; default: - abort(); + bt_common_abort(); } break; case 'd': @@ -1447,7 +1639,7 @@ static inline void handle_conversion_specifier_std(char *buf, char **buf_ch, BUF_STD_APPEND_SINGLE_ARG(size_t); break; default: - abort(); + bt_common_abort(); } break; case 'o': @@ -1472,7 +1664,7 @@ static inline void handle_conversion_specifier_std(char *buf, char **buf_ch, BUF_STD_APPEND_SINGLE_ARG(size_t); break; default: - abort(); + bt_common_abort(); } break; case 'f': @@ -1491,7 +1683,7 @@ static inline void handle_conversion_specifier_std(char *buf, char **buf_ch, BUF_STD_APPEND_SINGLE_ARG(long double); break; default: - abort(); + bt_common_abort(); } break; case 'p': @@ -1500,11 +1692,11 @@ static inline void handle_conversion_specifier_std(char *buf, char **buf_ch, if (length_mod == LENGTH_MOD_NONE) { BUF_STD_APPEND_SINGLE_ARG(void *); } else { - abort(); + bt_common_abort(); } break; default: - abort(); + bt_common_abort(); } update_rw_fmt: @@ -1520,13 +1712,13 @@ void bt_common_custom_vsnprintf(char *buf, size_t buf_size, const char *fmt_ch = fmt; char *buf_ch = buf; - BT_ASSERT(buf); - BT_ASSERT(fmt); + BT_ASSERT_DBG(buf); + BT_ASSERT_DBG(fmt); while (*fmt_ch != '\0') { switch (*fmt_ch) { case '%': - BT_ASSERT(fmt_ch[1] != '\0'); + BT_ASSERT_DBG(fmt_ch[1] != '\0'); if (fmt_ch[1] == intro) { handle_specifier(priv_data, &buf_ch, @@ -1578,12 +1770,12 @@ void bt_common_sep_digits(char *str, unsigned int digits_per_group, char sep) uint64_t sep_count; uint64_t new_len; - BT_ASSERT(digits_per_group > 0); - BT_ASSERT(sep != '\0'); + BT_ASSERT_DBG(digits_per_group > 0); + BT_ASSERT_DBG(sep != '\0'); /* Compute new length of `str` */ orig_len = strlen(str); - BT_ASSERT(orig_len > 0); + BT_ASSERT_DBG(orig_len > 0); sep_count = (orig_len - 1) / digits_per_group; new_len = strlen(str) + sep_count; @@ -1670,3 +1862,247 @@ void bt_common_sep_digits(char *str, unsigned int digits_per_group, char sep) i++; } } + +BT_HIDDEN +GString *bt_common_fold(const char *str, unsigned int total_length, + unsigned int indent) +{ + const unsigned int content_length = total_length - indent; + GString *folded = g_string_new(NULL); + GString *tmp_line = g_string_new(NULL); + gchar **lines = NULL; + gchar **line_words = NULL; + gchar * const *line; + unsigned int i; + + BT_ASSERT_DBG(str); + BT_ASSERT_DBG(indent < total_length); + BT_ASSERT_DBG(tmp_line); + BT_ASSERT_DBG(folded); + + if (strlen(str) == 0) { + /* Empty input string: empty output string */ + goto end; + } + + /* Split lines */ + lines = g_strsplit(str, "\n", 0); + BT_ASSERT_DBG(lines); + + /* For each source line */ + for (line = lines; *line; line++) { + gchar * const *word; + + /* + * Append empty line without indenting if source line is + * empty. + */ + if (strlen(*line) == 0) { + g_string_append_c(folded, '\n'); + continue; + } + + /* Split words */ + line_words = g_strsplit(*line, " ", 0); + BT_ASSERT_DBG(line_words); + + /* + * Indent for first line (we know there's at least one + * word at this point). + */ + for (i = 0; i < indent; i++) { + g_string_append_c(folded, ' '); + } + + /* Append words, folding when necessary */ + g_string_assign(tmp_line, ""); + + for (word = line_words; *word; word++) { + /* + * `tmp_line->len > 0` is in the condition so + * that words that are larger than + * `content_length` are at least written on + * their own line. + * + * `tmp_line->len - 1` because the temporary + * line always contains a trailing space which + * won't be part of the line if we fold. + */ + if (tmp_line->len > 0 && + tmp_line->len - 1 + strlen(*word) >= content_length) { + /* Fold (without trailing space) */ + g_string_append_len(folded, + tmp_line->str, tmp_line->len - 1); + g_string_append_c(folded, '\n'); + + /* Indent new line */ + for (i = 0; i < indent; i++) { + g_string_append_c(folded, ' '); + } + + g_string_assign(tmp_line, ""); + } + + /* Append current word and space to temporary line */ + g_string_append(tmp_line, *word); + g_string_append_c(tmp_line, ' '); + } + + /* Append last line if any, without trailing space */ + if (tmp_line->len > 0) { + g_string_append_len(folded, tmp_line->str, + tmp_line->len - 1); + } + + /* Append source newline */ + g_string_append_c(folded, '\n'); + + /* Free array of this line's words */ + g_strfreev(line_words); + line_words = NULL; + } + + /* Remove trailing newline if any */ + if (folded->str[folded->len - 1] == '\n') { + g_string_truncate(folded, folded->len - 1); + } + +end: + if (lines) { + g_strfreev(lines); + } + + BT_ASSERT_DBG(!line_words); + + if (tmp_line) { + g_string_free(tmp_line, TRUE); + } + + return folded; +} + +#ifdef __MINGW32__ +BT_HIDDEN +int bt_common_get_term_size(unsigned int *width, unsigned int *height) +{ + /* Not supported on Windows yet */ + return -1; +} +#else /* __MINGW32__ */ +BT_HIDDEN +int bt_common_get_term_size(unsigned int *width, unsigned int *height) +{ + int ret = 0; + struct winsize winsize; + + if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &winsize) < 0) { + ret = -1; + goto end; + } + + if (width) { + *width = (unsigned int) winsize.ws_col; + } + + if (height) { + *height = (unsigned int) winsize.ws_row; + } + +end: + return ret; +} +#endif /* __MINGW32__ */ + +BT_HIDDEN +int bt_common_g_string_append_printf(GString *str, const char *fmt, ...) +{ + va_list ap; + gsize len, allocated_len, available_len; + int print_len; + + /* str->len excludes \0. */ + len = str->len; + /* Explicitly exclude \0. */ + allocated_len = str->allocated_len - 1; + available_len = allocated_len - len; + + str->len = allocated_len; + va_start(ap, fmt); + print_len = vsnprintf(str->str + len, available_len + 1, fmt, ap); + va_end(ap); + if (print_len < 0) { + return print_len; + } + if (G_UNLIKELY(available_len < print_len)) { + /* Resize. */ + g_string_set_size(str, len + print_len); + va_start(ap, fmt); + print_len = vsprintf(str->str + len, fmt, ap); + va_end(ap); + } else { + str->len = len + print_len; + } + return print_len; +} + +BT_HIDDEN +int bt_common_append_file_content_to_g_string(GString *str, FILE *fp) +{ + const size_t chunk_size = 4096; + int ret = 0; + char *buf; + size_t read_len; + gsize orig_len = str->len; + + BT_ASSERT(str); + BT_ASSERT(fp); + buf = g_malloc(chunk_size); + if (!buf) { + ret = -1; + goto end; + } + + while (true) { + if (ferror(fp)) { + ret = -1; + goto end; + } + + if (feof(fp)) { + break; + } + + read_len = fread(buf, 1, chunk_size, fp); + g_string_append_len(str, buf, read_len); + } + +end: + if (ret) { + /* Remove what was appended */ + g_string_truncate(str, orig_len); + } + + g_free(buf); + return ret; +} + +BT_HIDDEN +void bt_common_abort(void) +{ + static const char * const exec_on_abort_env_name = + "BABELTRACE_EXEC_ON_ABORT"; + const char *env_exec_on_abort; + + env_exec_on_abort = getenv(exec_on_abort_env_name); + if (env_exec_on_abort) { + if (bt_common_is_setuid_setgid()) { + goto do_abort; + } + + (void) g_spawn_command_line_sync(env_exec_on_abort, + NULL, NULL, NULL, NULL); + } + +do_abort: + abort(); +}