/*
* pseudo_util.c, miscellaneous utility functions
*
* Copyright (c) 2008-2013 Wind River Systems, Inc.
*
* SPDX-License-Identifier: LGPL-2.1-only
*
*/
/* we need access to RTLD_NEXT for a horrible workaround */
#define _GNU_SOURCE
#include <ctype.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <regex.h>
#include <time.h>
#include <sys/time.h>
#include <unistd.h>
#include <limits.h>
/* see the comments below about (*real_regcomp)() */
#include <dlfcn.h>
#include "pseudo.h"
#include "pseudo_ipc.h"
#include "pseudo_db.h"
struct pseudo_variables {
char *key;
size_t key_len;
char *value;
};
/* The order below is not arbitrary, but based on an assumption
* of how often things will be used.
*/
static struct pseudo_variables pseudo_env[] = {
{ "PSEUDO_PREFIX", 13, NULL },
{ "PSEUDO_BINDIR", 13, NULL },
{ "PSEUDO_LIBDIR", 13, NULL },
{ "PSEUDO_LOCALSTATEDIR", 20, NULL },
{ "PSEUDO_PASSWD", 13, NULL },
{ "PSEUDO_CHROOT", 13, NULL },
{ "PSEUDO_UIDS", 11, NULL },
{ "PSEUDO_GIDS", 11, NULL },
{ "PSEUDO_OPTS", 11, NULL },
{ "PSEUDO_DEBUG", 12, NULL },
{ "PSEUDO_DEBUG_FILE", 17, NULL },
{ "PSEUDO_TAG", 10, NULL },
{ "PSEUDO_ENOSYS_ABORT", 19, NULL },
{ "PSEUDO_NOSYMLINKEXP", 19, NULL },
{ "PSEUDO_DISABLED", 15, NULL },
{ "PSEUDO_UNLOAD", 13, NULL },
{ "PSEUDO_ALLOW_FSYNC", 18, NULL },
#ifdef PSEUDO_PROFILING
{ "PSEUDO_PROFILE_PATH", 19, NULL },
#endif
{ "PSEUDO_EVLOG", 12, NULL },
{ "PSEUDO_EVLOG_FILE", 17, NULL },
{ NULL, 0, NULL } /* Magic terminator */
};
typedef struct {
struct timeval stamp;
int len;
char *data;
} pseudo_evlog_entry;
/* so bash overrides getenv/unsetenv/etcetera, preventing them from
* actually modifying environ, so we have pseudo_wrappers try to dlsym
* the right values. This could fail, in which case we'd get null
* pointers, and we'll just call whatever the linker gives us and
* hope for the best.
*/
#define SETENV(x, y, z) (pseudo_real_setenv ? pseudo_real_setenv : setenv)(x, y, z)
#define GETENV(x) (pseudo_real_getenv ? pseudo_real_getenv : getenv)(x)
#define UNSETENV(x) (pseudo_real_unsetenv ? pseudo_real_unsetenv : unsetenv)(x)
#define PSEUDO_EVLOG_ENTRIES 250
#define PSEUDO_EVLOG_LENGTH 256
static pseudo_evlog_entry event_log[PSEUDO_EVLOG_ENTRIES];
static char *pseudo_evlog_buffer;
static int pseudo_evlog_next_entry = 0;
static void pseudo_evlog_set(char *);
static void pseudo_evlog_flags_finalize(void);
static unsigned long pseudo_debug_flags_in(char *);
/* -1 - init hasn't been run yet
* 0 - init has been run
* 1 - init is running
*
* There are cases where the constructor is run AFTER the
* program starts playing with things, so we need to do our
* best to handle that case.
*/
static int pseudo_util_initted = -1; /* Not yet run */
/* bypass wrapper logic on path computations */
int (*pseudo_real_lstat)(const char *path, PSEUDO_STATBUF *buf) = NULL;
/* bash workaround */
int (*pseudo_real_unsetenv)(const char *) = unsetenv;
char * (*pseudo_real_getenv)(const char *) = getenv;
int (*pseudo_real_setenv)(const char *, const char *, int) = setenv;
#if 0
static void
dump_env(char **envp) {
size_t i = 0;
for (i = 0; envp[i]; i++) {
pseudo_debug(PDBGF_ENV, "dump_envp: [%d]%s\n", (int) i, envp[i]);
}
for (i = 0; pseudo_env[i].key; i++) {
pseudo_debug(PDBGF_ENV, "dump_envp: {%d}%s=%s\n", (int) i, pseudo_env[i].key, pseudo_env[i].value);
}
pseudo_debug(PDBGF_ENV, "dump_envp: _in_init %d\n", pseudo_util_initted);
}
#endif
int
pseudo_has_unload(char * const *envp) {
static const char unload[] = "PSEUDO_UNLOAD";
static size_t unload_len = sizeof(unload) - 1;
size_t i = 0;
/* Is it in the caller environment? */
if (NULL != GETENV(unload))
return 1;
/* Is it in the environment cache? */
if (pseudo_util_initted == -1)
pseudo_init_util();
while (pseudo_env[i].key && strcmp(pseudo_env[i].key, unload))
++i;
if (pseudo_env[i].key && pseudo_env[i].value)
return 1;
/* Is it in the operational environment? */
while (envp && *envp) {
if ((!strncmp(*envp, unload, unload_len)) && ('=' == (*envp)[unload_len]))
return 1;
++envp;
}
return 0;
}
/* Caller must free memory! */
char *
pseudo_get_value(const char *key) {
size_t i = 0;
char * value;
if (pseudo_util_initted == -1)
pseudo_init_util();
for (i = 0; pseudo_env[i].key && memcmp(pseudo_env[i].key, key, pseudo_env[i].key_len + 1); i++)
;
/* Check if the environment has it and we don't ...
* if so, something went wrong... so we'll attempt to recover
*/
if (pseudo_env[i].key && !pseudo_env[i].value && GETENV(pseudo_env[i].key))
pseudo_init_util();
if (pseudo_env[i].value)
value = strdup(pseudo_env[i].value);
else
value = NULL;
if (!pseudo_env[i].key)
pseudo_diag("Unknown variable %s.\n", key);
return value;
}
/* We make a copy, so the original values should be freed. */
int
pseudo_set_value(const char *key, const char *value) {
int rc = 0;
size_t i = 0;
if (pseudo_util_initted == -1)
pseudo_init_util();
for (i = 0; pseudo_env[i].key && memcmp(pseudo_env[i].key, key, pseudo_env[i].key_len + 1); i++)
;
if (pseudo_env[i].key) {
if (pseudo_env[i].value)
free(pseudo_env[i].value);
if (value) {
char *new = strdup(value);
if (new)
pseudo_env[i].value = new;
else
pseudo_diag("warning: failed to save new value (%s) for key %s\n",
value, key);
} else
pseudo_env[i].value = NULL;
} else {
if (!pseudo_util_initted) pseudo_diag("Unknown variable %s.\n", key);
rc = -EINVAL;
}
return rc;
}
void
pseudo_init_util(void) {
size_t i = 0;
char * env;
pseudo_util_initted = 1;
for (i = 0; pseudo_env[i].key; i++) {
if (GETENV(pseudo_env[i].key))
pseudo_set_value(pseudo_env[i].key, GETENV(pseudo_env[i].key));
}
pseudo_util_initted = 0;
/* Somewhere we have to set the debug level.. */
env = pseudo_get_value("PSEUDO_DEBUG");
if (env) {
int i;
int level = atoi(env);
if (level > 0) {
for (i = 0; i < level; ++i) {
pseudo_debug_verbose();
}
} else {
pseudo_debug_set(env);
}
pseudo_debug_flags_finalize();
}
free(env);
env = pseudo_get_value("PSEUDO_EVLOG");
if (env) {
pseudo_evlog_set(env);
pseudo_evlog_flags_finalize();
}
free(env);
}
unsigned long pseudo_util_debug_flags = 0;
unsigned long pseudo_util_evlog_flags = 0;
int pseudo_util_debug_fd = 2;
int pseudo_util_evlog_fd = 2;
static int debugged_newline = 1;
static char pid_text[32];
static size_t pid_len;
static int pseudo_append_element(char *newpath, char *root, size_t allocated, char **pcurrent, const char *element, size_t elen, PSEUDO_STATBUF *buf, int leave_this);
static int pseudo_append_elements(char *newpath, char *root, size_t allocated, char **current, const char *elements, size_t elen, int leave_last, PSEUDO_STATBUF *sbuf);
extern char **environ;
static ssize_t pseudo_max_pathlen = -1;
static ssize_t pseudo_sys_max_pathlen = -1;
/* in our installed system, we usually use a name of the form
* libpseudoCHECKSUM.so, where CHECKSUM is an md5 checksum of the host
* libc.so -- this forces rebuilds of the library when the C library
* changes. The problem is that the pseudo binary may be
* a prebuilt, in which case it doesn't know about CHECKSUM, so it
* has to determine whether a given PRELINK_LIBRARIES contains libpseudo.so
* or libpseudoCHECKSUM.so, without prior knowledge... Fancy!
*
* We search for anything matching libpseudo*.so, where * is any
* sequence of non-spaces (including an empty string), with either
* the beginning of the string or a space in front of it, and either
* the end of the string or a space after it.
*/
static char *libpseudo_name = "libpseudo.so";
/* this used to look for a "libpseudo*.so", but it turns out you can
* specify a path even on Linux.
*/
static char *libpseudo_pattern = "(^|=| )[^ ]*libpseudo[^ ]*\\.so($| )";
static regex_t libpseudo_regex;
static int libpseudo_regex_compiled = 0;
/* Okay, so, there's a funny story behind this. On one of the systems
* we need to run on, /usr/bin/find happens to provide its own
* definitions of regcomp and regexec which are INCOMPATIBLE with the
* ones in the C library, and not only that, but which have buggy and/or
* incompatible semantics, such that they trash elements of the pmatch
* array. So we do our best to call the "real" regcomp/regexec in the
* C library. If we can't find them, we just do our best and hope that
* no one called us from a program with incompatible variants.
*
*/
#if PSEUDO_PORT_LINUX
static int (*real_regcomp)(regex_t *__restrict __preg, const char *__restrict __pattern, int __cflags);
static int (*real_regexec)(const regex_t *__restrict __preg, const char *__restrict __string, size_t __nmatch, regmatch_t __pmatch[__restrict_arr], int __eflags);
#else
#define real_regcomp regcomp
#define real_regexec regexec
#endif /* PSEUDO_PORT_LINUX */
static int
libpseudo_regex_init(void) {
int rc;
if (libpseudo_regex_compiled)
return 0;
#if PSEUDO_PORT_LINUX
real_regcomp = dlsym(RTLD_NEXT, "regcomp");
if (!real_regcomp)
real_regcomp = regcomp;
real_regexec = dlsym(RTLD_NEXT, "regexec");
if (!real_regexec)
real_regexec = regexec;
#endif
rc = (*real_regcomp)(&libpseudo_regex, libpseudo_pattern, REG_EXTENDED);
if (rc == 0)
libpseudo_regex_compiled = 1;
return rc;
}
/* given a space-or-colon-separated list of files, ala PRELINK_LIBRARIES,
# return that list without any variants of libpseudo*.so.
*/
static char *
without_libpseudo(char *list) {
regmatch_t pmatch[1];
int counter = 0;
int skip_start = 0;
if (libpseudo_regex_init())
return NULL;
if (list[0] == '=' || list[0] == PSEUDO_LINKPATH_SEPARATOR[0])
skip_start = 1;
if ((*real_regexec)(&libpseudo_regex, list, 1, pmatch, 0)) {
return list;
}
list = strdup(list);
while (!(*real_regexec)(&libpseudo_regex, list, 1, pmatch, 0)) {
char *start = list + pmatch[0].rm_so;
char *end = list + pmatch[0].rm_eo;
/* don't copy over the space or = */
start += skip_start;
memmove(start, end, strlen(end) + 1);
++counter;
if (counter > 5) {
pseudo_diag("Found way too many libpseudo.so in environment, giving up.\n");
return list;
}
}
return list;
}
static char *
with_libpseudo(char *list, char *libdir_path) {
regmatch_t pmatch[1];
if (libpseudo_regex_init())
return NULL;
if ((*real_regexec)(&libpseudo_regex, list, 1, pmatch, 0)) {
size_t len;
#if PSEUDO_PORT_DARWIN
/* <%s:%s/%s\0> */
len = strlen(list) + 1 + strlen(libdir_path) + 1 + strlen(libpseudo_name) + 1;
#else
/* suppress warning */
(void) libdir_path;
/* <%s %s\0> */
len = strlen(list) + 1 + strlen(libpseudo_name) + 1;
#endif
char *new = malloc(len);
if (new) {
/* insert space only if there were previous bits */
/* on Darwin, we have to provide the full path to
* libpseudo
*/
#if PSEUDO_PORT_DARWIN
snprintf(new, len, "%s%s%s/%s", list,
*list ? PSEUDO_LINKPATH_SEPARATOR : "",
libdir_path ? libdir_path : "",
libpseudo_name);
#else
snprintf(new, len, "%s%s%s", list,
*list ? PSEUDO_LINKPATH_SEPARATOR : "",
libpseudo_name);
#endif
}
return new;
} else {
return strdup(list);
}
}
char *pseudo_version = PSEUDO_VERSION;
/* going away soon */
static int max_debug_level = 0;
void
pseudo_debug_terse(void) {
char s[2] = { pseudo_debug_type_symbolic(max_debug_level) };
if (max_debug_level > 0) {
--max_debug_level;
pseudo_debug_clear(s);
}
}
void
pseudo_debug_verbose(void) {
char s[2] = { pseudo_debug_type_symbolic(max_debug_level + 1) };
if (s[0]) {
pseudo_debug_set(s);
++max_debug_level;
}
}
void
pseudo_debug_set(char *s) {
pseudo_util_debug_flags = pseudo_debug_flags_in(s);
}
static void
pseudo_evlog_set(char *s) {
pseudo_util_evlog_flags = pseudo_debug_flags_in(s);
}
/* This exists because we don't want to allocate a bunch of strings
* and free them immediately if you have several flags set.
*/
static void
pseudo_flags_finalize(unsigned long flags, char *value) {
char buf[PDBG_MAX + 1] = "", *s = buf;
for (int i = 0; i < PDBG_MAX; ++i) {
if (flags & (1 << i)) {
*s++ = pseudo_debug_type_symbolic(i);
}
}
pseudo_set_value(value, buf);
}
void
pseudo_debug_flags_finalize(void) {
pseudo_flags_finalize(pseudo_util_debug_flags, "PSEUDO_DEBUG");
}
void
pseudo_evlog_flags_finalize(void) {
pseudo_flags_finalize(pseudo_util_evlog_flags, "PSEUDO_EVLOG");
}
static unsigned long
pseudo_debug_flags_in(char *s) {
unsigned long flags = 0;
if (!s)
return flags;
for (; *s; ++s) {
int id = pseudo_debug_type_symbolic_id(*s);
if (id > 0) {
flags |= (1 << id);
}
}
return flags;
}
void
pseudo_debug_clear(char *s) {
if (!s)
return;
for (; *s; ++s) {
int id = pseudo_debug_type_symbolic_id(*s);
if (id > 0) {
pseudo_util_debug_flags &= ~(1 << id);
}
}
}
int
pseudo_diag(char *fmt, ...) {
va_list ap;
char debuff[8192];
int len;
/* gcc on Ubuntu 8.10 requires that you examine the return from
* write(), and won't let you cast it to void. Of course, if you
* can't print error messages, there's nothing to do.
*/
int wrote = 0;
va_start(ap, fmt);
len = vsnprintf(debuff, 8192, fmt, ap);
va_end(ap);
if (len > 8192)
len = 8192;
if (debugged_newline && (pseudo_util_debug_flags & PDBGF_PID)) {
wrote += write(pseudo_util_debug_fd, pid_text, pid_len);
}
debugged_newline = (debuff[len - 1] == '\n');
wrote += write(pseudo_util_debug_fd, debuff, len);
return wrote;
}
void
pseudo_evlog_dump(void) {
char scratch[256], firstdate[64], lastdate[64];
time_t first = 0, last = 0;
int len;
int entries = 0;
struct tm first_tm, last_tm;
int wrote; /* ignoring write errors because there's nothing we can do */
for (int i = 0; i < PSEUDO_EVLOG_ENTRIES; ++i) {
pseudo_evlog_entry *e = &event_log[i];
if (!e->data || e->len < 0 || e->stamp.tv_sec == 0)
continue;
++entries;
if (!first || e->stamp.tv_sec < first)
first = e->stamp.tv_sec;
if (!last || e->stamp.tv_sec > last)
last = e->stamp.tv_sec;
}
localtime_r(&first, &first_tm);
localtime_r(&last, &last_tm);
strftime(firstdate, 64, "%Y-%M-%D %H:%M:%S", &first_tm);
strftime(lastdate, 64, "%Y-%M-%D %H:%M:%S", &last_tm);
len = snprintf(scratch, 256, "event log for pid %d [%d entries]\n",
getpid(), entries);
if (len > 256)
len = 256;
wrote = write(pseudo_util_evlog_fd, scratch, len);
len = snprintf(scratch, 256, " first entry %s\n", firstdate);
wrote = write(pseudo_util_evlog_fd, scratch, len);
len = snprintf(scratch, 256, " last entry %s\n", lastdate);
wrote = write(pseudo_util_evlog_fd, scratch, len);
for (int i = 0; i < PSEUDO_EVLOG_ENTRIES; ++i) {
int entry = (pseudo_evlog_next_entry + i) % PSEUDO_EVLOG_ENTRIES;
pseudo_evlog_entry *ev = &event_log[entry];
if (!ev->data || ev->len <= 0)
continue;
localtime_r(&ev->stamp.tv_sec, &first_tm);
len = strftime(firstdate, 64, "%H:%M:%S", &first_tm);
if (len) {
len = snprintf(scratch, 256, "%s.%03d: ", firstdate,
(int) (ev->stamp.tv_usec / 1000));
wrote = write(pseudo_util_evlog_fd, scratch, len);
} else {
wrote = write(pseudo_util_evlog_fd, "no timestamp: ", 14);
}
wrote = write(pseudo_util_evlog_fd, ev->data, ev->len);
}
(void) wrote;
}
int
pseudo_evlog_internal(char *fmt, ...) {
va_list ap;
pseudo_evlog_entry *ev = &event_log[pseudo_evlog_next_entry++];
pseudo_evlog_next_entry %= PSEUDO_EVLOG_ENTRIES;
if (!ev->data) {
pseudo_evlog_buffer = malloc(PSEUDO_EVLOG_ENTRIES * PSEUDO_EVLOG_LENGTH);
if (pseudo_evlog_buffer) {
for (int i = 0; i < PSEUDO_EVLOG_ENTRIES; ++i) {
event_log[i].data = pseudo_evlog_buffer + (PSEUDO_EVLOG_LENGTH * i);
}
} else {
pseudo_diag("fatal: can't allocate event log storage.\n");
}
}
va_start(ap, fmt);
ev->len = vsnprintf(ev->data, PSEUDO_EVLOG_LENGTH, fmt, ap);
va_end(ap);
if (ev->len > PSEUDO_EVLOG_LENGTH) {
strcpy(ev->data + PSEUDO_EVLOG_LENGTH - 5, "...\n");
ev->len = PSEUDO_EVLOG_LENGTH - 1;
}
gettimeofday(&ev->stamp, NULL);
return ev->len;
}
/* store pid in text form for prepending to messages */
void
pseudo_new_pid() {
#if PSEUDO_PORT_LINUX
extern char *program_invocation_short_name; /* glibcism */
#else
char *program_invocation_short_name = "unknown";
#endif
int pid = getpid();
pid_len = snprintf(pid_text, 32, "%d: ", pid);
pseudo_debug(PDBGF_PID, "new pid: %d [%s]\n", pid, program_invocation_short_name);
}
/* helper function for pseudo_fix_path
* adds "element" to "newpath" at location current, if it can, then
* checks whether this now points to a symlink. If it does, expand
* the symlink, appending each element in turn the same way.
*/
static int
pseudo_append_element(char *newpath, char *root, size_t allocated, char **pcurrent, const char *element, size_t elen, PSEUDO_STATBUF *buf, int leave_this) {
static int link_recursion = 0;
size_t curlen;
int is_dir = S_ISDIR(buf->st_mode);
char *current;
if (!newpath ||
!pcurrent || !*pcurrent ||
!root || !element) {
pseudo_diag("pseudo_append_element: invalid args.\n");
return -1;
}
current = *pcurrent;
pseudo_debug(PDBGF_PATH | PDBGF_VERBOSE, "pae: '%s', + '%.*s', is_dir %d\n",
newpath, (int) elen, element, is_dir);
/* the special cases here to skip empty paths, or ./.., should apply
* only to directories; plain files, nodes, etcetera should just get
* bogus paths.
*/
if (is_dir) {
/* sanity-check: ignore // or /./ */
if (elen == 0 || (elen == 1 && *element == '.')) {
return 0;
}
/* backtrack for .. */
if (elen == 2 && element[0] == '.' && element[1] == '.') {
/* if newpath is empty, do nothing. */
if (current <= root)
return 0;
/* now find the previous slash */
while (current > root && *current != '/') {
--current;
}
/* either we're at root, or we're at a slash.
* either way, nul that out, leaving us with a
* possibly-empty path which is not slash-terminated.
*/
*current = '\0';
*pcurrent = current;
return 1;
}
}
curlen = current - newpath;
/* current length, plus / <element> / \0 */
/* => curlen + elen + 3 */
if (curlen + elen + 3 > allocated) {
pseudo_diag("pseudo_append_element: path too long (wanted %lu bytes).\n", (unsigned long) curlen + elen + 3);
return -1;
}
/* append a slash */
*current++ = '/';
memcpy(current, element, elen);
current += elen;
/* nul-terminate, and we now point to the nul after the element just added. */
*current = '\0';
/* if we are not on the last element of a path and supposed to leave
* it alone (for SYMLINK_NOFOLLOW type cases), and we are not trying to
* go further under a regular file, we want to know whether this is a symlink.
* either way, we want to update buf to show the correct state of the file.
*/
if (!pseudo_real_lstat || (pseudo_real_lstat(newpath, buf) == -1)) {
// if we can't stat it, zero mode so we don't think it's
// known to be a link or a regular file.
buf->st_mode = 0;
}
/* it is intentional that this uses the "stale" is_dir for the file we
* were appending to. we don't want to actually try to do this when
* we're appending names to a regular file.
*/
if (!leave_this && is_dir) {
int is_link = S_ISLNK(buf->st_mode);
if (link_recursion >= PSEUDO_MAX_LINK_RECURSION && is_link) {
pseudo_diag("link recursion too deep, not expanding path '%s'.\n", newpath);
is_link = 0;
}
if (is_link) {
char linkbuf[pseudo_path_max() + 1];
ssize_t linklen;
int retval;
linklen = readlink(newpath, linkbuf, pseudo_path_max());
if (linklen == -1) {
pseudo_diag("uh-oh! '%s' seems to be a symlink, but I can't read it. Ignoring.", newpath);
return 0;
}
/* null-terminate buffer */
linkbuf[linklen] = '\0';
/* absolute symlink means start over! */
if (*linkbuf == '/') {
current = newpath;
} else {
/* point back at the end of the previous path... */
current -= (elen + 1);
}
/* null terminate at the new pointer */
*current = '\0';
*pcurrent = current;
/* we know that we're now pointing either at a directory we
* already decided was safe to go into, or root. either way,
* the parent item mode should reflect it being a directory.
* we don't need to call stat for that.
*/
buf->st_mode = S_IFDIR;
/* append all the elements in series */
++link_recursion;
retval = pseudo_append_elements(newpath, root, allocated, pcurrent, linkbuf, linklen, 0, buf);
--link_recursion;
return retval;
}
}
/* we used to always append a slash here. now we don't; append_elements
* handles slashes, so just update the pointer.
*/
*pcurrent = current;
return 1;
}
static int
pseudo_append_elements(char *newpath, char *root, size_t allocated, char **current, const char *path, size_t elen, int leave_last, PSEUDO_STATBUF *sbuf) {
int retval = 1;
/* a shareable buffer so we can cache stat results while walking the path */
PSEUDO_STATBUF buf;
buf.st_mode = 0;
const char * start = path;
if (!newpath || !root ||
!current || !*current ||
!path) {
pseudo_diag("pseudo_append_elements: invalid arguments.");
return -1;
}
if (!sbuf) {
/* we will use this buffer to hold "the current state of newpath".
* append_element will update that whenever it appends an element,
* and any calls back here from there will pass in the same buffer.
* if we didn't get one, we start using this local one, which will
* then get shared by anything we call.
*/
sbuf = &buf;
if (*current > root) {
if (!pseudo_real_lstat || (pseudo_real_lstat(newpath, sbuf) == -1)) {
sbuf->st_mode = 0;
}
} else {
/* Don't call lstat on an empty path, or at all when we
* know that "root" is always directory-like.
*/
sbuf->st_mode = S_IFDIR;
}
}
pseudo_debug(PDBGF_PATH | PDBGF_VERBOSE, "paes: newpath %s, element list <%.*s>\n",
newpath, (int) elen, path);
while (path < (start + elen) && *path) {
size_t this_elen;
int leave_this = 0;
char *next = strchr(path, '/');
if (!next) {
next = strchr(path, '\0');
leave_this = leave_last;
}
this_elen = next - path;
/* for a directory, we skip the append for empty path or ".";
* regular files get it appended so they can fail properly
* later for being invalid paths.
*/
pseudo_debug(PDBGF_PATH | PDBGF_VERBOSE, "element to add: '%.*s'\n",
(int) this_elen, path);
if (pseudo_append_element(newpath, root, allocated, current, path, this_elen, sbuf, leave_this) == -1) {
retval = -1;
break;
}
pseudo_debug(PDBGF_FILE | PDBGF_VERBOSE, "paes: append_element gave us '%s', current '%s'\n",
newpath, *current);
/* and now move past the separator */
path += this_elen + 1;
}
return retval;
}
/* don't do so many allocations */
#define PATHBUFS 16
static char *pathbufs[PATHBUFS] = { 0 };
static int pathbuf = 0;
/* Canonicalize path. "base", if present, is an already-canonicalized
* path of baselen characters, presumed not to end in a /. path is
* the new path to be canonicalized. The tricky part is that path may
* contain symlinks, which must be resolved.
* if "path" starts with a /, then it is an absolute path, and
* we ignore base.
*/
char *
pseudo_fix_path(const char *base, const char *path, size_t rootlen, size_t baselen, size_t *lenp, int leave_last) {
size_t newpathlen, pathlen;
char *newpath;
char *current;
char *effective_root;
int trailing_slash = 0;
if (!path) {
pseudo_diag("can't fix empty path.\n");
return 0;
}
newpathlen = pseudo_path_max();
if (!pathbufs[pathbuf]) {
pathbufs[pathbuf] = malloc(newpathlen);
}
newpath = pathbufs[pathbuf];
pathbuf = (pathbuf + 1) % PATHBUFS;
pathlen = strlen(path);
/* a trailing slash has special meaning, but processing
* trailing slashes is expensive.
*/
while (pathlen > 0 && path[pathlen - 1] == '/') {
trailing_slash = 1;
--pathlen;
}
/* allow a bit of slush. overallocating a bit won't
* hurt. rounding to 256's in the hopes that it makes life
* easier for the library.
*/
if (!newpath) {
pseudo_diag("allocation failed seeking memory for path (%s).\n", path);
return 0;
}
newpath[0] = '\0';
current = newpath;
if (baselen && (path[0] != '/' || rootlen)) {
memcpy(current, base, baselen);
current += baselen;
}
/* "root" is a pointer to the beginning of the *modifiable*
* part of the string; you can't back up over it.
*/
effective_root = newpath + rootlen;
*current = '\0';
/* at any given point:
* path is not slash-terminated
* current points to the null byte immediately after the path
* path points to the next element of path
* newpathlen is the total allocated length of newpath
* (current - newpath) is the used length of newpath
*/
int save_errno = errno;
if (pseudo_append_elements(newpath, effective_root, newpathlen, ¤t, path, pathlen, leave_last, 0) != -1) {
/* if we are expecting a trailing slash, or the path ended up being completely
* empty (meaning it's pointing at either effective_root or the beginning of
* the path), we need a slash here.
*/
if ((current == effective_root) || trailing_slash) {
if ((current - newpath) < (int) newpathlen) {
*current++ = '/';
*current = '\0';
}
}
pseudo_debug(PDBGF_PATH, "%s + %s => <%s>\n",
base ? base : "<nil>",
path ? path : "<nil>",
newpath ? newpath : "<nil>");
if (lenp) {
*lenp = current - newpath;
}
errno = save_errno;
return newpath;
} else {
errno = save_errno;
return 0;
}
}
/* remove the libpseudo stuff from the environment (leaving other preloads
* alone).
* There's an implicit memory leak here, but this is called only right
* before an exec(), or at most once in a given run.
*
* we don't try to fix the library path.
*/
void pseudo_dropenv() {
char *ld_preload = GETENV(PRELINK_LIBRARIES);
if (ld_preload) {
ld_preload = without_libpseudo(ld_preload);
if (!ld_preload) {
pseudo_diag("fatal: can't allocate new %s variable.\n", PRELINK_LIBRARIES);
}
if (ld_preload && strlen(ld_preload)) {
SETENV(PRELINK_LIBRARIES, ld_preload, 1);
} else {
SETENV(PRELINK_LIBRARIES, "", 1);
}
}
}
char **
pseudo_dropenvp(char * const *envp) {
char **new_envp;
int i, j;
for (i = 0; envp[i]; ++i) ;
new_envp = malloc((i + 1) * sizeof(*new_envp));
if (!new_envp) {
pseudo_diag("fatal: can't allocate new environment.\n");
return NULL;
}
j = 0;
for (i = 0; envp[i]; ++i) {
if (STARTSWITH(envp[i], PRELINK_LIBRARIES "=")) {
char *new_val = without_libpseudo(envp[i]);
if (!new_val) {
pseudo_diag("fatal: can't allocate new environment variable.\n");
return 0;
} else {
/* don't keep an empty value; if the whole string is
* PRELINK_LIRBARIES=, we just drop it. */
if (strcmp(new_val, PRELINK_LIBRARIES "=")) {
new_envp[j++] = new_val;
}
}
} else {
new_envp[j++] = envp[i];
}
}
new_envp[j++] = NULL;
return new_envp;
}
/* add pseudo stuff to the environment.
*/
void
pseudo_setupenv() {
size_t i = 0;
pseudo_debug(PDBGF_CLIENT, "setting up pseudo environment.\n");
/* Make sure everything has been evaluated */
free(pseudo_get_prefix(NULL));
free(pseudo_get_bindir());
free(pseudo_get_libdir());
free(pseudo_get_localstatedir());
while (pseudo_env[i].key) {
if (pseudo_env[i].value) {
SETENV(pseudo_env[i].key, pseudo_env[i].value, 0);
pseudo_debug(PDBGF_ENV | PDBGF_VERBOSE, "pseudo_env: %s => %s\n",
pseudo_env[i].key, pseudo_env[i].value);
}
i++;
}
const char *ld_library_path = GETENV(PRELINK_PATH);
char *libdir_path = pseudo_libdir_path(NULL);
if (!ld_library_path) {
size_t len = strlen(libdir_path) + 1 + (strlen(libdir_path) + 2) + 1;
char *newenv = malloc(len);
if (!newenv) {
pseudo_diag("fatal: can't allocate new %s variable.\n", PRELINK_PATH);
}
snprintf(newenv, len, "%s:%s64", libdir_path, libdir_path);
SETENV(PRELINK_PATH, newenv, 1);
} else if (!strstr(ld_library_path, libdir_path)) {
size_t len = strlen(ld_library_path) + 1 + strlen(libdir_path) + 1 + (strlen(libdir_path) + 2) + 1;
char *newenv = malloc(len);
if (!newenv) {
pseudo_diag("fatal: can't allocate new %s variable.\n", PRELINK_PATH);
}
snprintf(newenv, len, "%s:%s:%s64", ld_library_path, libdir_path, libdir_path);
SETENV(PRELINK_PATH, newenv, 1);
} else {
/* nothing to do, ld_library_path exists and contains
* our preferred path */
}
char *ld_preload = GETENV(PRELINK_LIBRARIES);
if (ld_preload) {
ld_preload = with_libpseudo(ld_preload, libdir_path);
if (!ld_preload) {
pseudo_diag("fatal: can't allocate new %s variable.\n", PRELINK_LIBRARIES);
}
SETENV(PRELINK_LIBRARIES, ld_preload, 1);
free(ld_preload);
} else {
ld_preload = with_libpseudo("", libdir_path);
if (!ld_preload) {
pseudo_diag("fatal: can't allocate new %s variable.\n", PRELINK_LIBRARIES);
}
SETENV(PRELINK_LIBRARIES, ld_preload, 1);
free(ld_preload);
}
/* we kept libdir path until now because with_libpseudo might
* need it
*/
free(libdir_path);
#if PSEUDO_PORT_DARWIN
char *force_flat = GETENV("DYLD_FORCE_FLAT_NAMESPACE");
if (!force_flat) {
SETENV("DYLD_FORCE_FLAT_NAMESPACE", "1", 1);
}
#endif
}
/* add pseudo stuff to the environment.
* We can't just use setenv(), because one use case is that we're trying
* to modify the environment of a process about to be forked through
* execve().
*/
char **
pseudo_setupenvp(char * const *envp) {
char **new_envp;
size_t i, j, k;
size_t env_count = 0;
size_t size_pseudoenv = 0;
char *ld_preload = NULL, *ld_library_path = NULL;
pseudo_debug(PDBGF_ENV, "setting up envp environment.\n");
/* Make sure everything has been evaluated */
free(pseudo_get_prefix(NULL));
free(pseudo_get_bindir());
free(pseudo_get_libdir());
free(pseudo_get_localstatedir());
for (i = 0; envp[i]; ++i) {
if (STARTSWITH(envp[i], PRELINK_LIBRARIES "=")) {
ld_preload = envp[i];
}
if (STARTSWITH(envp[i], PRELINK_PATH "=")) {
ld_library_path = envp[i];
}
++env_count;
}
for (i = 0; pseudo_env[i].key; i++) {
size_pseudoenv++;
}
env_count += size_pseudoenv; /* We're going to over allocate */
j = 0;
new_envp = malloc((env_count + 1) * sizeof(*new_envp));
if (!new_envp) {
pseudo_diag("fatal: can't allocate new environment.\n");
return NULL;
}
char *libdir_path = pseudo_libdir_path(NULL);
if (!ld_library_path) {
size_t len = strlen(PRELINK_PATH "=") + strlen(libdir_path) + 1 + (strlen(libdir_path) + 2) + 1;
char *newenv = malloc(len);
if (!newenv) {
pseudo_diag("fatal: can't allocate new %s variable.\n", PRELINK_PATH);
}
snprintf(newenv, len, PRELINK_PATH "=%s:%s64", libdir_path, libdir_path);
new_envp[j++] = newenv;
} else if (!strstr(ld_library_path, libdir_path)) {
size_t len = strlen(ld_library_path) + 1 + strlen(libdir_path) + 1 + (strlen(libdir_path) + 2) + 1;
char *newenv = malloc(len);
if (!newenv) {
pseudo_diag("fatal: can't allocate new %s variable.\n", PRELINK_PATH);
}
snprintf(newenv, len, "%s:%s:%s64", ld_library_path, libdir_path, libdir_path);
new_envp[j++] = newenv;
} else {
/* keep old value */
new_envp[j++] = ld_library_path;
}
if (ld_preload) {
ld_preload = with_libpseudo(ld_preload, libdir_path);
if (!ld_preload) {
pseudo_diag("fatal: can't allocate new %s variable.\n", PRELINK_LIBRARIES);
}
new_envp[j++] = ld_preload;
} else {
ld_preload = with_libpseudo("", libdir_path);
size_t len = strlen(PRELINK_LIBRARIES "=") + strlen(ld_preload) + 1;
char *newenv = malloc(len);
snprintf(newenv, len, PRELINK_LIBRARIES "=%s", ld_preload);
new_envp[j++] = newenv;
free(ld_preload);
}
free(libdir_path);
for (i = 0; envp[i]; ++i) {
if (STARTSWITH(envp[i], PRELINK_LIBRARIES "=")) continue;
if (STARTSWITH(envp[i], PRELINK_PATH "=")) continue;
new_envp[j++] = envp[i];
}
for (i = 0; pseudo_env[i].key; i++) {
int found = 0;
for (k = 0; k < j; k++) {
if (!strncmp(pseudo_env[i].key,new_envp[k],strlen(pseudo_env[i].key))) {
found = 1;
break;
}
}
if (!found && pseudo_env[i].key && pseudo_env[i].value) {
size_t len = strlen(pseudo_env[i].key) + 1 + strlen(pseudo_env[i].value) + 1;
char *newenv = malloc(len);
if (!newenv) {
pseudo_diag("fatal: can't allocate new variable.\n");
}
snprintf(newenv, len, "%s=%s", pseudo_env[i].key, pseudo_env[i].value);
new_envp[j++] = newenv;
}
}
new_envp[j++] = NULL;
return new_envp;
}
/* Append the file value to the prefix value. */
char *
pseudo_append_path(const char * prefix, size_t prefix_len, char *file) {
char *path;
if (!file) {
return strdup(prefix);
} else {
size_t len = prefix_len + strlen(file) + 2;
path = malloc(len);
if (path) {
char *endptr;
int rc;
rc = snprintf(path, len, "%s", prefix);
/* this certainly SHOULD be impossible */
if ((size_t) rc >= len)
rc = len - 1;
endptr = path + rc;
/* strip extra slashes.
* This probably has no real effect, but I don't like
* seeing "//" in paths.
*/
while ((endptr > path) && (endptr[-1] == '/'))
--endptr;
snprintf(endptr, len - (endptr - path), "/%s", file);
}
return path;
}
}
/* get the full path to a file under $PSEUDO_PREFIX. Other ways of
* setting the prefix all set it in the environment.
*/
char *
pseudo_prefix_path(char *file) {
char * rc;
char * prefix = pseudo_get_prefix(NULL);
if (!prefix) {
pseudo_diag("You must set the PSEUDO_PREFIX environment variable to run pseudo.\n");
exit(1);
}
rc = pseudo_append_path(prefix, strlen(prefix), file);
free(prefix);
return rc;
}
/* get the full path to a file under $PSEUDO_BINDIR. */
char *
pseudo_bindir_path(char *file) {
char * rc;
char * bindir = pseudo_get_bindir();
if (!bindir) {
pseudo_diag("You must set the PSEUDO_BINDIR environment variable to run pseudo.\n");
exit(1);
}
rc = pseudo_append_path(bindir, strlen(bindir), file);
free(bindir);
return rc;
}
/* get the full path to a file under $PSEUDO_LIBDIR. */
char *
pseudo_libdir_path(char *file) {
char * rc;
char * libdir = pseudo_get_libdir();
if (!libdir) {
pseudo_diag("You must set the PSEUDO_LIBDIR environment variable to run pseudo.\n");
exit(1);
}
rc = pseudo_append_path(libdir, strlen(libdir), file);
free(libdir);
return rc;
}
/* get the full path to a file under $PSEUDO_LOCALSTATEDIR. */
char *
pseudo_localstatedir_path(char *file) {
char * rc;
char * localstatedir = pseudo_get_localstatedir();
if (!localstatedir) {
pseudo_diag("You must set the PSEUDO_LOCALSTATEDIR environment variable to run pseudo.\n");
exit(1);
}
rc = pseudo_append_path(localstatedir, strlen(localstatedir), file);
free(localstatedir);
return rc;
}
char *
pseudo_get_prefix(char *pathname) {
char *s = pseudo_get_value("PSEUDO_PREFIX");
/* Generate the PSEUDO_PREFIX if necessary, and possible... */
if (!s && pathname) {
char mypath[pseudo_path_max()];
char *dir;
char *tmp_path;
if (pathname[0] == '/') {
snprintf(mypath, pseudo_path_max(), "%s", pathname);
s = mypath + strlen(mypath);
} else {
if (!getcwd(mypath, pseudo_path_max())) {
mypath[0] = '\0';
}
s = mypath + strlen(mypath);
s += snprintf(s, pseudo_path_max() - (s - mypath), "/%s",
pathname);
}
tmp_path = pseudo_fix_path(NULL, mypath, 0, 0, 0, AT_SYMLINK_NOFOLLOW);
/* point s to the end of the fixed path */
if ((int) strlen(tmp_path) >= pseudo_path_max()) {
pseudo_diag("Can't expand path '%s' -- expansion exceeds %d.\n",
mypath, (int) pseudo_path_max());
} else {
s = mypath + snprintf(mypath, pseudo_path_max(), "%s", tmp_path);
}
while (s > (mypath + 1) && *s != '/')
--s;
*s = '\0';
dir = s - 1;
while (dir > mypath && *dir != '/') {
--dir;
}
/* strip bin directory, if any */
if (!strncmp(dir, "/bin", 4)) {
*dir = '\0';
}
/* degenerate case: /bin/pseudo should yield a pseudo_prefix "/" */
if (*mypath == '\0') {
strcpy(mypath, "/");
}
pseudo_diag("Warning: PSEUDO_PREFIX unset, defaulting to %s.\n",
mypath);
pseudo_set_value("PSEUDO_PREFIX", mypath);
s = pseudo_get_value("PSEUDO_PREFIX");
}
return s;
}
char *
pseudo_get_bindir(void) {
char *s = pseudo_get_value("PSEUDO_BINDIR");
if (!s) {
char *pseudo_bindir = pseudo_prefix_path(PSEUDO_BINDIR);
if (pseudo_bindir) {
pseudo_set_value("PSEUDO_BINDIR", pseudo_bindir);
s = pseudo_bindir;
}
}
return s;
}
char *
pseudo_get_libdir(void) {
char *s = pseudo_get_value("PSEUDO_LIBDIR");
if (!s) {
char *pseudo_libdir;
pseudo_libdir = pseudo_prefix_path(PSEUDO_LIBDIR);
if (pseudo_libdir) {
pseudo_set_value("PSEUDO_LIBDIR", pseudo_libdir);
s = pseudo_libdir;
}
}
#if PSEUDO_PORT_DARWIN
/* on Darwin, we need lib64, because dyld won't search */
#else
/* If we somehow got lib64 in there, clean it down to just lib... */
if (s) {
size_t len = strlen(s);
if (s[len-2] == '6' && s[len-1] == '4') {
s[len-2] = '\0';
pseudo_set_value("PSEUDO_LIBDIR", s);
}
}
#endif
return s;
}
char *
pseudo_get_localstatedir() {
char *s = pseudo_get_value("PSEUDO_LOCALSTATEDIR");
if (!s) {
char *pseudo_localstatedir = pseudo_prefix_path(PSEUDO_LOCALSTATEDIR);
if (pseudo_localstatedir) {
pseudo_set_value("PSEUDO_LOCALSTATEDIR", pseudo_localstatedir);
s = pseudo_localstatedir;
}
}
return s;
}
/* these functions define the sizes pseudo will try to use
* when trying to allocate space, or guess how much space
* other people will have allocated; see the GNU man page
* for realpath(3) for an explanation of why the sys_path_max
* functions exists, approximately -- it's there to be a size
* that I'm pretty sure the user will have allocated if they
* provided a buffer to that defective function.
*/
/* I'm pretty sure this will be larger than real PATH_MAX */
#define REALLY_BIG_PATH 16384
/* A likely common value for PATH_MAX */
#define SORTA_BIG_PATH 4096
ssize_t
pseudo_path_max(void) {
if (pseudo_max_pathlen == -1) {
long l = pathconf("/", _PC_PATH_MAX);
if (l < 0) {
if (_POSIX_PATH_MAX > 0) {
pseudo_max_pathlen = _POSIX_PATH_MAX;
} else {
pseudo_max_pathlen = REALLY_BIG_PATH;
}
} else {
if (l <= REALLY_BIG_PATH) {
pseudo_max_pathlen = l;
} else {
pseudo_max_pathlen = REALLY_BIG_PATH;
}
}
}
return pseudo_max_pathlen;
}
ssize_t
pseudo_sys_path_max(void) {
if (pseudo_sys_max_pathlen == -1) {
long l = pathconf("/", _PC_PATH_MAX);
if (l < 0) {
if (_POSIX_PATH_MAX > 0) {
pseudo_sys_max_pathlen = _POSIX_PATH_MAX;
} else {
pseudo_sys_max_pathlen = SORTA_BIG_PATH;
}
} else {
if (l <= SORTA_BIG_PATH) {
pseudo_sys_max_pathlen = l;
} else {
pseudo_sys_max_pathlen = SORTA_BIG_PATH;
}
}
}
return pseudo_sys_max_pathlen;
}
/* complicated because in theory you can have modes like * 'ab+'
* which is the same as 'a+' in POSIX. The first letter really does have
* to be one of r, w, a, though.
*/
int
pseudo_access_fopen(const char *mode) {
int access = 0;
for (; *mode; ++mode) {
switch (*mode) {
case 'a':
access |= (PSA_APPEND | PSA_WRITE);
break;
case 'r':
access |= PSA_READ;
break;
case 'w':
access |= PSA_WRITE;
break;
case 'x':
/* special case -- note that this conflicts with a
* rarely-used glibc extension
*/
access |= PSA_EXEC;
break;
case 'b': /* binary mode */
break;
case 'c': case 'e': case 'm': /* glibc extensions */
break;
case '+':
/* one of these will already be set, presumably */
access |= (PSA_READ | PSA_WRITE);
break;
default:
access = -1;
break;
}
}
return access;
}
/* find a passwd/group file to use
* uses in order:
* - PSEUDO_CHROOT/etc/<file> (only if CHROOT is set)
* - PSEUDO_PASSWD/etc/<file>
* - /etc/<file>
*/
#if PSEUDO_PORT_DARWIN
/* on Darwin, you can't just use /etc/passwd for system lookups,
* you have to use the real library calls because they know about
* Directory Services. So...
*
* We make up fake fds and FILE * objects that can't possibly be
* valid.
*/
int pseudo_host_etc_passwd_fd = -3;
int pseudo_host_etc_group_fd = -4;
static FILE pseudo_fake_passwd_file;
static FILE pseudo_fake_group_file;
FILE *pseudo_host_etc_passwd_file = &pseudo_fake_passwd_file;
FILE *pseudo_host_etc_group_file = &pseudo_fake_group_file;
#endif
int
pseudo_etc_file(const char *file, char *realname, int flags, const char **search_dirs, int dircount) {
char filename[pseudo_path_max()];
int rc = -1;
if (!file) {
pseudo_debug(PDBGF_CHROOT, "pseudo_etc_file: needs argument, usually passwd/group\n");
errno = ENOENT;
return -1;
}
int i;
if (!search_dirs || dircount == 0) {
pseudo_debug(PDBGF_CHROOT, "pseudo_etc_file: no search dirs.\n");
errno = ENOENT;
return -1;
}
for (i = 0; i < dircount; ++i) {
const char *s = search_dirs[i];
/* we used to pass in some paths as NULL when unset,
* so we skipped those. Now NULL entries don't get
* put in, so the only NULL should be the sentinel
* value, and this should never get hit.
*
* "should" is not comforting to me.
*/
if (!s)
break;
#if PSEUDO_PORT_DARWIN
/* special magic: empty string implies our emulation
* of the passwd/group files.
*/
if (!*s) {
if (!strcmp("passwd", file)) {
pseudo_debug(PDBGF_CHROOT, "Darwin hackery: pseudo_etc_passwd returning magic passwd fd\n");
return pseudo_host_etc_passwd_fd;
} else if (!strcmp("group", file)) {
pseudo_debug(PDBGF_CHROOT, "Darwin hackery: pseudo_etc_passwd returning magic group fd\n");
return pseudo_host_etc_group_fd;
}
}
#endif
snprintf(filename, pseudo_path_max(), "%s/etc/%s",
s, file);
rc = open(filename, flags, 0600);
if (rc >= 0) {
if (realname)
strcpy(realname, filename);
pseudo_debug(PDBGF_CHROOT, "pseudo_etc_file: using '%s' for '%s'.\n",
filename, file);
return rc;
} else {
pseudo_debug(PDBGF_CHROOT | PDBGF_VERBOSE, "didn't find <%s>\n",
filename);
}
}
return rc;
}
/* set up a log file */
static int
pseudo_logfile(char *filename, char *defname, int prefer_fd) {
char *pseudo_path;
char *s;
#if PSEUDO_PORT_LINUX
extern char *program_invocation_short_name; /* glibcism */
#else
char *program_invocation_short_name = "unknown";
#endif
int fd;
if (!filename) {
if (!defname) {
pseudo_debug(PDBGF_INVOKE, "no special log file requested, using stderr.\n");
return -1;
}
pseudo_path = pseudo_localstatedir_path(defname);
if (!pseudo_path) {
pseudo_diag("can't get path for prefix/%s\n", PSEUDO_LOGFILE);
return -1;
}
} else {
char *pid = NULL, *prog = NULL;
size_t len;
for (s = filename; *s; ++s) {
if (s[0] == '%') {
switch (s[1]) {
case '%': /* skip the %% */
++s;
break;
case 'd':
if (pid) {
pseudo_diag("found second %%d in PSEUDO_DEBUG_FILE, ignoring.\n");
return -1;
} else {
pid = s;
}
break;
case 's':
if (prog) {
pseudo_diag("found second %%s in PSEUDO_DEBUG_FILE, ignoring.\n");
return -1;
} else {
prog = s;
}
break;
default:
if (isprint(s[1])) {
pseudo_diag("found unknown format character '%c' in PSEUDO_DEBUG_FILE, ignoring.\n",
s[1]);
} else {
pseudo_diag("found unknown format character '\\x%02x' in PSEUDO_DEBUG_FILE, ignoring.\n",
(unsigned char) s[1]);
}
return -1;
break;
}
}
}
len = strlen(filename) + 1;
if (pid)
len += 8;
if (prog)
len += strlen(program_invocation_short_name);
pseudo_path = malloc(len);
if (!pseudo_path) {
pseudo_diag("can't allocate space for debug file name.\n");
return -1;
}
if (pid && prog) {
if (pid < prog) {
snprintf(pseudo_path, len, filename, getpid(), program_invocation_short_name);
} else {
snprintf(pseudo_path, len, filename, program_invocation_short_name, getpid());
}
} else if (pid) {
snprintf(pseudo_path, len, filename, getpid());
} else if (prog) {
snprintf(pseudo_path, len, filename, program_invocation_short_name);
} else {
strcpy(pseudo_path, filename);
}
free(filename);
}
fd = open(pseudo_path, O_WRONLY | O_APPEND | O_CREAT, 0644);
if (fd == -1) {
pseudo_diag("help: can't open log file %s: %s\n", pseudo_path, strerror(errno));
} else {
/* try to force fd to prefer_fd. We do this because glibc's malloc
* debug unconditionally writes to fd 2, and we don't want
* a client process ending op on fd 2, or server debugging
* becomes a nightmare. So, server sets prefer_fd to 2. Client
* leaves it at -1.
*/
if (prefer_fd >= 0 && fd != prefer_fd) {
int newfd;
close(prefer_fd);
newfd = dup2(fd, prefer_fd);
if (newfd != -1) {
fd = newfd;
}
}
pseudo_util_debug_fd = fd;
}
free(pseudo_path);
return fd;
}
int
pseudo_debug_logfile(char *defname, int prefer_fd) {
char *filename = pseudo_get_value("PSEUDO_DEBUG_FILE");
int fd;
fd = pseudo_logfile(filename, defname, prefer_fd);
if (fd > -1) {
pseudo_diag("debug_logfile: fd %d\n", fd);
pseudo_util_debug_fd = fd;
return 0;
}
return 1;
}
int
pseudo_evlog_logfile(char *defname, int prefer_fd) {
char *filename = pseudo_get_value("PSEUDO_EVLOG_FILE");
int fd;
fd = pseudo_logfile(filename, defname, prefer_fd);
if (fd > -1) {
pseudo_util_evlog_fd = fd;
return 0;
}
return 1;
}
void
pseudo_stat32_from64(struct stat *buf32, const struct stat64 *buf) {
buf32->st_dev = buf->st_dev;
buf32->st_ino = buf->st_ino;
buf32->st_mode = buf->st_mode;
buf32->st_nlink = buf->st_nlink;
buf32->st_uid = buf->st_uid;
buf32->st_gid = buf->st_gid;
buf32->st_rdev = buf->st_rdev;
buf32->st_size = buf->st_size;
buf32->st_blksize = buf->st_blksize;
buf32->st_blocks = buf->st_blocks;
buf32->st_atime = buf->st_atime;
buf32->st_mtime = buf->st_mtime;
buf32->st_ctime = buf->st_ctime;
}
void
pseudo_stat64_from32(struct stat64 *buf64, const struct stat *buf) {
buf64->st_dev = buf->st_dev;
buf64->st_ino = buf->st_ino;
buf64->st_mode = buf->st_mode;
buf64->st_nlink = buf->st_nlink;
buf64->st_uid = buf->st_uid;
buf64->st_gid = buf->st_gid;
buf64->st_rdev = buf->st_rdev;
buf64->st_size = buf->st_size;
buf64->st_blksize = buf->st_blksize;
buf64->st_blocks = buf->st_blocks;
buf64->st_atime = buf->st_atime;
buf64->st_mtime = buf->st_mtime;
buf64->st_ctime = buf->st_ctime;
}
/* pretty-dump some data.
* expects to be called using pseudo_debug_call() so it doesn't have
* to do debug checks.
*/
void
pseudo_dump_data(char *name, const void *v, size_t len) {
char hexbuf[128];
char asciibuf[32];
const unsigned char *base = v;
const unsigned char *data = base;
int remaining = len;
pseudo_diag("%s at %p [%d byte%s]:\n",
name ? name : "data", v, (int) len, len == 1 ? "" : "s");
while (remaining > 0) {
char *hexptr = hexbuf;
char *asciiptr = asciibuf;
for (int i = 0; i < 16 && i < remaining; ++i) {
hexptr += snprintf(hexptr, 4, "%02x ", data[i]);
if (isprint(data[i])) {
*asciiptr++ = data[i];
} else {
*asciiptr++ = '.';
}
if (i % 4 == 3) {
*hexptr++ = ' ';
}
}
*hexptr = '\0';
*asciiptr = '\0';
pseudo_diag("0x%06x %-50.50s '%.16s'\n",
(int) (data - base),
hexbuf, asciibuf);
remaining = remaining - 16;
data = data + 16;
}
}