1314 lines
29 KiB
C
1314 lines
29 KiB
C
/*
|
|
* Copyright (c) 2013, 2015, 2016, 2022, 2023 Jonas 'Sortie' Termansen.
|
|
*
|
|
* 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.
|
|
*
|
|
* util.h
|
|
* Shared Utility functions for Tix.
|
|
*/
|
|
|
|
#ifndef UTIL_H
|
|
#define UTIL_H
|
|
|
|
#define DEFAULT_GENERATION "3"
|
|
|
|
extern char** environ;
|
|
|
|
bool does_path_contain_dotdot(const char* path)
|
|
{
|
|
size_t index = 0;
|
|
while ( path[index] )
|
|
{
|
|
if ( path[index] == '.' && path[index+1] == '.' )
|
|
{
|
|
index += 2;
|
|
if ( !path[index] || path[index] == '/' )
|
|
return true;
|
|
}
|
|
while ( path[index] && path[index] != '/' )
|
|
index++;
|
|
while ( path[index] == '/' )
|
|
index++;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool parse_boolean(const char* str)
|
|
{
|
|
return strcmp(str, "true") == 0;
|
|
}
|
|
|
|
char* strdup_null(const char* src)
|
|
{
|
|
return src ? strdup(src) : NULL;
|
|
}
|
|
|
|
char* strdup_null_if_content(const char* src)
|
|
{
|
|
if ( src && !src[0] )
|
|
return NULL;
|
|
return strdup_null(src);
|
|
}
|
|
|
|
const char* non_modify_basename(const char* path)
|
|
{
|
|
const char* last_slash = (char*) strrchr((char*) path, '/');
|
|
if ( !last_slash )
|
|
return path;
|
|
return last_slash + 1;
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
char** strings;
|
|
size_t length;
|
|
size_t capacity;
|
|
} string_array_t;
|
|
|
|
string_array_t string_array_make(void)
|
|
{
|
|
string_array_t sa;
|
|
sa.strings = NULL;
|
|
sa.length = sa.capacity = 0;
|
|
return sa;
|
|
}
|
|
|
|
void string_array_reset(string_array_t* sa)
|
|
{
|
|
for ( size_t i = 0; i < sa->length; i++ )
|
|
free(sa->strings[i]);
|
|
free(sa->strings);
|
|
*sa = string_array_make();
|
|
}
|
|
|
|
bool string_array_append(string_array_t* sa, const char* str)
|
|
{
|
|
if ( sa->length == sa->capacity )
|
|
{
|
|
size_t new_capacity = sa->capacity ? sa->capacity * 2 : 8;
|
|
size_t new_size = sizeof(char*) * new_capacity;
|
|
char** new_strings = (char**) realloc(sa->strings, new_size);
|
|
if ( !new_strings )
|
|
return false;
|
|
sa->strings = new_strings;
|
|
sa->capacity = new_capacity;
|
|
}
|
|
char* copy = strdup_null(str);
|
|
if ( str && !copy )
|
|
return false;
|
|
sa->strings[sa->length++] = copy;
|
|
return true;
|
|
}
|
|
|
|
bool string_array_append_token_string(string_array_t* sa, const char* str)
|
|
{
|
|
while ( *str )
|
|
{
|
|
if ( isspace((unsigned char) *str) )
|
|
{
|
|
str++;
|
|
continue;
|
|
}
|
|
|
|
size_t input_length = 0;
|
|
size_t output_length = 0;
|
|
bool quoted = false;
|
|
bool escaped = false;
|
|
while ( str[input_length] &&
|
|
(escaped || quoted || !isspace((unsigned char) str[input_length])) )
|
|
{
|
|
if ( !escaped && str[input_length] == '\\' )
|
|
escaped = true;
|
|
else if ( !escaped && str[input_length] == '"' )
|
|
quoted = !quoted;
|
|
else
|
|
escaped = false, output_length++;
|
|
input_length++;
|
|
}
|
|
|
|
if ( quoted || escaped )
|
|
return false;
|
|
|
|
char* output = (char*) malloc(sizeof(char) * (output_length+1));
|
|
if ( !output )
|
|
return false;
|
|
|
|
input_length = 0;
|
|
output_length = 0;
|
|
quoted = false;
|
|
escaped = false;
|
|
while ( str[input_length] &&
|
|
(escaped || quoted || !isspace((unsigned char) str[input_length])) )
|
|
{
|
|
if ( !escaped && str[input_length] == '\\' )
|
|
escaped = true;
|
|
else if ( !escaped && str[input_length] == '"' )
|
|
quoted = !quoted;
|
|
else if ( escaped && str[input_length] == 'a' )
|
|
escaped = false, output[output_length++] = '\a';
|
|
else if ( escaped && str[input_length] == 'b' )
|
|
escaped = false, output[output_length++] = '\b';
|
|
else if ( escaped && str[input_length] == 'e' )
|
|
escaped = false, output[output_length++] = '\e';
|
|
else if ( escaped && str[input_length] == 'f' )
|
|
escaped = false, output[output_length++] = '\f';
|
|
else if ( escaped && str[input_length] == 'n' )
|
|
escaped = false, output[output_length++] = '\n';
|
|
else if ( escaped && str[input_length] == 'r' )
|
|
escaped = false, output[output_length++] = '\r';
|
|
else if ( escaped && str[input_length] == 't' )
|
|
escaped = false, output[output_length++] = '\t';
|
|
else if ( escaped && str[input_length] == 'v' )
|
|
escaped = false, output[output_length++] = '\v';
|
|
else
|
|
escaped = false, output[output_length++] = str[input_length];
|
|
input_length++;
|
|
}
|
|
|
|
output[output_length] = '\0';
|
|
|
|
if ( !string_array_append(sa, output) )
|
|
{
|
|
free(output);
|
|
return false;
|
|
}
|
|
|
|
free(output);
|
|
|
|
str += input_length;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool is_token_string_special_character(char c)
|
|
{
|
|
return isspace((unsigned char) c) || c == '"' || c == '\\';
|
|
}
|
|
|
|
char* token_string_of_string_array(const string_array_t* sa)
|
|
{
|
|
size_t result_length = 0;
|
|
|
|
for ( size_t i = 0; i < sa->length; i++ )
|
|
{
|
|
if ( i )
|
|
result_length++;
|
|
|
|
for ( size_t n = 0; sa->strings[i][n]; n++ )
|
|
{
|
|
if ( is_token_string_special_character(sa->strings[i][n]) )
|
|
result_length++;
|
|
result_length++;
|
|
}
|
|
}
|
|
|
|
char* result = (char*) malloc(sizeof(char) * (result_length + 1));
|
|
if ( !result )
|
|
return NULL;
|
|
|
|
result_length = 0;
|
|
|
|
for ( size_t i = 0; i < sa->length; i++ )
|
|
{
|
|
if ( i )
|
|
result[result_length++] = ' ';
|
|
|
|
for ( size_t n = 0; sa->strings[i][n]; n++ )
|
|
{
|
|
if ( is_token_string_special_character(sa->strings[i][n]) )
|
|
result[result_length++] = '\\';
|
|
result[result_length++] = sa->strings[i][n];
|
|
}
|
|
}
|
|
|
|
result[result_length] = '\0';
|
|
|
|
return result;
|
|
}
|
|
|
|
void string_array_append_file(string_array_t* sa, FILE* fp)
|
|
{
|
|
char* entry = NULL;
|
|
size_t entry_size = 0;
|
|
ssize_t entry_length;
|
|
while ( 0 < (entry_length = getline(&entry, &entry_size, fp)) )
|
|
{
|
|
if ( entry[entry_length-1] == '\n' )
|
|
entry[--entry_length] = '\0';
|
|
string_array_append(sa, entry);
|
|
}
|
|
free(entry);
|
|
assert(!ferror(fp));
|
|
}
|
|
|
|
bool string_array_append_file_path(string_array_t* sa, const char* path)
|
|
{
|
|
FILE* fp = fopen(path, "r");
|
|
if ( !fp )
|
|
return false;
|
|
string_array_append_file(sa, fp);
|
|
fclose(fp);
|
|
return true;
|
|
}
|
|
|
|
size_t string_array_find(string_array_t* sa, const char* str)
|
|
{
|
|
for ( size_t i = 0; i < sa->length; i++ )
|
|
if ( !strcmp(sa->strings[i], str) )
|
|
return i;
|
|
return SIZE_MAX;
|
|
}
|
|
|
|
bool string_array_contains(string_array_t* sa, const char* str)
|
|
{
|
|
return string_array_find(sa, str) != SIZE_MAX;
|
|
}
|
|
|
|
size_t dictionary_lookup_index(string_array_t* sa, const char* key)
|
|
{
|
|
size_t keylen = strlen(key);
|
|
for ( size_t i = 0; i < sa->length; i++ )
|
|
{
|
|
const char* entry = sa->strings[i];
|
|
if ( strncmp(key, entry, keylen) != 0 )
|
|
continue;
|
|
if ( entry[keylen] != '=' )
|
|
continue;
|
|
return i;
|
|
}
|
|
return SIZE_MAX;
|
|
}
|
|
|
|
const char* dictionary_get_entry(string_array_t* sa, const char* key)
|
|
{
|
|
size_t index = dictionary_lookup_index(sa, key);
|
|
if ( index == SIZE_MAX )
|
|
return NULL;
|
|
return sa->strings[index];
|
|
}
|
|
|
|
const char* dictionary_get_def(string_array_t* sa, const char* key,
|
|
const char* def)
|
|
{
|
|
size_t keylen = strlen(key);
|
|
const char* entry = dictionary_get_entry(sa, key);
|
|
return entry ? entry + keylen + 1 : def;
|
|
}
|
|
|
|
const char* dictionary_get(string_array_t* sa, const char* key)
|
|
{
|
|
return dictionary_get_def(sa, key, NULL);
|
|
}
|
|
|
|
void dictionary_normalize_entry(char* entry)
|
|
{
|
|
bool key = true;
|
|
size_t input_off, output_off;
|
|
for ( input_off = output_off = 0; entry[input_off]; input_off++ )
|
|
{
|
|
if ( key && isspace((unsigned char) entry[input_off]) )
|
|
continue;
|
|
if ( key && (entry[input_off] == '=' || entry[input_off] == '#') )
|
|
key = false;
|
|
entry[output_off++] = entry[input_off];
|
|
}
|
|
entry[output_off] = '\0';
|
|
}
|
|
|
|
bool is_identifier_char(char c)
|
|
{
|
|
return ('a' <= c && c <= 'z') ||
|
|
('A' <= c && c <= 'Z') ||
|
|
('0' <= c && c <= '9') ||
|
|
c == '_';
|
|
}
|
|
|
|
// 0 on success, -1 on error, -2 on syntax error.
|
|
int variables_parse_fp(string_array_t* sa, const char* line, FILE* fp)
|
|
{
|
|
size_t i = 0;
|
|
while ( isspace((unsigned char) line[i]) )
|
|
i++;
|
|
if ( !line[i] || line[i] == '#' )
|
|
return 0;
|
|
if ( line[i] == '=' )
|
|
return -2;
|
|
size_t keylen = 0;
|
|
while ( line[i + keylen] &&
|
|
line[i + keylen] != '=' &&
|
|
line[i + keylen] != '#' &&
|
|
!isspace((unsigned char) line[i + keylen]) )
|
|
{
|
|
if ( fputc((unsigned char) line[i + keylen++], fp) == EOF )
|
|
return -1;
|
|
}
|
|
i += keylen;
|
|
if ( line[i++] != '=' )
|
|
return -2;
|
|
fputc('=', fp);
|
|
bool escaped = false;
|
|
bool singly_quote = false;
|
|
bool doubly_quote = false;
|
|
while ( true )
|
|
{
|
|
unsigned char c = (unsigned char) line[i++];
|
|
if ( !c )
|
|
{
|
|
i--;
|
|
break;
|
|
}
|
|
else if ( !escaped && !singly_quote && c == '\\' )
|
|
escaped = true;
|
|
else if ( !escaped && !doubly_quote && c == '\'' )
|
|
singly_quote = !singly_quote;
|
|
else if ( !escaped && !singly_quote && c == '"' )
|
|
doubly_quote = !doubly_quote;
|
|
else if ( !escaped && !singly_quote && c == '$' &&
|
|
(is_identifier_char(line[i]) || line[i] == '{') )
|
|
{
|
|
size_t start = i;
|
|
size_t keylen = 0;
|
|
if ( line[start] == '{' )
|
|
{
|
|
start++;
|
|
while ( line[start + keylen] && line[start + keylen] != '}' )
|
|
keylen++;
|
|
if ( !keylen )
|
|
return -2;
|
|
if ( line[start + keylen] != '}' )
|
|
return -2;
|
|
i = start + keylen + 1;
|
|
}
|
|
else
|
|
{
|
|
while ( line[start + keylen] &&
|
|
is_identifier_char(line[start + keylen]) )
|
|
keylen++;
|
|
i = start + keylen;
|
|
}
|
|
const char* key = line + start;
|
|
const char* value = NULL;
|
|
for ( size_t n = 0; !value && n < sa->length; n++ )
|
|
{
|
|
const char* entry = sa->strings[n];
|
|
if ( strncmp(key, entry, keylen) != 0 )
|
|
continue;
|
|
if ( entry[keylen] != '=' )
|
|
continue;
|
|
value = entry + keylen + 1;
|
|
}
|
|
if ( !value )
|
|
return -2;
|
|
size_t length = strlen(value);
|
|
if ( fwrite(value, 1, length, fp) != length )
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
if ( !escaped && !singly_quote && !doubly_quote && isspace(c) )
|
|
{
|
|
i--;
|
|
break;
|
|
}
|
|
if ( fputc(c, fp) == EOF )
|
|
return -1;
|
|
escaped = false;
|
|
}
|
|
}
|
|
while ( isspace((unsigned char) line[i]) )
|
|
i++;
|
|
if ( line[i] && line[i] != '#' )
|
|
return -2;
|
|
return 1;
|
|
}
|
|
|
|
int variables_parse(string_array_t* sa, const char* line, char** out_ptr)
|
|
{
|
|
size_t out_size;
|
|
FILE* fp = open_memstream(out_ptr, &out_size);
|
|
if ( !fp )
|
|
return -1;
|
|
int result = variables_parse_fp(sa, line, fp);
|
|
if ( fclose(fp) == EOF )
|
|
result = -1;
|
|
if ( result <= 0 )
|
|
free(*out_ptr);
|
|
return result;
|
|
}
|
|
|
|
int variables_append_file(string_array_t* sa, FILE* fp)
|
|
{
|
|
char* line = NULL;
|
|
size_t line_size = 0;
|
|
ssize_t line_length;
|
|
while ( 0 < (line_length = getline(&line, &line_size, fp)) )
|
|
{
|
|
if ( line[line_length-1] == '\n' )
|
|
line[--line_length] = '\0';
|
|
char* entry;
|
|
int result = variables_parse(sa, line, &entry);
|
|
if ( result == 0 )
|
|
continue;
|
|
if ( result < 0 )
|
|
{
|
|
free(line);
|
|
return result;
|
|
}
|
|
if ( !string_array_append(sa, entry) )
|
|
{
|
|
free(entry);
|
|
free(line);
|
|
return -1;
|
|
}
|
|
free(entry);
|
|
}
|
|
free(line);
|
|
if ( ferror(fp) )
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
int variables_append_file_path(string_array_t* sa, const char* path)
|
|
{
|
|
FILE* fp = fopen(path, "r");
|
|
if ( !fp )
|
|
return -1;
|
|
int result = variables_append_file(sa, fp);
|
|
fclose(fp);
|
|
return result;
|
|
}
|
|
|
|
__attribute__((format(printf, 1, 2)))
|
|
char* print_string(const char* format, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, format);
|
|
char* ret;
|
|
if ( vasprintf(&ret, format, ap) < 0 )
|
|
ret = NULL;
|
|
va_end(ap);
|
|
return ret;
|
|
}
|
|
|
|
char* read_single_line(FILE* fp)
|
|
{
|
|
char* ret = NULL;
|
|
size_t ret_size = 0;
|
|
ssize_t ret_len = getline(&ret, &ret_size, fp);
|
|
if ( ret_len < 0 )
|
|
{
|
|
free(ret);
|
|
return NULL;
|
|
}
|
|
if ( ret[ret_len-1] == '\n' )
|
|
ret[--ret_len] = '\0';
|
|
return ret;
|
|
}
|
|
|
|
pid_t fork_or_death(void)
|
|
{
|
|
pid_t child_pid = fork();
|
|
if ( child_pid < 0 )
|
|
err(1, "fork");
|
|
return child_pid;
|
|
}
|
|
|
|
void waitpid_or_death_def(pid_t child_pid, bool die_on_error)
|
|
{
|
|
int status;
|
|
waitpid(child_pid, &status, 0);
|
|
if ( die_on_error )
|
|
{
|
|
if ( WIFEXITED(status) && WEXITSTATUS(status) != 0 )
|
|
exit(WEXITSTATUS(status));
|
|
if ( WIFSIGNALED(status) )
|
|
errx(128 + WTERMSIG(status), "child with pid %ji was killed by "
|
|
"signal %i (%s).", (intmax_t) child_pid, WTERMSIG(status),
|
|
strsignal(WTERMSIG(status)));
|
|
}
|
|
}
|
|
|
|
void waitpid_or_death(pid_t child_pid)
|
|
{
|
|
return waitpid_or_death_def(child_pid, true);
|
|
}
|
|
|
|
bool fork_and_wait_or_death_def(bool die_on_error)
|
|
{
|
|
pid_t child_pid = fork_or_death();
|
|
if ( !child_pid )
|
|
return true;
|
|
waitpid_or_death_def(child_pid, die_on_error);
|
|
return false;
|
|
}
|
|
|
|
bool fork_and_wait_or_death(void)
|
|
{
|
|
return fork_and_wait_or_death_def(true);
|
|
}
|
|
|
|
const char* getenv_def(const char* var, const char* def)
|
|
{
|
|
const char* ret = getenv(var);
|
|
return ret ? ret : def;
|
|
}
|
|
|
|
int mkdir_p(const char* path, mode_t mode)
|
|
{
|
|
int saved_errno = errno;
|
|
if ( !mkdir(path, mode) )
|
|
return 0;
|
|
if ( errno == ENOENT )
|
|
{
|
|
char* prev = strdup(path);
|
|
if ( !prev )
|
|
return -1;
|
|
int status = mkdir_p(dirname(prev), mode | 0500);
|
|
free(prev);
|
|
if ( status < 0 )
|
|
return -1;
|
|
errno = saved_errno;
|
|
if ( !mkdir(path, mode) )
|
|
return 0;
|
|
}
|
|
if ( errno == EEXIST )
|
|
return errno = saved_errno, 0;
|
|
return -1;
|
|
}
|
|
|
|
static void compact_arguments(int* argc, char*** argv)
|
|
{
|
|
for ( int i = 0; i < *argc; i++ )
|
|
{
|
|
while ( i < *argc && !(*argv)[i] )
|
|
{
|
|
for ( int n = i; n < *argc; n++ )
|
|
(*argv)[n] = (*argv)[n+1];
|
|
(*argc)--;
|
|
}
|
|
}
|
|
}
|
|
|
|
char* GetBuildTriplet(void)
|
|
{
|
|
#if defined(__sortix__) && defined(__i386__)
|
|
#if defined(__i686__)
|
|
return "i686-sortix";
|
|
#elif defined(__i586__)
|
|
return "i586-sortix";
|
|
#elif defined(__i486__)
|
|
return "i486-sortix";
|
|
#else
|
|
return "i386-sortix";
|
|
#endif
|
|
#elif defined(__sortix__) && defined(__x86_64__)
|
|
return strdup("x86_64-sortix");
|
|
#elif defined(__sortix__)
|
|
#warning "Add your build triplet here"
|
|
#endif
|
|
FILE* fp = popen("cc -dumpmachine", "r");
|
|
if ( !fp )
|
|
return NULL;
|
|
char* ret = read_single_line(fp);
|
|
pclose(fp);
|
|
return ret;
|
|
}
|
|
|
|
bool get_option_variable(const char* option, char** varptr,
|
|
const char* arg, int argc, char** argv, int* ip,
|
|
const char* argv0)
|
|
{
|
|
size_t option_len = strlen(option);
|
|
if ( strncmp(option, arg, option_len) != 0 )
|
|
return false;
|
|
if ( arg[option_len] == '=' )
|
|
{
|
|
*varptr = strdup(arg + option_len + 1);
|
|
return true;
|
|
}
|
|
if ( arg[option_len] != '\0' )
|
|
return false;
|
|
if ( *ip + 1 == argc )
|
|
{
|
|
fprintf(stderr, "%s: expected operand after `%s'\n", argv0, option);
|
|
exit(1);
|
|
}
|
|
*varptr = strdup(argv[++*ip]), argv[*ip] = NULL;
|
|
return true;
|
|
}
|
|
|
|
char* join_paths(const char* a, const char* b)
|
|
{
|
|
size_t a_len = strlen(a);
|
|
bool has_slash = (a_len && a[a_len-1] == '/') || b[0] == '/';
|
|
return has_slash ? print_string("%s%s", a, b) : print_string("%s/%s", a, b);
|
|
}
|
|
|
|
bool IsFile(const char* path)
|
|
{
|
|
struct stat st;
|
|
return stat(path, &st) == 0 && S_ISREG(st.st_mode);
|
|
}
|
|
|
|
bool IsDirectory(const char* path)
|
|
{
|
|
struct stat st;
|
|
return stat(path, &st) == 0 &&
|
|
(S_ISDIR(st.st_mode) || (errno = ENOTDIR, false));
|
|
}
|
|
|
|
size_t count_tar_components(const char* path)
|
|
{
|
|
if ( !*path )
|
|
return 0;
|
|
size_t slashes = 1;
|
|
for ( size_t i = 0; path[i]; i++ )
|
|
if ( path[i] == '/' )
|
|
slashes++;
|
|
return slashes;
|
|
}
|
|
|
|
#define GET_OPTION_VARIABLE(str, varptr) \
|
|
get_option_variable(str, varptr, arg, argc, argv, &i, argv0)
|
|
|
|
// TODO: This is a bit inefficient but doing it otherwise would involve looking
|
|
// through the error stream for messages such as "file not found", which
|
|
// can be hard to distinguish from the common "oh no, an error occured"
|
|
// case in which we need to abort as well.
|
|
bool TarContainsFile(const char* archive, const char* file)
|
|
{
|
|
int pipes[2];
|
|
if ( pipe(pipes) )
|
|
err(1, "pipe");
|
|
pid_t tar_pid = fork_or_death();
|
|
if ( !tar_pid )
|
|
{
|
|
dup2(pipes[1], 1);
|
|
close(pipes[1]);
|
|
close(pipes[0]);
|
|
const char* cmd_argv[] =
|
|
{
|
|
"tar",
|
|
"--list",
|
|
"--file", archive,
|
|
NULL
|
|
};
|
|
execvp(cmd_argv[0], (char* const*) cmd_argv);
|
|
err(127, "%s", cmd_argv[0]);
|
|
}
|
|
close(pipes[1]);
|
|
FILE* fp = fdopen(pipes[0], "r");
|
|
|
|
char* line = NULL;
|
|
size_t line_size = 0;
|
|
ssize_t line_len;
|
|
bool ret = false;
|
|
while ( 0 < (line_len = getline(&line, &line_size, fp)) )
|
|
{
|
|
if ( line[line_len-1] == '\n' )
|
|
line[--line_len] = '\0';
|
|
if ( strcmp(line, file) == 0 )
|
|
{
|
|
ret = true;
|
|
#if !defined(__sortix__)
|
|
kill(tar_pid, SIGPIPE);
|
|
break;
|
|
#endif
|
|
}
|
|
}
|
|
free(line);
|
|
if ( ferror(fp) )
|
|
err(1, "getline: tar");
|
|
|
|
fclose(fp);
|
|
int tar_exit_status;
|
|
waitpid(tar_pid, &tar_exit_status, 0);
|
|
bool sigpiped = WIFSIGNALED(tar_exit_status) &&
|
|
WTERMSIG(tar_exit_status) == SIGPIPE;
|
|
bool errored = !WIFEXITED(tar_exit_status) ||
|
|
WEXITSTATUS(tar_exit_status) != 0;
|
|
if ( errored && !sigpiped )
|
|
{
|
|
errx(1, "Unable to list contents of `%s'.", archive);
|
|
exit(WEXITSTATUS(tar_exit_status));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void TarExtractFileToFD(const char* archive, const char* file, int fd)
|
|
{
|
|
pid_t tar_pid = fork_or_death();
|
|
if ( !tar_pid )
|
|
{
|
|
if ( dup2(fd, 1) < 0 )
|
|
{
|
|
warn("dup2");
|
|
_exit(127);
|
|
}
|
|
close(fd);
|
|
const char* cmd_argv[] =
|
|
{
|
|
"tar",
|
|
"--to-stdout",
|
|
"--extract",
|
|
"--file", archive,
|
|
"--", file,
|
|
NULL
|
|
};
|
|
execvp(cmd_argv[0], (char* const*) cmd_argv);
|
|
warn("%s", cmd_argv[0]);
|
|
_exit(127);
|
|
}
|
|
int tar_exit_status;
|
|
waitpid(tar_pid, &tar_exit_status, 0);
|
|
if ( !WIFEXITED(tar_exit_status) || WEXITSTATUS(tar_exit_status) != 0 )
|
|
{
|
|
errx(1, "Unable to extract `%s/%s'", archive, file);
|
|
exit(WEXITSTATUS(tar_exit_status));
|
|
}
|
|
}
|
|
|
|
FILE* TarOpenFile(const char* archive, const char* file)
|
|
{
|
|
FILE* fp = tmpfile();
|
|
if ( !fp )
|
|
err(1, "tmpfile");
|
|
TarExtractFileToFD(archive, file, fileno(fp));
|
|
if ( fseeko(fp, 0, SEEK_SET) < 0 )
|
|
err(1, "fseeko(tmpfile(), 0, SEEK_SET)");
|
|
return fp;
|
|
}
|
|
|
|
void TarIndexToFD(const char* archive, int fd)
|
|
{
|
|
pid_t tar_pid = fork_or_death();
|
|
if ( !tar_pid )
|
|
{
|
|
if ( dup2(fd, 1) < 0 )
|
|
{
|
|
warn("dup2");
|
|
_exit(127);
|
|
}
|
|
close(fd);
|
|
const char* cmd_argv[] =
|
|
{
|
|
"tar",
|
|
"--list",
|
|
"--file", archive,
|
|
NULL
|
|
};
|
|
execvp(cmd_argv[0], (char* const*) cmd_argv);
|
|
warn("%s", cmd_argv[0]);
|
|
_exit(127);
|
|
}
|
|
int tar_exit_status;
|
|
waitpid(tar_pid, &tar_exit_status, 0);
|
|
if ( !WIFEXITED(tar_exit_status) || WEXITSTATUS(tar_exit_status) != 0 )
|
|
{
|
|
errx(1, "Unable to list contents of `%s'", archive);
|
|
exit(WEXITSTATUS(tar_exit_status));
|
|
}
|
|
}
|
|
|
|
FILE* TarOpenIndex(const char* archive)
|
|
{
|
|
FILE* fp = tmpfile();
|
|
if ( !fp )
|
|
err(1, "tmpfile");
|
|
TarIndexToFD(archive, fileno(fp));
|
|
if ( fseeko(fp, 0, SEEK_SET) < 0 )
|
|
err(1, "fseeko(tmpfile(), 0, SEEK_SET)");
|
|
return fp;
|
|
}
|
|
|
|
const char* VerifyInfoVariable(string_array_t* info, const char* var,
|
|
const char* path)
|
|
{
|
|
const char* ret = dictionary_get(info, var);
|
|
if ( !ret )
|
|
errx(1, "error: `%s': no `%s' variable declared", path, var);
|
|
return ret;
|
|
}
|
|
|
|
void VerifyTixInformation(string_array_t* tixinfo, const char* tix_path)
|
|
{
|
|
const char* tix_version = dictionary_get(tixinfo, "tix.version");
|
|
if ( !tix_version )
|
|
errx(1, "error: `%s': no `tix.version' variable declared",
|
|
tix_path);
|
|
if ( atoi(tix_version) != 1 )
|
|
errx(1, "error: `%s': tix version `%s' not supported", tix_path,
|
|
tix_version);
|
|
const char* tix_class = dictionary_get(tixinfo, "tix.class");
|
|
if ( !tix_class )
|
|
errx(1, "error: `%s': no `tix.class' variable declared", tix_path);
|
|
if ( !strcmp(tix_class, "srctix") )
|
|
errx(1, "error: `%s': this object is a source tix and needs to be "
|
|
"compiled into a binary tix prior to installation.",
|
|
tix_path);
|
|
if ( strcmp(tix_class, "tix") )
|
|
errx(1, "error: `%s': tix class `%s' is not `tix': this object is "
|
|
"not suitable for installation.", tix_path, tix_class);
|
|
if ( !(dictionary_get(tixinfo, "tix.platform")) )
|
|
errx(1, "error: `%s': no `tix.platform' variable declared", tix_path);
|
|
if ( !(dictionary_get(tixinfo, "pkg.name")) )
|
|
errx(1, "error: `%s': no `pkg.name' variable declared", tix_path);
|
|
}
|
|
|
|
bool IsCollectionPrefixRatherThanCommand(const char* arg)
|
|
{
|
|
return strchr(arg, '/') || !strcmp(arg, ".") || !strcmp(arg, "..");
|
|
}
|
|
|
|
void ParseOptionalCommandLineCollectionPrefix(char** collection, int* argcp,
|
|
char*** argvp)
|
|
{
|
|
if ( 2 <= *argcp && IsCollectionPrefixRatherThanCommand((*argvp)[1]) )
|
|
{
|
|
if ( !*collection )
|
|
{
|
|
free(*collection);
|
|
*collection = strdup((*argvp)[1]);
|
|
}
|
|
(*argvp)[1] = NULL;
|
|
compact_arguments(argcp, argvp);
|
|
}
|
|
else if ( !*collection )
|
|
{
|
|
*collection = strdup("/");
|
|
}
|
|
}
|
|
|
|
void VerifyCommandLineCollection(char** collection)
|
|
{
|
|
if ( !*collection )
|
|
errx(1, "error: you need to specify which tix collection to administer "
|
|
"using --collection or giving the prefix as the first "
|
|
"argument.");
|
|
|
|
if ( !**collection )
|
|
{
|
|
free(*collection);
|
|
*collection = strdup("/");
|
|
}
|
|
|
|
char* collection_rel = *collection;
|
|
if ( !(*collection = realpath(collection_rel, NULL)) )
|
|
err(1, "realpath: %s", collection_rel);
|
|
free(collection_rel);
|
|
}
|
|
|
|
void VerifyTixCollectionConfiguration(string_array_t* info, const char* path)
|
|
{
|
|
// TODO: After releasing Sortix 1.1, remove generation 2 compatibility.
|
|
const char* tix_version = dictionary_get(info, "tix.version");
|
|
if ( tix_version )
|
|
{
|
|
if ( !tix_version )
|
|
errx(1, "error: `%s': no `tix.version' variable declared", path);
|
|
if ( atoi(tix_version) != 1 )
|
|
errx(1, "error: `%s': tix version `%s' not supported", path,
|
|
tix_version);
|
|
const char* tix_class = dictionary_get(info, "tix.class");
|
|
if ( !tix_class )
|
|
errx(1, "error: `%s': no `tix.class' variable declared", path);
|
|
if ( strcmp(tix_class, "collection") != 0 )
|
|
errx(1, "error: `%s': error: unexpected tix class `%s'.", path,
|
|
tix_class);
|
|
if ( !(dictionary_get(info, "collection.prefix")) )
|
|
errx(1, "error: `%s': no `collection.prefix' variable declared",
|
|
path);
|
|
if ( !(dictionary_get(info, "collection.platform")) )
|
|
errx(1, "error: `%s': no `collection.platform' variable declared",
|
|
path);
|
|
return;
|
|
}
|
|
|
|
const char* version = dictionary_get(info, "TIX_COLLECTION_VERSION");
|
|
if ( !version )
|
|
errx(1, "%s: Mandatory TIX_COLLECTION_VERSION was not set", path);
|
|
if ( atoi(version) != 3 )
|
|
errx(1, "%s: Unsupported: TIX_COLLECTION_VERSION: %s", path, version);
|
|
if ( !(dictionary_get(info, "PREFIX")) )
|
|
errx(1, "%s: Mandatory PREFIX was not set", path);
|
|
if ( !(dictionary_get(info, "PLATFORM")) )
|
|
errx(1, "%s: Mandatory PLATFORM was not set", path);
|
|
}
|
|
|
|
static pid_t original_pid;
|
|
char* tmp_root = NULL;
|
|
static void cleanup_tmp(void)
|
|
{
|
|
if ( original_pid != getpid() )
|
|
return;
|
|
if ( !tmp_root )
|
|
return;
|
|
pid_t pid = fork();
|
|
if ( pid < 0 )
|
|
{
|
|
warn("fork");
|
|
return;
|
|
}
|
|
if ( pid == 0 )
|
|
{
|
|
const char* cmd_argv[] =
|
|
{
|
|
"rm",
|
|
"-rf",
|
|
"--",
|
|
(const char*) tmp_root,
|
|
NULL,
|
|
};
|
|
execvp(cmd_argv[0], (char* const*) cmd_argv);
|
|
warn("%s", cmd_argv[0]);
|
|
_exit(127);
|
|
}
|
|
int code;
|
|
waitpid(pid, &code, 0);
|
|
free(tmp_root);
|
|
tmp_root = NULL;
|
|
}
|
|
|
|
void initialize_tmp(const char* tmp, const char* purpose)
|
|
{
|
|
if ( tmp_root )
|
|
errx(1, "error: initialize_tmp called twice");
|
|
if ( asprintf(&tmp_root, "%s/%s.XXXXXX", tmp, purpose) < 0 )
|
|
err(1, "error: asprintf");
|
|
if ( !mkdtemp(tmp_root) )
|
|
err(1, "mkdtemp: `%s'", tmp_root);
|
|
original_pid = getpid();
|
|
if ( atexit(cleanup_tmp) != 0 )
|
|
{
|
|
int errnum = errno;
|
|
cleanup_tmp();
|
|
errno = errnum;
|
|
err(1, "atexit");
|
|
}
|
|
}
|
|
|
|
mode_t get_umask_value(void)
|
|
{
|
|
mode_t result = umask(0);
|
|
umask(result);
|
|
return result;
|
|
}
|
|
|
|
int fchmod_plus_x(int fd)
|
|
{
|
|
struct stat st;
|
|
if ( fstat(fd, &st) != 0 )
|
|
return -1;
|
|
mode_t new_mode = st.st_mode | (0111 & ~get_umask_value());
|
|
if ( fchmod(fd, new_mode) != 0 )
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
void fprint_shell_variable_assignment(FILE* fp, const char* variable, const char* value)
|
|
{
|
|
if ( value )
|
|
{
|
|
fprintf(fp, "export %s='", variable);
|
|
for ( size_t i = 0; value[i]; i++ )
|
|
if ( value[i] == '\'' )
|
|
fprintf(fp, "'\\''");
|
|
else
|
|
fputc(value[i], fp);
|
|
fprintf(fp, "'\n");
|
|
}
|
|
else
|
|
{
|
|
fprintf(fp, "unset %s\n", variable);
|
|
}
|
|
}
|
|
|
|
bool needs_single_quote(const char* string)
|
|
{
|
|
for ( size_t i = 0; string[i]; i++ )
|
|
{
|
|
char c = string[i];
|
|
if ( !(('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') ||
|
|
('0' <= c && c <= '9') ||
|
|
c == '/' || c == '_' || c == '.' || c == '+' || c == ':' ||
|
|
c == '%' || c == '$' || c == '{' || c == '}' || c == '-') )
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void fwrite_variable(FILE* fp, const char* key, const char* value)
|
|
{
|
|
fprintf(fp, "%s=", key);
|
|
if ( !needs_single_quote(value) )
|
|
fprintf(fp, "%s\n", value);
|
|
else
|
|
{
|
|
fputc('\'', fp);
|
|
for ( size_t i = 0; value[i]; i++ )
|
|
if ( value[i] == '\'' )
|
|
fprintf(fp, "'\\''");
|
|
else
|
|
fputc(value[i], fp);
|
|
fputs("'\n", fp);
|
|
}
|
|
}
|
|
|
|
bool is_success_exit_status(int status)
|
|
{
|
|
return WIFEXITED(status) && WEXITSTATUS(status) == 0;
|
|
}
|
|
|
|
__attribute__((noreturn))
|
|
bool exit_like_exit_status(int status)
|
|
{
|
|
if ( WIFEXITED(status) )
|
|
exit(WEXITSTATUS(status));
|
|
if ( WIFSIGNALED(status) )
|
|
exit(128 + WTERMSIG(status));
|
|
exit(1);
|
|
}
|
|
|
|
enum recovery_state
|
|
{
|
|
RECOVERY_STATE_NONE,
|
|
RECOVERY_STATE_PRINT_COMMAND,
|
|
RECOVERY_STATE_RUN_SHELL,
|
|
};
|
|
|
|
enum recovery_state
|
|
recovery_configure_state_def(bool set, enum recovery_state to_what)
|
|
{
|
|
static enum recovery_state recovery_state = RECOVERY_STATE_NONE;
|
|
if ( set )
|
|
recovery_state = to_what;
|
|
return recovery_state;
|
|
}
|
|
|
|
enum recovery_state
|
|
recovery_configure_state(bool set)
|
|
{
|
|
return recovery_configure_state_def(set, RECOVERY_STATE_NONE);
|
|
}
|
|
|
|
bool recovery_print_attempted_execution(void)
|
|
{
|
|
pid_t child_pid = fork();
|
|
if ( child_pid < 0 )
|
|
return false;
|
|
|
|
if ( !child_pid )
|
|
{
|
|
// Redirect stdout and stderr to /dev/null to prevent duplicate errors.
|
|
// The recovery_execvp function below will automatically re-open the
|
|
// terminal device when it needs to talk to the terminal.
|
|
int dev_null = open("/dev/null", O_WRONLY);
|
|
if ( 0 <= dev_null )
|
|
{
|
|
dup2(dev_null, 1);
|
|
dup2(dev_null, 2);
|
|
close(dev_null);
|
|
}
|
|
|
|
recovery_configure_state_def(true, RECOVERY_STATE_PRINT_COMMAND);
|
|
return true;
|
|
}
|
|
|
|
int status;
|
|
waitpid(child_pid, &status, 0);
|
|
|
|
return false;
|
|
}
|
|
|
|
bool recovery_run_shell(void)
|
|
{
|
|
pid_t child_pid = fork();
|
|
if ( child_pid < 0 )
|
|
return false;
|
|
|
|
if ( !child_pid )
|
|
{
|
|
recovery_configure_state_def(true, RECOVERY_STATE_RUN_SHELL);
|
|
return true;
|
|
}
|
|
|
|
int status;
|
|
waitpid(child_pid, &status, 0);
|
|
|
|
return false;
|
|
}
|
|
|
|
int recovery_execvp(const char* path, char* const* argv)
|
|
{
|
|
if ( recovery_configure_state(false) == RECOVERY_STATE_NONE )
|
|
return execvp(path, argv);
|
|
|
|
// Make sure that stdout and stderr go to an interactive terminal.
|
|
if ( !isatty(1) )
|
|
{
|
|
int dev_tty = open("/dev/tty", O_WRONLY);
|
|
if ( 0 <= dev_tty )
|
|
{
|
|
dup2(dev_tty, 1);
|
|
dup2(dev_tty, 2);
|
|
close(dev_tty);
|
|
}
|
|
}
|
|
|
|
printf("Attempted command was: ");
|
|
|
|
for ( int i = 0; argv[i]; i++ )
|
|
{
|
|
if ( i )
|
|
putchar(' ');
|
|
putchar('\'');
|
|
for ( size_t n = 0; argv[i][n]; n++ )
|
|
if ( argv[i][n] == '\'' )
|
|
printf("'\\''");
|
|
else
|
|
putchar(argv[i][n]);
|
|
putchar('\'');
|
|
}
|
|
|
|
printf("\n");
|
|
fflush(stdout);
|
|
|
|
if ( recovery_configure_state(false) == RECOVERY_STATE_PRINT_COMMAND )
|
|
_exit(0);
|
|
|
|
const char* cmd_argv[] =
|
|
{
|
|
getenv_def("SHELL", "sh"),
|
|
NULL
|
|
};
|
|
execvp(cmd_argv[0], (char* const*) cmd_argv);
|
|
err(127, "%s", cmd_argv[0]);
|
|
}
|
|
|
|
bool fork_and_wait_or_recovery(void)
|
|
{
|
|
int default_selection = 1;
|
|
|
|
while ( true )
|
|
{
|
|
pid_t child_pid = fork_or_death();
|
|
if ( !child_pid )
|
|
return true;
|
|
|
|
int status;
|
|
waitpid(child_pid, &status, 0);
|
|
|
|
if ( is_success_exit_status(status) )
|
|
return false;
|
|
|
|
if ( WIFEXITED(status) )
|
|
warnx("child with pid %ju exited with status %i.",
|
|
(intmax_t) child_pid, WEXITSTATUS(status));
|
|
else if ( WIFSIGNALED(status) )
|
|
warnx("child with pid %ji was killed by signal %i (%s).",
|
|
(intmax_t) child_pid, WTERMSIG(status),
|
|
strsignal(WTERMSIG(status)));
|
|
else
|
|
warnx("child with pid %ji exited in an unusual manner (%i).",
|
|
(intmax_t) child_pid, status);
|
|
|
|
if ( recovery_print_attempted_execution() )
|
|
return true;
|
|
|
|
if ( !isatty(0) )
|
|
exit_like_exit_status(status);
|
|
|
|
FILE* output = fopen("/dev/tty", "we");
|
|
if ( !output )
|
|
exit_like_exit_status(status);
|
|
|
|
retry_ask_recovery_method:
|
|
|
|
fprintf(output, "\n");
|
|
fprintf(output, "1. Abort\n");
|
|
fprintf(output, "2. Try again\n");
|
|
fprintf(output, "3. Pretend command was successful\n");
|
|
fprintf(output, "4. Run $SHELL -i to investigate\n");
|
|
fprintf(output, "5. Dump environment\n");
|
|
fprintf(output, "\n");
|
|
fprintf(output, "Please choose one: [%i] ", default_selection);
|
|
fflush(output);
|
|
|
|
char* input = read_single_line(stdin);
|
|
if ( !input )
|
|
{
|
|
fprintf(output, "\n");
|
|
fclose(output);
|
|
warn("stdin");
|
|
exit_like_exit_status(status);
|
|
}
|
|
|
|
int selection = default_selection;
|
|
if ( input[0] )
|
|
{
|
|
char* input_end;
|
|
selection = (int) strtol(input, &input_end, 0);
|
|
if ( *input_end )
|
|
{
|
|
warnx("error: `%s' is not an allowed choice", input);
|
|
goto retry_ask_recovery_method;
|
|
}
|
|
|
|
if ( 5 < selection )
|
|
{
|
|
warnx("error: `%i' is not an allowed choice", selection);
|
|
goto retry_ask_recovery_method;
|
|
}
|
|
}
|
|
|
|
if ( selection == 1 )
|
|
exit_like_exit_status(status);
|
|
|
|
if ( selection == 2 )
|
|
{
|
|
fprintf(output, "\nTrying to execute command again.\n\n");
|
|
fclose(output);
|
|
continue;
|
|
}
|
|
|
|
if ( selection == 3 )
|
|
{
|
|
fprintf(output, "\nPretending the command executed successfully.\n\n");
|
|
fclose(output);
|
|
return false;
|
|
}
|
|
|
|
if ( selection == 4 )
|
|
{
|
|
fprintf(output, "\nDropping you to a recovery shell, type `exit' "
|
|
"when you are done.\n\n");
|
|
if ( recovery_run_shell() )
|
|
return true;
|
|
}
|
|
|
|
if ( selection == 5 )
|
|
{
|
|
for ( size_t i = 0; environ[i]; i++ )
|
|
fprintf(output, "%s\n", environ[i]);
|
|
goto retry_ask_recovery_method;
|
|
}
|
|
|
|
default_selection = 2;
|
|
|
|
goto retry_ask_recovery_method;
|
|
}
|
|
}
|
|
|
|
#endif
|