-dss_objects := cmdline.o dss.o string.o fd.o exec.o signal.o daemon.o df.o time.o snap.o ipc.o
+dss_objects := cmdline.o dss.o str.o file.o exec.o sig.o daemon.o df.o tv.o snap.o ipc.o
all: dss
man: dss.1
#include <stdio.h>
#include "gcc-compat.h"
-#include "error.h"
+#include "err.h"
#include "log.h"
-#include "string.h"
+#include "str.h"
+#include "daemon.h"
/**
* Do the usual stuff to become a daemon.
pid_t pid;
int null;
- DSS_INFO_LOG("daemonizing\n");
+ DSS_INFO_LOG(("daemonizing\n"));
pid = fork();
if (pid < 0)
goto err;
close(null);
return;
err:
- DSS_EMERG_LOG("fatal: %s\n", strerror(errno));
+ DSS_EMERG_LOG(("fatal: %s\n", strerror(errno)));
exit(EXIT_FAILURE);
}
assert(logfile_name);
logfile = fopen(logfile_name, "a");
if (!logfile) {
- DSS_EMERG_LOG("can not open %s: %s\n", logfile_name,
- strerror(errno));
+ DSS_EMERG_LOG(("can not open %s: %s\n", logfile_name,
+ strerror(errno)));
exit(EXIT_FAILURE);
}
setlinebuf(logfile);
{
if (!logfile)
return;
- DSS_INFO_LOG("closing logfile\n");
+ DSS_INFO_LOG(("closing logfile\n"));
fclose(logfile);
}
*/
void log_welcome(int loglevel)
{
- DSS_INFO_LOG("***** welcome to dss ******\n");
- DSS_DEBUG_LOG("using loglevel %d\n", loglevel);
+ DSS_INFO_LOG(("***** welcome to dss ******\n"));
+ DSS_DEBUG_LOG(("using loglevel %d\n", loglevel));
}
#include "gcc-compat.h"
#include "log.h"
-#include "error.h"
-#include "string.h"
+#include "err.h"
+#include "str.h"
#include "df.h"
int get_disk_space(const char *path, struct disk_space *result)
void log_disk_space(struct disk_space *ds)
{
- DSS_INFO_LOG("free: %uM/%uM (%u%%), %u%% inodes unused\n",
+ DSS_INFO_LOG(("free: %uM/%uM (%u%%), %u%% inodes unused\n",
ds->free_mb, ds->total_mb, ds->percent_free,
- ds->percent_free_inodes);
+ ds->percent_free_inodes));
}
#include "gcc-compat.h"
#include "cmdline.h"
#include "log.h"
-#include "string.h"
-#include "error.h"
-#include "fd.h"
+#include "str.h"
+#include "err.h"
+#include "file.h"
#include "exec.h"
#include "daemon.h"
-#include "signal.h"
+#include "sig.h"
#include "df.h"
-#include "time.h"
+#include "tv.h"
#include "snap.h"
#include "ipc.h"
fprintf(log, "\n*** disk space ***\n\n");
ret = get_disk_space(".", &ds);
if (ret >= 0) {
- DSS_INFO_LOG("disk space low: %s\n", disk_space_low(&ds)?
- "yes" : "no");
+ DSS_INFO_LOG(("disk space low: %s\n", disk_space_low(&ds)?
+ "yes" : "no"));
log_disk_space(&ds);
} else
- DSS_ERROR_LOG("can not get free disk space: %s\n",
- dss_strerror(-ret));
+ DSS_ERROR_LOG(("can not get free disk space: %s\n",
+ dss_strerror(-ret)));
/* we continue on errors from get_disk_space */
static int call_command_handler(void)
{
COMMANDS
- DSS_EMERG_LOG("BUG: did not find command handler\n");
+ DSS_EMERG_LOG(("BUG: did not find command handler\n"));
return -E_BUG;
}
#undef COMMAND
#undef COMMANDS
+static int loglevel = -1;
+static const char *location_file = NULL;
+static int location_line = -1;
+static const char *location_func = NULL;
+
+void dss_log_set_params(int ll, const char *file, int line, const char *func)
+{
+ loglevel = ll;
+ location_file = file;
+ location_line = line;
+ location_func = func;
+}
+
/**
* The log function of dss.
*
*
* All DSS_XXX_LOG() macros use this function.
*/
-__printf_2_3 void dss_log(int ll, const char* fmt,...)
+__printf_1_2 void dss_log(const char* fmt,...)
{
va_list argp;
FILE *outfd;
time_t t1;
char str[255] = "";
- if (ll < conf.loglevel_arg)
+ if (loglevel < conf.loglevel_arg)
return;
outfd = logfile? logfile : stderr;
time(&t1);
strftime(str, sizeof(str), "%b %d %H:%M:%S", tm);
fprintf(outfd, "%s ", str);
if (conf.loglevel_arg <= INFO)
- fprintf(outfd, "%i: ", ll);
+ fprintf(outfd, "%i: ", loglevel);
+#ifdef DSS_NO_FUNC_NAMES
+ fprintf(outfd, "%s:%d: ", location_file, location_line);
+#else
+ fprintf(outfd, "%s: ", location_func);
+#endif
va_start(argp, fmt);
vfprintf(outfd, fmt, argp);
va_end(argp);
if (!next_snapshot_time_is_valid())
next_snapshot_time = compute_next_snapshot_time();
if (next_snapshot_time <= now) {
- DSS_DEBUG_LOG("next snapshot: now\n");
+ DSS_DEBUG_LOG(("next snapshot: now\n"));
return 1;
}
- DSS_DEBUG_LOG("next snapshot due in %" PRId64 " seconds\n",
- next_snapshot_time - now);
+ DSS_DEBUG_LOG(("next snapshot due in %" PRId64 " seconds\n",
+ next_snapshot_time - now));
return 0;
}
assert(snapshot_creation_status == HS_READY);
/* make sure that the next snapshot time will be recomputed */
invalidate_next_snapshot_time();
- DSS_DEBUG_LOG("executing %s\n", conf.pre_create_hook_arg);
+ DSS_DEBUG_LOG(("executing %s\n", conf.pre_create_hook_arg));
dss_exec_cmdline_pid(&create_pid, conf.pre_create_hook_arg);
snapshot_creation_status = HS_PRE_RUNNING;
}
if (!s)
return;
- DSS_DEBUG_LOG("%s snapshot %s\n", why, s->name);
+ DSS_DEBUG_LOG(("%s snapshot %s\n", why, s->name));
assert(snapshot_removal_status == HS_READY);
assert(remove_pid == 0);
assert(!snapshot_currently_being_removed);
cmd = make_message("%s %s/%s", conf.pre_remove_hook_arg,
conf.dest_dir_arg, s->name);
- DSS_DEBUG_LOG("executing %s\n", cmd);
+ DSS_DEBUG_LOG(("executing %s\n", cmd));
dss_exec_cmdline_pid(&remove_pid, cmd);
free(cmd);
snapshot_removal_status = HS_PRE_RUNNING;
assert(snapshot_removal_status == HS_PRE_SUCCESS);
assert(remove_pid == 0);
- DSS_NOTICE_LOG("removing %s (interval = %i)\n", s->name, s->interval);
+ DSS_NOTICE_LOG(("removing %s (interval = %i)\n", s->name, s->interval));
ret = dss_rename(s->name, new_name);
if (ret < 0)
goto out;
struct snapshot *s;
int i;
- DSS_DEBUG_LOG("looking for orphaned snapshots\n");
+ DSS_DEBUG_LOG(("looking for orphaned snapshots\n"));
FOR_EACH_SNAPSHOT(s, i, sl) {
if (snapshot_is_being_created(s))
continue;
struct snapshot *s;
unsigned missing = 0;
- DSS_DEBUG_LOG("looking for intervals containing too many snapshots\n");
+ DSS_DEBUG_LOG(("looking for intervals containing too many snapshots\n"));
for (interval = conf.num_intervals_arg - 1; interval >= 0; interval--) {
unsigned keep = desired_number_of_snapshots(interval, conf.num_intervals_arg);
unsigned num = sl->interval_count[interval];
int i;
struct snapshot *s;
- DSS_DEBUG_LOG("looking for snapshots belonging to intervals >= %d\n",
- conf.num_intervals_arg);
+ DSS_DEBUG_LOG(("looking for snapshots belonging to intervals >= %d\n",
+ conf.num_intervals_arg));
FOR_EACH_SNAPSHOT(s, i, sl) {
if (snapshot_is_being_created(s))
continue;
return NULL;
}
-struct snapshot *find_oldest_removable_snapshot(struct snapshot_list *sl)
+static struct snapshot *find_oldest_removable_snapshot(struct snapshot_list *sl)
{
int i;
struct snapshot *s;
continue;
if (is_reference_snapshot(s))
continue;
- DSS_INFO_LOG("oldest removable snapshot: %s\n", s->name);
+ DSS_INFO_LOG(("oldest removable snapshot: %s\n", s->name));
return s;
}
return NULL;
{
char *old_name;
int ret;
+ int64_t now;
+ /*
+ * We don't want the dss_rename() below to fail with EEXIST because the
+ * last complete snapshot was created (and completed) in the same
+ * second as this one.
+ */
+ while ((now = get_current_time()) == start)
+ sleep(1);
free(path_to_last_complete_snapshot);
- ret = complete_name(start, get_current_time(),
- &path_to_last_complete_snapshot);
+ ret = complete_name(start, now, &path_to_last_complete_snapshot);
if (ret < 0)
return ret;
old_name = incomplete_name(start);
ret = dss_rename(old_name, path_to_last_complete_snapshot);
if (ret >= 0)
- DSS_NOTICE_LOG("%s -> %s\n", old_name,
- path_to_last_complete_snapshot);
+ DSS_NOTICE_LOG(("%s -> %s\n", old_name,
+ path_to_last_complete_snapshot));
free(old_name);
return ret;
}
victim = find_orphaned_snapshot(&sl);
if (victim)
goto remove;
- DSS_WARNING_LOG("disk space low and nothing obvious to remove\n");
+ DSS_WARNING_LOG(("disk space low and nothing obvious to remove\n"));
victim = find_oldest_removable_snapshot(&sl);
if (victim)
goto remove;
- DSS_CRIT_LOG("uhuhu: disk space low and nothing to remove\n");
+ DSS_CRIT_LOG(("uhuhu: disk space low and nothing to remove\n"));
ret = -ERRNO_TO_DSS_ERROR(ENOSPC);
goto out;
remove:
{
char *cmd = make_message("%s %s/%s", conf.post_create_hook_arg,
conf.dest_dir_arg, path_to_last_complete_snapshot);
- DSS_NOTICE_LOG("executing %s\n", cmd);
+ DSS_NOTICE_LOG(("executing %s\n", cmd));
dss_exec_cmdline_pid(&create_pid, cmd);
free(cmd);
snapshot_creation_status = HS_POST_RUNNING;
cmd = make_message("%s %s/%s", conf.post_remove_hook_arg,
conf.dest_dir_arg, s->name);
- DSS_NOTICE_LOG("executing %s\n", cmd);
+ DSS_NOTICE_LOG(("executing %s\n", cmd));
dss_exec_cmdline_pid(&remove_pid, cmd);
free(cmd);
snapshot_removal_status = HS_POST_RUNNING;
else process_name = "??????";
if (msg)
- DSS_INFO_LOG("%s\n", msg);
- DSS_DEBUG_LOG("sending signal %d (%s) to pid %d (%s process)\n",
- sig, signame, (int)pid, process_name);
+ DSS_INFO_LOG(("%s\n", msg));
+ DSS_DEBUG_LOG(("sending signal %d (%s) to pid %d (%s process)\n",
+ sig, signame, (int)pid, process_name));
if (kill(pid, sig) >= 0)
return;
- DSS_INFO_LOG("failed to send signal %d (%s) to pid %d (%s process)\n",
- sig, signame, (int)pid, process_name);
+ DSS_INFO_LOG(("failed to send signal %d (%s) to pid %d (%s process)\n",
+ sig, signame, (int)pid, process_name));
}
static void stop_create_process(void)
static void log_termination_msg(pid_t pid, int status)
{
if (WIFEXITED(status))
- DSS_INFO_LOG("child %i exited. Exit status: %i\n", (int)pid,
- WEXITSTATUS(status));
+ DSS_INFO_LOG(("child %i exited. Exit status: %i\n", (int)pid,
+ WEXITSTATUS(status)));
else if (WIFSIGNALED(status))
- DSS_NOTICE_LOG("child %i was killed by signal %i\n", (int)pid,
- WTERMSIG(status));
+ DSS_NOTICE_LOG(("child %i was killed by signal %i\n", (int)pid,
+ WTERMSIG(status)));
else
- DSS_WARNING_LOG("child %i terminated abormally\n", (int)pid);
+ DSS_WARNING_LOG(("child %i terminated abormally\n", (int)pid));
}
static int wait_for_process(pid_t pid, int *status)
{
int ret;
- DSS_DEBUG_LOG("Waiting for process %d to terminate\n", (int)pid);
+ DSS_DEBUG_LOG(("Waiting for process %d to terminate\n", (int)pid));
for (;;) {
fd_set rfds;
dss_kill(pid, SIGTERM, "killing child process");
}
if (ret < 0)
- DSS_ERROR_LOG("failed to wait for process %d\n", (int)pid);
+ DSS_ERROR_LOG(("failed to wait for process %d\n", (int)pid));
else
log_termination_msg(pid, *status);
return ret;
int es, ret;
if (!WIFEXITED(status)) {
- DSS_ERROR_LOG("rsync process %d died involuntary\n", (int)create_pid);
+ DSS_ERROR_LOG(("rsync process %d died involuntary\n", (int)create_pid));
ret = -E_INVOLUNTARY_EXIT;
snapshot_creation_status = HS_READY;
goto out;
* 13: Errors with program diagnostics
*/
if (es == 12 || es == 13) {
- DSS_WARNING_LOG("rsync process %d returned %d -- restarting\n",
- (int)create_pid, es);
+ DSS_WARNING_LOG(("rsync process %d returned %d -- restarting\n",
+ (int)create_pid, es));
snapshot_creation_status = HS_NEEDS_RESTART;
next_snapshot_time = get_current_time() + 60;
ret = 1;
goto out;
}
if (es != 0 && es != 23 && es != 24) {
- DSS_ERROR_LOG("rsync process %d returned %d\n", (int)create_pid, es);
+ DSS_ERROR_LOG(("rsync process %d returned %d\n", (int)create_pid, es));
ret = -E_BAD_EXIT_CODE;
snapshot_creation_status = HS_READY;
goto out;
es = WEXITSTATUS(status);
if (es) {
if (!warn_count--) {
- DSS_NOTICE_LOG("pre_create_hook %s returned %d\n",
- conf.pre_create_hook_arg, es);
- DSS_NOTICE_LOG("deferring snapshot creation...\n");
+ DSS_NOTICE_LOG(("pre_create_hook %s returned %d\n",
+ conf.pre_create_hook_arg, es));
+ DSS_NOTICE_LOG(("deferring snapshot creation...\n"));
warn_count = 60; /* warn only once per hour */
}
next_snapshot_time = get_current_time() + 60;
ret = 1;
break;
default:
- DSS_EMERG_LOG("BUG: create can't die in status %d\n",
- snapshot_creation_status);
+ DSS_EMERG_LOG(("BUG: create can't die in status %d\n",
+ snapshot_creation_status));
return -E_BUG;
}
create_pid = 0;
return ret;
return ret;
}
- DSS_EMERG_LOG("BUG: unknown process %d died\n", (int)pid);
+ DSS_EMERG_LOG(("BUG: unknown process %d died\n", (int)pid));
return -E_BUG;
}
static int check_config(void)
{
if (conf.unit_interval_arg <= 0) {
- DSS_ERROR_LOG("bad unit interval: %i\n", conf.unit_interval_arg);
+ DSS_ERROR_LOG(("bad unit interval: %i\n", conf.unit_interval_arg));
return -E_INVALID_NUMBER;
}
- DSS_DEBUG_LOG("unit interval: %i day(s)\n", conf.unit_interval_arg);
- if (conf.num_intervals_arg <= 0) {
- DSS_ERROR_LOG("bad number of intervals %i\n", conf.num_intervals_arg);
+ DSS_DEBUG_LOG(("unit interval: %i day(s)\n", conf.unit_interval_arg));
+ if (conf.num_intervals_arg <= 0 || conf.num_intervals_arg > 30) {
+ DSS_ERROR_LOG(("bad number of intervals: %i\n",
+ conf.num_intervals_arg));
return -E_INVALID_NUMBER;
}
- DSS_DEBUG_LOG("number of intervals: %i\n", conf.num_intervals_arg);
+ DSS_DEBUG_LOG(("number of intervals: %i\n", conf.num_intervals_arg));
return 1;
}
config_file_exists = !stat(config_file, &statbuf);
if (!config_file_exists && conf.config_file_given) {
ret = -ERRNO_TO_DSS_ERROR(errno);
- DSS_ERROR_LOG("failed to stat config file %s\n", config_file);
+ DSS_ERROR_LOG(("failed to stat config file %s\n", config_file));
goto out;
}
if (config_file_exists) {
logfile = open_log(conf.logfile_arg);
log_welcome(conf.loglevel_arg);
}
- DSS_DEBUG_LOG("loglevel: %d\n", conf.loglevel_arg);
+ DSS_DEBUG_LOG(("loglevel: %d\n", conf.loglevel_arg));
ret = config_file_exists;
out:
free(config_file);
if (ret < 0)
- DSS_EMERG_LOG("%s\n", dss_strerror(-ret));
+ DSS_EMERG_LOG(("%s\n", dss_strerror(-ret)));
return ret;
}
static int change_to_dest_dir(void)
{
- DSS_INFO_LOG("changing cwd to %s\n", conf.dest_dir_arg);
+ DSS_INFO_LOG(("changing cwd to %s\n", conf.dest_dir_arg));
return dss_chdir(conf.dest_dir_arg);
}
{
int ret;
- DSS_NOTICE_LOG("SIGHUP, re-reading config\n");
+ DSS_NOTICE_LOG(("SIGHUP, re-reading config\n"));
dump_dss_config("old");
ret = parse_config_file(1);
if (ret < 0)
}
out:
if (ret < 0)
- DSS_ERROR_LOG("%s\n", dss_strerror(-ret));
+ DSS_ERROR_LOG(("%s\n", dss_strerror(-ret)));
return ret;
}
s = find_orphaned_snapshot(&sl);
out:
if (s) {
- DSS_INFO_LOG("reusing %s snapshot %s\n", why, s->name);
+ DSS_INFO_LOG(("reusing %s snapshot %s\n", why, s->name));
ret = dss_rename(s->name, new_name);
}
if (ret >= 0)
- DSS_NOTICE_LOG("creating new snapshot %s\n", new_name);
+ DSS_NOTICE_LOG(("creating new snapshot %s\n", new_name));
free(new_name);
free_snapshot_list(&sl);
return ret;
*argv = dss_malloc((15 + conf.rsync_option_given) * sizeof(char *));
(*argv)[i++] = dss_strdup("rsync");
- (*argv)[i++] = dss_strdup("-aq");
+ (*argv)[i++] = dss_strdup("-a");
(*argv)[i++] = dss_strdup("--delete");
for (j = 0; j < conf.rsync_option_given; j++)
(*argv)[i++] = dss_strdup(conf.rsync_option_arg[j]);
if (name_of_reference_snapshot) {
- DSS_INFO_LOG("using %s as reference\n", name_of_reference_snapshot);
+ DSS_INFO_LOG(("using %s as reference\n", name_of_reference_snapshot));
(*argv)[i++] = make_message("--link-dest=../%s",
name_of_reference_snapshot);
} else
- DSS_INFO_LOG("no suitable reference snapshot found\n");
+ DSS_INFO_LOG(("no suitable reference snapshot found\n"));
logname = dss_logname();
if (use_rsync_locally(logname))
(*argv)[i++] = dss_strdup(conf.source_dir_arg);
(*argv)[i++] = incomplete_name(*num);
(*argv)[i++] = NULL;
for (j = 0; j < i; j++)
- DSS_DEBUG_LOG("argv[%d] = %s\n", j, (*argv)[j]);
+ DSS_DEBUG_LOG(("argv[%d] = %s\n", j, (*argv)[j]));
}
static void free_rsync_argv(char **argv)
argv[1] = dss_strerror(-exit_code);
argv[2] = NULL;
- DSS_NOTICE_LOG("executing %s %s\n", argv[0], argv[1]);
+ DSS_NOTICE_LOG(("executing %s %s\n", argv[0], argv[1]));
dss_exec(&pid, conf.exit_hook_arg, argv);
}
free(config_file);
if (ret < 0) {
- DSS_EMERG_LOG("failed to lock: %s\n", dss_strerror(-ret));
+ DSS_EMERG_LOG(("failed to lock: %s\n", dss_strerror(-ret)));
exit(EXIT_FAILURE);
}
}
lock_dss_or_die();
if (conf.dry_run_given) {
- DSS_ERROR_LOG("dry_run not supported by this command\n");
+ DSS_ERROR_LOG(("dry_run not supported by this command\n"));
return -E_SYNTAX;
}
ret = install_sighandler(SIGHUP);
{
int ret;
- DSS_INFO_LOG("setting up signal handlers\n");
+ DSS_INFO_LOG(("setting up signal handlers\n"));
signal_pipe = signal_init(); /* always successful */
ret = install_sighandler(SIGINT);
if (ret < 0)
ret = call_command_handler();
out:
if (ret < 0)
- DSS_EMERG_LOG("%s\n", dss_strerror(-ret));
+ DSS_EMERG_LOG(("%s\n", dss_strerror(-ret)));
exit(ret >= 0? EXIT_SUCCESS : EXIT_FAILURE);
}
--- /dev/null
+/*
+ * Copyright (C) 2006-2010 Andre Noll <maan@systemlinux.org>
+ *
+ * Licensed under the GPL v2. For licencing details see COPYING.
+ */
+extern char *dss_errlist[];
+extern char *dss_error_txt;
+
+void dss_log_set_params(int ll, const char *file, int line, const char *func);
+__printf_1_2 void dss_log(const char* fmt,...);
+
+/**
+ * This bit indicates whether a number is considered a system error number
+ * If yes, the system errno is just the result of clearing this bit from
+ * the given number.
+ */
+#define SYSTEM_ERROR_BIT 30
+
+/** Check whether the system error bit is set. */
+#define IS_SYSTEM_ERROR(num) (!!((num) & (1 << SYSTEM_ERROR_BIT)))
+
+/** Set the system error bit for the given number. */
+#define ERRNO_TO_DSS_ERROR(num) ((num) | (1 << SYSTEM_ERROR_BIT))
+
+/**
+ * dss' version of strerror(3).
+ *
+ * \param num The error number.
+ *
+ * \return The error text of \a num.
+ */
+static inline char *dss_strerror(int num)
+{
+ assert(num > 0);
+ if (IS_SYSTEM_ERROR(num))
+ return strerror((num) & ((1 << SYSTEM_ERROR_BIT) - 1));
+ else
+ return dss_errlist[num];
+}
+
+#define DSS_ERRORS \
+ DSS_ERROR(SUCCESS, "success"), \
+ DSS_ERROR(SYNTAX, "syntax error"), \
+ DSS_ERROR(ATOI_OVERFLOW, "value too large"), \
+ DSS_ERROR(STRTOLL, "unknown strtoll error"), \
+ DSS_ERROR(ATOI_NO_DIGITS, "no digits found in string"), \
+ DSS_ERROR(ATOI_JUNK_AT_END, "further characters after number"), \
+ DSS_ERROR(INVALID_NUMBER, "invalid number"), \
+ DSS_ERROR(STRFTIME, "strftime() failed"), \
+ DSS_ERROR(LOCALTIME, "localtime() failed"), \
+ DSS_ERROR(NULL_OPEN, "can not open /dev/null"), \
+ DSS_ERROR(DUP_PIPE, "exec error: can not create pipe"), \
+ DSS_ERROR(INVOLUNTARY_EXIT, "unexpected termination cause"), \
+ DSS_ERROR(BAD_EXIT_CODE, "unexpected exit code"), \
+ DSS_ERROR(SIGNAL_SIG_ERR, "signal() returned SIG_ERR"), \
+ DSS_ERROR(SIGNAL, "caught terminating signal"), \
+ DSS_ERROR(BUG, "values of beta might cause dom!"), \
+ DSS_ERROR(NOT_RUNNING, "dss not running")
+
+/**
+ * This is temporarily defined to expand to its first argument (prefixed by
+ * 'E_') and gets later redefined to expand to the error text only
+ */
+#define DSS_ERROR(err, msg) E_ ## err
+
+enum dss_error_codes {
+ DSS_ERRORS
+};
+#undef DSS_ERROR
+#define DSS_ERROR(err, msg) msg
+#define DEFINE_DSS_ERRLIST char *dss_errlist[] = {DSS_ERRORS}
+++ /dev/null
-/*
- * Copyright (C) 2006-2010 Andre Noll <maan@systemlinux.org>
- *
- * Licensed under the GPL v2. For licencing details see COPYING.
- */
-extern char *dss_errlist[];
-extern char *dss_error_txt;
-
-__printf_2_3 void dss_log(int ll, const char* fmt,...);
-
-/**
- * This bit indicates whether a number is considered a system error number
- * If yes, the system errno is just the result of clearing this bit from
- * the given number.
- */
-#define SYSTEM_ERROR_BIT 30
-
-/** Check whether the system error bit is set. */
-#define IS_SYSTEM_ERROR(num) (!!((num) & (1 << SYSTEM_ERROR_BIT)))
-
-/** Set the system error bit for the given number. */
-#define ERRNO_TO_DSS_ERROR(num) ((num) | (1 << SYSTEM_ERROR_BIT))
-
-/**
- * dss' version of strerror(3).
- *
- * \param num The error number.
- *
- * \return The error text of \a num.
- */
-static inline char *dss_strerror(int num)
-{
- assert(num > 0);
- if (IS_SYSTEM_ERROR(num))
- return strerror((num) & ((1 << SYSTEM_ERROR_BIT) - 1));
- else
- return dss_errlist[num];
-}
-
-#define DSS_ERRORS \
- DSS_ERROR(SUCCESS, "success"), \
- DSS_ERROR(SYNTAX, "syntax error"), \
- DSS_ERROR(ATOI_OVERFLOW, "value too large"), \
- DSS_ERROR(STRTOLL, "unknown strtoll error"), \
- DSS_ERROR(ATOI_NO_DIGITS, "no digits found in string"), \
- DSS_ERROR(ATOI_JUNK_AT_END, "further characters after number"), \
- DSS_ERROR(INVALID_NUMBER, "invalid number"), \
- DSS_ERROR(STRFTIME, "strftime() failed"), \
- DSS_ERROR(LOCALTIME, "localtime() failed"), \
- DSS_ERROR(NULL_OPEN, "can not open /dev/null"), \
- DSS_ERROR(DUP_PIPE, "exec error: can not create pipe"), \
- DSS_ERROR(INVOLUNTARY_EXIT, "unexpected termination cause"), \
- DSS_ERROR(BAD_EXIT_CODE, "unexpected exit code"), \
- DSS_ERROR(SIGNAL_SIG_ERR, "signal() returned SIG_ERR"), \
- DSS_ERROR(SIGNAL, "caught terminating signal"), \
- DSS_ERROR(BUG, "values of beta might cause dom!"), \
- DSS_ERROR(NOT_RUNNING, "dss not running")
-
-/**
- * This is temporarily defined to expand to its first argument (prefixed by
- * 'E_') and gets later redefined to expand to the error text only
- */
-#define DSS_ERROR(err, msg) E_ ## err
-
-enum dss_error_codes {
- DSS_ERRORS
-};
-#undef DSS_ERROR
-#define DSS_ERROR(err, msg) msg
-#define DEFINE_DSS_ERRLIST char *dss_errlist[] = {DSS_ERRORS}
#include "gcc-compat.h"
#include "log.h"
-#include "error.h"
-#include "string.h"
+#include "err.h"
+#include "str.h"
+#include "exec.h"
/**
* Spawn a new process using execvp().
void dss_exec(pid_t *pid, const char *file, char *const *const args)
{
if ((*pid = fork()) < 0) {
- DSS_EMERG_LOG("fork error: %s\n", strerror(errno));
+ DSS_EMERG_LOG(("fork error: %s\n", strerror(errno)));
exit(EXIT_FAILURE);
}
if (*pid) /* parent */
signal(SIGTERM, SIG_DFL);
signal(SIGCHLD, SIG_DFL);
execvp(file, args);
- DSS_EMERG_LOG("execvp error: %s\n", strerror(errno));
+ DSS_EMERG_LOG(("execvp error: %s\n", strerror(errno)));
_exit(EXIT_FAILURE);
}
+++ /dev/null
-/*
- * Copyright (C) 2006-2010 Andre Noll <maan@systemlinux.org>
- *
- * Licensed under the GPL v2. For licencing details see COPYING.
- */
-
-#include <unistd.h>
-#include <assert.h>
-#include <string.h>
-#include <errno.h>
-#include <sys/types.h>
-#include <dirent.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-
-
-#include "gcc-compat.h"
-#include "error.h"
-#include "string.h"
-
-/**
- * Call a function for each subdirectory of the current working directory.
- *
- * \param dirname The directory to traverse.
- * \param func The function to call for each subdirecrtory.
- * \param private_data Pointer to an arbitrary data structure.
- *
- * For each top-level directory under \a dirname, the supplied function \a func is
- * called. The full path of the subdirectory and the \a private_data pointer
- * are passed to \a func.
- *
- * \return This function returns immediately if \a func returned a negative
- * value. In this case \a func must set error_txt and this negative value is
- * returned to the caller. Otherwise the function returns when all
- * subdirectories have been passed to \a func.
- */
-
-int for_each_subdir(int (*func)(const char *, void *), void *private_data)
-{
- struct dirent *entry;
- int ret;
- DIR *dir = opendir(".");
-
- if (!dir)
- return -ERRNO_TO_DSS_ERROR(errno);
- while ((entry = readdir(dir))) {
- mode_t m;
- struct stat s;
-
- if (!strcmp(entry->d_name, "."))
- continue;
- if (!strcmp(entry->d_name, ".."))
- continue;
- ret = lstat(entry->d_name, &s) == -1;
- if (ret == -1) {
- ret = -ERRNO_TO_DSS_ERROR(errno);
- goto out;
- }
- m = s.st_mode;
- if (!S_ISDIR(m))
- continue;
- ret = func(entry->d_name, private_data);
- if (ret < 0)
- goto out;
- }
- ret = 1;
-out:
- closedir(dir);
- return ret;
-}
-/**
- * Wrapper for chdir(2).
- *
- * \param path The specified directory.
- *
- * \return Standard.
- */
-int dss_chdir(const char *path)
-{
- if (chdir(path) >= 0)
- return 1;
- return -ERRNO_TO_DSS_ERROR(errno);
-}
-
-/**
- * Set a file descriptor to non-blocking mode.
- *
- * \param fd The file descriptor.
- *
- * \return Standard.
- */
-__must_check int mark_fd_nonblocking(int fd)
-{
- int flags = fcntl(fd, F_GETFL);
- if (flags < 0)
- return -ERRNO_TO_DSS_ERROR(errno);
- flags = fcntl(fd, F_SETFL, ((long)flags) | O_NONBLOCK);
- if (flags < 0)
- return -ERRNO_TO_DSS_ERROR(errno);
- return 1;
-}
-
-/**
- * dss' wrapper for select(2).
- *
- * It calls select(2) (with no exceptfds) and starts over if select() was
- * interrupted by a signal.
- *
- * \param n The highest-numbered descriptor in any of the two sets, plus 1.
- * \param readfds fds that should be checked for readability.
- * \param writefds fds that should be checked for writablility.
- * \param timeout_tv upper bound on the amount of time elapsed before select()
- * returns.
- *
- * \return The return value of the underlying select() call on success, the
- * negative system error code on errors.
- *
- * All arguments are passed verbatim to select(2).
- * \sa select(2) select_tut(2).
- */
-int dss_select(int n, fd_set *readfds, fd_set *writefds,
- struct timeval *timeout_tv)
-{
- int ret, err;
- do {
- ret = select(n, readfds, writefds, NULL, timeout_tv);
- err = errno;
- } while (ret < 0 && err == EINTR);
- if (ret < 0)
- return -ERRNO_TO_DSS_ERROR(errno);
- return ret;
-}
+++ /dev/null
-/*
- * Copyright (C) 2006-2010 Andre Noll <maan@systemlinux.org>
- *
- * Licensed under the GPL v2. For licencing details see COPYING.
- */
-int dss_chdir(const char *path);
-int for_each_subdir(int (*func)(const char *, void *), void *private_data);
-__must_check int mark_fd_nonblocking(int fd);
-/**
- * A wrapper for rename(2).
- *
- * \param old_path The source path.
- * \param new_path The destination path.
- *
- * \return Standard.
- *
- * \sa rename(2).
- */
-_static_inline_ int dss_rename(const char *old_path, const char *new_path)
-{
- if (rename(old_path, new_path) >= 0)
- return 1;
- return -ERRNO_TO_DSS_ERROR(errno);
-}
-
-int dss_select(int n, fd_set *readfds, fd_set *writefds,
- struct timeval *timeout_tv);
--- /dev/null
+/*
+ * Copyright (C) 2006-2010 Andre Noll <maan@systemlinux.org>
+ *
+ * Licensed under the GPL v2. For licencing details see COPYING.
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <assert.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include "gcc-compat.h"
+#include "err.h"
+#include "str.h"
+#include "file.h"
+
+/**
+ * Call a function for each subdirectory of the current working directory.
+ *
+ * \param dirname The directory to traverse.
+ * \param func The function to call for each subdirecrtory.
+ * \param private_data Pointer to an arbitrary data structure.
+ *
+ * For each top-level directory under \a dirname, the supplied function \a func is
+ * called. The full path of the subdirectory and the \a private_data pointer
+ * are passed to \a func.
+ *
+ * \return This function returns immediately if \a func returned a negative
+ * value. In this case \a func must set error_txt and this negative value is
+ * returned to the caller. Otherwise the function returns when all
+ * subdirectories have been passed to \a func.
+ */
+
+int for_each_subdir(int (*func)(const char *, void *), void *private_data)
+{
+ struct dirent *entry;
+ int ret;
+ DIR *dir = opendir(".");
+
+ if (!dir)
+ return -ERRNO_TO_DSS_ERROR(errno);
+ while ((entry = readdir(dir))) {
+ mode_t m;
+ struct stat s;
+
+ if (!strcmp(entry->d_name, "."))
+ continue;
+ if (!strcmp(entry->d_name, ".."))
+ continue;
+ ret = lstat(entry->d_name, &s) == -1;
+ if (ret == -1) {
+ ret = -ERRNO_TO_DSS_ERROR(errno);
+ goto out;
+ }
+ m = s.st_mode;
+ if (!S_ISDIR(m))
+ continue;
+ ret = func(entry->d_name, private_data);
+ if (ret < 0)
+ goto out;
+ }
+ ret = 1;
+out:
+ closedir(dir);
+ return ret;
+}
+/**
+ * Wrapper for chdir(2).
+ *
+ * \param path The specified directory.
+ *
+ * \return Standard.
+ */
+int dss_chdir(const char *path)
+{
+ if (chdir(path) >= 0)
+ return 1;
+ return -ERRNO_TO_DSS_ERROR(errno);
+}
+
+/**
+ * Set a file descriptor to non-blocking mode.
+ *
+ * \param fd The file descriptor.
+ *
+ * \return Standard.
+ */
+__must_check int mark_fd_nonblocking(int fd)
+{
+ int flags = fcntl(fd, F_GETFL);
+ if (flags < 0)
+ return -ERRNO_TO_DSS_ERROR(errno);
+ flags = fcntl(fd, F_SETFL, ((long)flags) | O_NONBLOCK);
+ if (flags < 0)
+ return -ERRNO_TO_DSS_ERROR(errno);
+ return 1;
+}
+
+/**
+ * dss' wrapper for select(2).
+ *
+ * It calls select(2) (with no exceptfds) and starts over if select() was
+ * interrupted by a signal.
+ *
+ * \param n The highest-numbered descriptor in any of the two sets, plus 1.
+ * \param readfds fds that should be checked for readability.
+ * \param writefds fds that should be checked for writablility.
+ * \param timeout_tv upper bound on the amount of time elapsed before select()
+ * returns.
+ *
+ * \return The return value of the underlying select() call on success, the
+ * negative system error code on errors.
+ *
+ * All arguments are passed verbatim to select(2).
+ * \sa select(2) select_tut(2).
+ */
+int dss_select(int n, fd_set *readfds, fd_set *writefds,
+ struct timeval *timeout_tv)
+{
+ int ret, err;
+ do {
+ ret = select(n, readfds, writefds, NULL, timeout_tv);
+ err = errno;
+ } while (ret < 0 && err == EINTR);
+ if (ret < 0)
+ return -ERRNO_TO_DSS_ERROR(errno);
+ return ret;
+}
--- /dev/null
+/*
+ * Copyright (C) 2006-2010 Andre Noll <maan@systemlinux.org>
+ *
+ * Licensed under the GPL v2. For licencing details see COPYING.
+ */
+int dss_chdir(const char *path);
+int for_each_subdir(int (*func)(const char *, void *), void *private_data);
+__must_check int mark_fd_nonblocking(int fd);
+/**
+ * A wrapper for rename(2).
+ *
+ * \param old_path The source path.
+ * \param new_path The destination path.
+ *
+ * \return Standard.
+ *
+ * \sa rename(2).
+ */
+_static_inline_ int dss_rename(const char *old_path, const char *new_path)
+{
+ if (rename(old_path, new_path) >= 0)
+ return 1;
+ return -ERRNO_TO_DSS_ERROR(errno);
+}
+
+int dss_select(int n, fd_set *readfds, fd_set *writefds,
+ struct timeval *timeout_tv);
#include <sys/param.h>
#include "gcc-compat.h"
-#include "string.h"
+#include "str.h"
#include "log.h"
#include "gcc-compat.h"
-#include "error.h"
+#include "err.h"
+#include "ipc.h"
#if (defined(__GNUC__) && defined(__i386__))
#define get16bits(d) (*((const uint16_t *) (d)))
if (stat(config_file, &statbuf) == 0) {
ret = dss_realpath(config_file, &rpath);
if (ret < 0) {
- DSS_EMERG_LOG("could not resolve path %s: %s\n", config_file,
- dss_strerror(-ret));
+ DSS_EMERG_LOG(("could not resolve path %s: %s\n", config_file,
+ dss_strerror(-ret)));
exit(EXIT_FAILURE);
}
- DSS_DEBUG_LOG("resolved path: %s\n", rpath);
+ DSS_DEBUG_LOG(("resolved path: %s\n", rpath));
} else
/*
* This happens if the user did not specify a config file, and
{
int ret;
- DSS_DEBUG_LOG("getting semaphore 0x%x\n", key);
+ DSS_DEBUG_LOG(("getting semaphore 0x%x\n", key));
ret = semget(key, 2, flags);
if (ret < 0)
return -ERRNO_TO_DSS_ERROR(errno);
{
int ret;
- DSS_DEBUG_LOG("calling semop\n");
+ DSS_DEBUG_LOG(("calling semop\n"));
do {
ret = semop(id, sops, num);
if (ret >= 0)
static int mutex_lock(int id)
{
+ struct sembuf sops[4];
int ret;
- DSS_DEBUG_LOG("locking\n");
- struct sembuf sops[4] = {
- {
- .sem_num = 0,
- .sem_op = 0,
- .sem_flg = SEM_UNDO | IPC_NOWAIT
- },
- {
- .sem_num = 0,
- .sem_op = 1,
- .sem_flg = SEM_UNDO | IPC_NOWAIT
- },
- {
- .sem_num = 1,
- .sem_op = 0,
- .sem_flg = SEM_UNDO | IPC_NOWAIT
- },
- {
- .sem_num = 1,
- .sem_op = 1,
- .sem_flg = SEM_UNDO | IPC_NOWAIT
- }
- };
+ DSS_DEBUG_LOG(("locking\n"));
+
+ sops[0].sem_num = 0;
+ sops[0].sem_op = 0;
+ sops[0].sem_flg = SEM_UNDO | IPC_NOWAIT;
+
+ sops[1].sem_num = 0;
+ sops[1].sem_op = 1;
+ sops[1].sem_flg = SEM_UNDO | IPC_NOWAIT;
+
+ sops[2].sem_num = 1;
+ sops[2].sem_op = 0;
+ sops[2].sem_flg = SEM_UNDO | IPC_NOWAIT;
+
+ sops[3].sem_num = 1;
+ sops[3].sem_op = 1;
+ sops[3].sem_flg = SEM_UNDO | IPC_NOWAIT;
+
ret = do_semop(id, sops, 4);
if (ret < 0)
return -ERRNO_TO_DSS_ERROR(errno);
static int mutex_try_lock(int id)
{
+ struct sembuf sops[2];
int ret;
- DSS_DEBUG_LOG("trying to lock\n");
- struct sembuf sops[2] = {
- {
- .sem_num = 0,
- .sem_op = 0,
- .sem_flg = SEM_UNDO | IPC_NOWAIT
- },
- {
- .sem_num = 0,
- .sem_op = 1,
- .sem_flg = SEM_UNDO | IPC_NOWAIT
- }
- };
+ DSS_DEBUG_LOG(("trying to lock\n"));
+
+ sops[0].sem_num = 0;
+ sops[0].sem_op = 0;
+ sops[0].sem_flg = SEM_UNDO | IPC_NOWAIT;
+
+ sops[1].sem_num = 0;
+ sops[1].sem_op = 1;
+ sops[1].sem_flg = SEM_UNDO | IPC_NOWAIT;
+
ret = do_semop(id, sops, 2);
if (ret < 0)
return -ERRNO_TO_DSS_ERROR(errno);
/** Log messages with lower priority than that will not be compiled in. */
#define COMPILE_TIME_LOGLEVEL 0
+/** Not all compilers support __func__ or an equivalent. */
+#if (!defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L) && !defined(__GNUC__)
+# if defined(_MSC_VER) && _MSC_VER >= 1300
+# define __func__ __FUNCTION__
+# else
+# define DSS_NO_FUNC_NAMES
+# define __func__ "<unknown>"
+# endif
+#endif
+
/** \cond */
#if DEBUG > COMPILE_TIME_LOGLEVEL
-#define DSS_DEBUG_LOG(f,...) dss_log(DEBUG, "%s: " f, __FUNCTION__, ## __VA_ARGS__)
+#define DSS_DEBUG_LOG(args) \
+ do { \
+ dss_log_set_params(DEBUG, __FILE__, __LINE__, __func__); \
+ dss_log args ; \
+ } while (0)
#else
-#define DSS_DEBUG_LOG(...) do {;} while (0)
+#define DSS_DEBUG_LOG(args) do {;} while (0)
#endif
#if INFO > COMPILE_TIME_LOGLEVEL
-#define DSS_INFO_LOG(f,...) dss_log(INFO, "%s: " f, __FUNCTION__, ## __VA_ARGS__)
+#define DSS_INFO_LOG(args) \
+ do { \
+ dss_log_set_params(INFO, __FILE__, __LINE__, __func__); \
+ dss_log args ; \
+ } while (0)
#else
-#define DSS_INFO_LOG(...) do {;} while (0)
+#define DSS_INFO_LOG(args) do {;} while (0)
#endif
#if NOTICE > COMPILE_TIME_LOGLEVEL
-#define DSS_NOTICE_LOG(f,...) dss_log(NOTICE, "%s: " f, __FUNCTION__, ## __VA_ARGS__)
+#define DSS_NOTICE_LOG(args) \
+ do { \
+ dss_log_set_params(NOTICE, __FILE__, __LINE__, __func__); \
+ dss_log args ; \
+ } while (0)
#else
-#define DSS_NOTICE_LOG(...) do {;} while (0)
+#define DSS_NOTICE_LOG(args) do {;} while (0)
#endif
#if WARNING > COMPILE_TIME_LOGLEVEL
-#define DSS_WARNING_LOG(f,...) dss_log(WARNING, "%s: " f, __FUNCTION__, ## __VA_ARGS__)
+#define DSS_WARNING_LOG(args) \
+ do { \
+ dss_log_set_params(WARNING, __FILE__, __LINE__, __func__); \
+ dss_log args ; \
+ } while (0)
#else
-#define DSS_WARNING_LOG(...) do {;} while (0)
+#define DSS_WARNING_LOG(args) do {;} while (0)
#endif
#if ERROR > COMPILE_TIME_LOGLEVEL
-#define DSS_ERROR_LOG(f,...) dss_log(ERROR, "%s: " f, __FUNCTION__, ## __VA_ARGS__)
+#define DSS_ERROR_LOG(args) \
+ do { \
+ dss_log_set_params(ERROR, __FILE__, __LINE__, __func__); \
+ dss_log args ; \
+ } while (0)
#else
-#define DSS_ERROR_LOG(...) do {;} while (0)
+#define DSS_ERROR_LOG(args) do {;} while (0)
#endif
#if CRIT > COMPILE_TIME_LOGLEVEL
-#define DSS_CRIT_LOG(f,...) dss_log(CRIT, "%s: " f, __FUNCTION__, ## __VA_ARGS__)
+#define DSS_CRIT_LOG(args) \
+ do { \
+ dss_log_set_params(CRIT, __FILE__, __LINE__, __func__); \
+ dss_log args ; \
+ } while (0)
#else
-#define DSS_CRIT_LOG(...) do {;} while (0)
+#define DSS_CRIT_LOG(args) do {;} while (0)
#endif
#if EMERG > COMPILE_TIME_LOGLEVEL
-#define DSS_EMERG_LOG(f,...) dss_log(EMERG, "%s: " f, __FUNCTION__, ## __VA_ARGS__)
+#define DSS_EMERG_LOG(args) \
+ do { \
+ dss_log_set_params(EMERG, __FILE__, __LINE__, __func__); \
+ dss_log args ; \
+ } while (0)
#else
-#define DSS_EMERG_LOG(...)
+#define DSS_EMERG_LOG(args)
#endif
--- /dev/null
+/*
+ * Copyright (C) 2004-2010 Andre Noll <maan@systemlinux.org>
+ *
+ * Licensed under the GPL v2. For licencing details see COPYING.
+ */
+
+#include <string.h>
+#include <errno.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <dirent.h>
+#include <assert.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <sys/select.h>
+
+
+#include "gcc-compat.h"
+#include "err.h"
+#include "log.h"
+#include "str.h"
+#include "file.h"
+#include "sig.h"
+
+static int signal_pipe[2];
+
+/**
+ * Initialize the signal subsystem.
+ *
+ * This function creates a pipe, the signal pipe, to deliver pending signals to
+ * the application (Bernstein's trick). It should be called during the
+ * application's startup part, followed by subsequent calls to
+ * install_sighandler() for each signal that should be caught.
+ *
+ * signal_init() installs a generic signal handler which is used for all
+ * signals simultaneously. When a signal arrives, this generic signal handler
+ * writes the corresponding signal number to the signal pipe so that the
+ * application can test for pending signals simply by checking the signal pipe
+ * for reading, e.g. by using the select(2) system call.
+ *
+ * \return This function either succeeds or calls exit(2) to terminate
+ * the current process. On success, the file descriptor of the signal pipe is
+ * returned.
+ */
+int signal_init(void)
+{
+ int ret;
+ if (pipe(signal_pipe) < 0) {
+ ret = -ERRNO_TO_DSS_ERROR(errno);
+ goto err_out;
+ }
+ ret = mark_fd_nonblocking(signal_pipe[0]);
+ if (ret < 0)
+ goto err_out;
+ ret = mark_fd_nonblocking(signal_pipe[1]);
+ if (ret < 0)
+ goto err_out;
+ return signal_pipe[0];
+err_out:
+ DSS_EMERG_LOG(("%s\n", dss_strerror(-ret)));
+ exit(EXIT_FAILURE);
+}
+
+/*
+ * just write one integer to signal pipe
+ */
+static void generic_signal_handler(int s)
+{
+ write(signal_pipe[1], &s, sizeof(int));
+}
+
+/**
+ * Reap one child.
+ *
+ * \param pid In case a child died, its pid is returned here.
+ *
+ * Call waitpid() and print a log message containing the pid and the cause of
+ * the child's death.
+ *
+ * \return A (negative) error code on errors, zero, if no child died, one
+ * otherwise. If and only if the function returns one, the content of \a pid is
+ * meaningful.
+ *
+ * \sa waitpid(2)
+ */
+int reap_child(pid_t *pid, int *status)
+{
+ *pid = waitpid(-1, status, WNOHANG);
+
+ if (!*pid)
+ return 0;
+ if (*pid < 0)
+ return -ERRNO_TO_DSS_ERROR(errno);
+ if (WIFEXITED(*status))
+ DSS_DEBUG_LOG(("child %i exited. Exit status: %i\n", (int)*pid,
+ WEXITSTATUS(*status)));
+ else if (WIFSIGNALED(*status))
+ DSS_DEBUG_LOG(("child %i was killed by signal %i\n", (int)*pid,
+ WTERMSIG(*status)));
+ else
+ DSS_WARNING_LOG(("child %i terminated abormally\n", (int)*pid));
+ return 1;
+}
+
+/**
+ * Wrapper around signal(2)
+ *
+ * \param sig The number of the signal to catch.
+ *
+ * This installs the generic signal handler for the given signal.
+ *
+ * \return This function returns 1 on success and \p -E_SIGNAL_SIG_ERR on errors.
+ * \sa signal(2)
+ */
+int install_sighandler(int sig)
+{
+ DSS_DEBUG_LOG(("catching signal %d\n", sig));
+ if (signal(sig, &generic_signal_handler) != SIG_ERR)
+ return 1;
+ return -E_SIGNAL_SIG_ERR;
+}
+
+/**
+ * Return number of next pending signal.
+ *
+ * This should be called if the fd for the signal pipe is ready for reading.
+ *
+ * \return On success, the number of the received signal is returned.
+ * If the read was interrupted by another signal the function returns 0.
+ * Otherwise a negative error code is returned.
+ */
+int next_signal(void)
+{
+ int s, err;
+ ssize_t r;
+
+ r = read(signal_pipe[0], &s, sizeof(s));
+ if (r == sizeof(s)) {
+ DSS_DEBUG_LOG(("next signal: %d\n", s));
+ return s;
+ }
+ err = errno;
+ assert(r < 0);
+ if (err == EAGAIN)
+ return 0;
+ DSS_ERROR_LOG(("failed to read from signal pipe\n"));
+ return -ERRNO_TO_DSS_ERROR(err);
+}
+
+/**
+ * Close the signal pipe.
+ */
+void signal_shutdown(void)
+{
+ close(signal_pipe[1]);
+}
--- /dev/null
+/*
+ * Copyright (C) 2007-2010 Andre Noll <maan@systemlinux.org>
+ *
+ * Licensed under the GPL v2. For licencing details see COPYING.
+ */
+
+int signal_init(void);
+int install_sighandler(int);
+int next_signal(void);
+void signal_shutdown(void);
+int reap_child(pid_t *pid, int *status);
+++ /dev/null
-/*
- * Copyright (C) 2004-2010 Andre Noll <maan@systemlinux.org>
- *
- * Licensed under the GPL v2. For licencing details see COPYING.
- */
-/** \file signal.c Signal handling functions. */
-
-#include <string.h>
-#include <errno.h>
-#include <signal.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <dirent.h>
-#include <assert.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <signal.h>
-#include <stdlib.h>
-#include <sys/select.h>
-
-
-#include "gcc-compat.h"
-#include "error.h"
-#include "log.h"
-#include "string.h"
-#include "fd.h"
-
-static int signal_pipe[2];
-
-/**
- * Initialize the signal subsystem.
- *
- * This function creates a pipe, the signal pipe, to deliver pending signals to
- * the application (Bernstein's trick). It should be called during the
- * application's startup part, followed by subsequent calls to
- * install_sighandler() for each signal that should be caught.
- *
- * signal_init() installs a generic signal handler which is used for all
- * signals simultaneously. When a signal arrives, this generic signal handler
- * writes the corresponding signal number to the signal pipe so that the
- * application can test for pending signals simply by checking the signal pipe
- * for reading, e.g. by using the select(2) system call.
- *
- * \return This function either succeeds or calls exit(2) to terminate
- * the current process. On success, the file descriptor of the signal pipe is
- * returned.
- */
-int signal_init(void)
-{
- int ret;
- if (pipe(signal_pipe) < 0) {
- ret = -ERRNO_TO_DSS_ERROR(errno);
- goto err_out;
- }
- ret = mark_fd_nonblocking(signal_pipe[0]);
- if (ret < 0)
- goto err_out;
- ret = mark_fd_nonblocking(signal_pipe[1]);
- if (ret < 0)
- goto err_out;
- return signal_pipe[0];
-err_out:
- DSS_EMERG_LOG("%s\n", dss_strerror(-ret));
- exit(EXIT_FAILURE);
-}
-
-/*
- * just write one integer to signal pipe
- */
-static void generic_signal_handler(int s)
-{
- write(signal_pipe[1], &s, sizeof(int));
-}
-
-/**
- * Reap one child.
- *
- * \param pid In case a child died, its pid is returned here.
- *
- * Call waitpid() and print a log message containing the pid and the cause of
- * the child's death.
- *
- * \return A (negative) error code on errors, zero, if no child died, one
- * otherwise. If and only if the function returns one, the content of \a pid is
- * meaningful.
- *
- * \sa waitpid(2)
- */
-int reap_child(pid_t *pid, int *status)
-{
- *pid = waitpid(-1, status, WNOHANG);
-
- if (!*pid)
- return 0;
- if (*pid < 0)
- return -ERRNO_TO_DSS_ERROR(errno);
- if (WIFEXITED(*status))
- DSS_DEBUG_LOG("child %i exited. Exit status: %i\n", (int)*pid,
- WEXITSTATUS(*status));
- else if (WIFSIGNALED(*status))
- DSS_DEBUG_LOG("child %i was killed by signal %i\n", (int)*pid,
- WTERMSIG(*status));
- else
- DSS_WARNING_LOG("child %i terminated abormally\n", (int)*pid);
- return 1;
-}
-
-/**
- * Wrapper around signal(2)
- *
- * \param sig The number of the signal to catch.
- *
- * This installs the generic signal handler for the given signal.
- *
- * \return This function returns 1 on success and \p -E_SIGNAL_SIG_ERR on errors.
- * \sa signal(2)
- */
-int install_sighandler(int sig)
-{
- DSS_DEBUG_LOG("catching signal %d\n", sig);
- if (signal(sig, &generic_signal_handler) != SIG_ERR)
- return 1;
- return -E_SIGNAL_SIG_ERR;
-}
-
-/**
- * Return number of next pending signal.
- *
- * This should be called if the fd for the signal pipe is ready for reading.
- *
- * \return On success, the number of the received signal is returned.
- * If the read was interrupted by another signal the function returns 0.
- * Otherwise a negative error code is returned.
- */
-int next_signal(void)
-{
- int s, err;
- ssize_t r;
-
- r = read(signal_pipe[0], &s, sizeof(s));
- if (r == sizeof(s)) {
- DSS_DEBUG_LOG("next signal: %d\n", s);
- return s;
- }
- err = errno;
- assert(r < 0);
- if (err == EAGAIN)
- return 0;
- DSS_ERROR_LOG("failed to read from signal pipe\n");
- return -ERRNO_TO_DSS_ERROR(err);
-}
-
-/**
- * Close the signal pipe.
- */
-void signal_shutdown(void)
-{
- close(signal_pipe[1]);
-}
+++ /dev/null
-/*
- * Copyright (C) 2007-2010 Andre Noll <maan@systemlinux.org>
- *
- * Licensed under the GPL v2. For licencing details see COPYING.
- */
-
-/** \file signal.h exported symbols from signal.c */
-
-int signal_init(void);
-int install_sighandler(int);
-int next_signal(void);
-void signal_shutdown(void);
-int reap_child(pid_t *pid, int *status);
#include <sys/time.h>
#include "gcc-compat.h"
-#include "error.h"
+#include "err.h"
#include "snap.h"
-#include "string.h"
-#include "time.h"
-#include "fd.h"
+#include "str.h"
+#include "tv.h"
+#include "file.h"
/**
* Wrapper for isdigit.
--- /dev/null
+/*
+ * Copyright (C) 2004-2010 Andre Noll <maan@systemlinux.org>
+ *
+ * Licensed under the GPL v2. For licencing details see COPYING.
+ */
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <limits.h>
+#include <errno.h>
+#include <pwd.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+
+#include "gcc-compat.h"
+#include "log.h"
+#include "err.h"
+#include "str.h"
+
+/**
+ * Write a message to a dynamically allocated string.
+ *
+ * \param fmt Usual format string.
+ * \param p Result pointer.
+ *
+ * \sa printf(3). */
+#define VSPRINTF(fmt, p) \
+{ \
+ int n; \
+ size_t size = 100; \
+ p = dss_malloc(size); \
+ while (1) { \
+ va_list ap; \
+ /* Try to print in the allocated space. */ \
+ va_start(ap, fmt); \
+ n = vsnprintf(p, size, fmt, ap); \
+ va_end(ap); \
+ /* If that worked, return the string. */ \
+ if (n > -1 && n < size) \
+ break; \
+ /* Else try again with more space. */ \
+ if (n > -1) /* glibc 2.1 */ \
+ size = n + 1; /* precisely what is needed */ \
+ else /* glibc 2.0 */ \
+ size *= 2; /* twice the old size */ \
+ p = dss_realloc(p, size); \
+ } \
+}
+
+/**
+ * dss' version of realloc().
+ *
+ * \param p Pointer to the memory block, may be \p NULL.
+ * \param size The desired new size.
+ *
+ * A wrapper for realloc(3). It calls \p exit(\p EXIT_FAILURE) on errors,
+ * i.e. there is no need to check the return value in the caller.
+ *
+ * \return A pointer to the newly allocated memory, which is suitably aligned
+ * for any kind of variable and may be different from \a p.
+ *
+ * \sa realloc(3).
+ */
+__must_check __malloc void *dss_realloc(void *p, size_t size)
+{
+ /*
+ * No need to check for NULL pointers: If p is NULL, the call
+ * to realloc is equivalent to malloc(size)
+ */
+ assert(size);
+ if (!(p = realloc(p, size))) {
+ DSS_EMERG_LOG(("realloc failed (size = %zu), aborting\n",
+ size));
+ exit(EXIT_FAILURE);
+ }
+ return p;
+}
+
+/**
+ * dss' version of malloc().
+ *
+ * \param size The desired new size.
+ *
+ * A wrapper for malloc(3) which exits on errors.
+ *
+ * \return A pointer to the allocated memory, which is suitably aligned for any
+ * kind of variable.
+ *
+ * \sa malloc(3).
+ */
+__must_check __malloc void *dss_malloc(size_t size)
+{
+ void *p;
+ assert(size);
+ p = malloc(size);
+
+ if (!p) {
+ DSS_EMERG_LOG(("malloc failed (size = %zu), aborting\n",
+ size));
+ exit(EXIT_FAILURE);
+ }
+ return p;
+}
+
+/**
+ * dss' version of calloc().
+ *
+ * \param size The desired new size.
+ *
+ * A wrapper for calloc(3) which exits on errors.
+ *
+ * \return A pointer to the allocated and zeroed-out memory, which is suitably
+ * aligned for any kind of variable.
+ *
+ * \sa calloc(3)
+ */
+__must_check __malloc void *dss_calloc(size_t size)
+{
+ void *ret = dss_malloc(size);
+
+ memset(ret, 0, size);
+ return ret;
+}
+
+/**
+ * dss' version of strdup().
+ *
+ * \param s The string to be duplicated.
+ *
+ * A wrapper for strdup(3). It calls \p exit(EXIT_FAILURE) on errors, i.e.
+ * there is no need to check the return value in the caller.
+ *
+ * \return A pointer to the duplicated string. If \p s was the NULL pointer,
+ * an pointer to an empty string is returned.
+ *
+ * \sa strdup(3)
+ */
+
+__must_check __malloc char *dss_strdup(const char *s)
+{
+ char *ret;
+
+ if ((ret = strdup(s? s: "")))
+ return ret;
+ DSS_EMERG_LOG(("strdup failed, aborting\n"));
+ exit(EXIT_FAILURE);
+}
+
+/**
+ * Allocate a sufficiently large string and print into it.
+ *
+ * \param fmt A usual format string.
+ *
+ * Produce output according to \p fmt. No artificial bound on the length of the
+ * resulting string is imposed.
+ *
+ * \return This function either returns a pointer to a string that must be
+ * freed by the caller or aborts without returning.
+ *
+ * \sa printf(3).
+ */
+__must_check __printf_1_2 __malloc char *make_message(const char *fmt, ...)
+{
+ char *msg;
+
+ VSPRINTF(fmt, msg);
+ return msg;
+}
+
+/**
+ * Get the home directory of the current user.
+ *
+ * \return A dynammically allocated string that must be freed by the caller. If
+ * the home directory could not be found, this function returns "/tmp".
+ */
+__must_check __malloc char *get_homedir(void)
+{
+ struct passwd *pw = getpwuid(getuid());
+ return dss_strdup(pw? pw->pw_dir : "/tmp");
+}
+
+/**
+ * Convert a string to a 64-bit signed integer value.
+ *
+ * \param str The string to be converted.
+ * \param value Result pointer.
+ *
+ * \return Standard.
+ *
+ * \sa strtol(3), atoi(3).
+ */
+int dss_atoi64(const char *str, int64_t *value)
+{
+ char *endptr;
+ long long tmp;
+
+ errno = 0; /* To distinguish success/failure after call */
+ tmp = strtoll(str, &endptr, 10);
+ if (errno == ERANGE && (tmp == LLONG_MAX || tmp == LLONG_MIN))
+ return -E_ATOI_OVERFLOW;
+ if (errno != 0 && tmp == 0) /* other error */
+ return -E_STRTOLL;
+ if (endptr == str)
+ return -E_ATOI_NO_DIGITS;
+ if (*endptr != '\0') /* Further characters after number */
+ return -E_ATOI_JUNK_AT_END;
+ *value = tmp;
+ return 1;
+}
+
+/**
+ * Get the logname of the current user.
+ *
+ * \return A dynammically allocated string that must be freed by the caller. On
+ * errors, the string "unknown user" is returned, i.e. this function never
+ * returns \p NULL.
+ *
+ * \sa getpwuid(3).
+ */
+__must_check __malloc char *dss_logname(void)
+{
+ struct passwd *pw = getpwuid(getuid());
+ return dss_strdup(pw? pw->pw_name : "unknown_user");
+}
+
+/**
+ * Split string and return pointers to its parts.
+ *
+ * \param args The string to be split.
+ * \param argv_ptr Pointer to the list of substrings.
+ * \param delim Delimiter.
+ *
+ * This function modifies \a args by replacing each occurance of \a delim by
+ * zero. A \p NULL-terminated array of pointers to char* is allocated dynamically
+ * and these pointers are initialized to point to the broken-up substrings
+ * within \a args. A pointer to this array is returned via \a argv_ptr.
+ *
+ * \return The number of substrings found in \a args.
+ */
+unsigned split_args(char *args, char *** const argv_ptr, const char *delim)
+{
+ char *p = args;
+ char **argv;
+ size_t n = 0, i, j;
+
+ p = args + strspn(args, delim);
+ for (;;) {
+ i = strcspn(p, delim);
+ if (!i)
+ break;
+ p += i;
+ n++;
+ p += strspn(p, delim);
+ }
+ *argv_ptr = dss_malloc((n + 1) * sizeof(char *));
+ argv = *argv_ptr;
+ i = 0;
+ p = args + strspn(args, delim);
+ while (p) {
+ argv[i] = p;
+ j = strcspn(p, delim);
+ if (!j)
+ break;
+ p += strcspn(p, delim);
+ if (*p) {
+ *p = '\0';
+ p++;
+ p += strspn(p, delim);
+ }
+ i++;
+ }
+ argv[n] = NULL;
+ return n;
+}
--- /dev/null
+__must_check __malloc void *dss_realloc(void *p, size_t size);
+__must_check __malloc void *dss_malloc(size_t size);
+__must_check __malloc void *dss_calloc(size_t size);
+__must_check __printf_1_2 __malloc char *make_message(const char *fmt, ...);
+__must_check __malloc char *dss_strdup(const char *s);
+__must_check __malloc char *get_homedir(void);
+int dss_atoi64(const char *str, int64_t *value);
+__must_check __malloc char *dss_logname(void);
+unsigned split_args(char *args, char *** const argv_ptr, const char *delim);
+
+
+/** \cond LLONG_MAX and LLONG_LIN might not be defined. */
+#ifndef LLONG_MAX
+#define LLONG_MAX (1 << (sizeof(long) - 1))
+#endif
+#ifndef LLONG_MIN
+#define LLONG_MIN (-LLONG_MAX - 1LL)
+#endif
+/** \endcond */
+
+++ /dev/null
-/*
- * Copyright (C) 2004-2010 Andre Noll <maan@systemlinux.org>
- *
- * Licensed under the GPL v2. For licencing details see COPYING.
- */
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <assert.h>
-#include <limits.h>
-#include <errno.h>
-#include <pwd.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-
-#include "gcc-compat.h"
-#include "log.h"
-#include "error.h"
-#include "string.h"
-
-/**
- * Write a message to a dynamically allocated string.
- *
- * \param fmt Usual format string.
- * \param p Result pointer.
- *
- * \sa printf(3). */
-#define VSPRINTF(fmt, p) \
-{ \
- int n; \
- size_t size = 100; \
- p = dss_malloc(size); \
- while (1) { \
- va_list ap; \
- /* Try to print in the allocated space. */ \
- va_start(ap, fmt); \
- n = vsnprintf(p, size, fmt, ap); \
- va_end(ap); \
- /* If that worked, return the string. */ \
- if (n > -1 && n < size) \
- break; \
- /* Else try again with more space. */ \
- if (n > -1) /* glibc 2.1 */ \
- size = n + 1; /* precisely what is needed */ \
- else /* glibc 2.0 */ \
- size *= 2; /* twice the old size */ \
- p = dss_realloc(p, size); \
- } \
-}
-
-/**
- * dss' version of realloc().
- *
- * \param p Pointer to the memory block, may be \p NULL.
- * \param size The desired new size.
- *
- * A wrapper for realloc(3). It calls \p exit(\p EXIT_FAILURE) on errors,
- * i.e. there is no need to check the return value in the caller.
- *
- * \return A pointer to the newly allocated memory, which is suitably aligned
- * for any kind of variable and may be different from \a p.
- *
- * \sa realloc(3).
- */
-__must_check __malloc void *dss_realloc(void *p, size_t size)
-{
- /*
- * No need to check for NULL pointers: If p is NULL, the call
- * to realloc is equivalent to malloc(size)
- */
- assert(size);
- if (!(p = realloc(p, size))) {
- DSS_EMERG_LOG("realloc failed (size = %zu), aborting\n",
- size);
- exit(EXIT_FAILURE);
- }
- return p;
-}
-
-/**
- * dss' version of malloc().
- *
- * \param size The desired new size.
- *
- * A wrapper for malloc(3) which exits on errors.
- *
- * \return A pointer to the allocated memory, which is suitably aligned for any
- * kind of variable.
- *
- * \sa malloc(3).
- */
-__must_check __malloc void *dss_malloc(size_t size)
-{
- void *p;
- assert(size);
- p = malloc(size);
-
- if (!p) {
- DSS_EMERG_LOG("malloc failed (size = %zu), aborting\n",
- size);
- exit(EXIT_FAILURE);
- }
- return p;
-}
-
-/**
- * dss' version of calloc().
- *
- * \param size The desired new size.
- *
- * A wrapper for calloc(3) which exits on errors.
- *
- * \return A pointer to the allocated and zeroed-out memory, which is suitably
- * aligned for any kind of variable.
- *
- * \sa calloc(3)
- */
-__must_check __malloc void *dss_calloc(size_t size)
-{
- void *ret = dss_malloc(size);
-
- memset(ret, 0, size);
- return ret;
-}
-
-/**
- * dss' version of strdup().
- *
- * \param s The string to be duplicated.
- *
- * A wrapper for strdup(3). It calls \p exit(EXIT_FAILURE) on errors, i.e.
- * there is no need to check the return value in the caller.
- *
- * \return A pointer to the duplicated string. If \p s was the NULL pointer,
- * an pointer to an empty string is returned.
- *
- * \sa strdup(3)
- */
-
-__must_check __malloc char *dss_strdup(const char *s)
-{
- char *ret;
-
- if ((ret = strdup(s? s: "")))
- return ret;
- DSS_EMERG_LOG("strdup failed, aborting\n");
- exit(EXIT_FAILURE);
-}
-
-/**
- * Allocate a sufficiently large string and print into it.
- *
- * \param fmt A usual format string.
- *
- * Produce output according to \p fmt. No artificial bound on the length of the
- * resulting string is imposed.
- *
- * \return This function either returns a pointer to a string that must be
- * freed by the caller or aborts without returning.
- *
- * \sa printf(3).
- */
-__must_check __printf_1_2 __malloc char *make_message(const char *fmt, ...)
-{
- char *msg;
-
- VSPRINTF(fmt, msg);
- return msg;
-}
-
-/**
- * Get the home directory of the current user.
- *
- * \return A dynammically allocated string that must be freed by the caller. If
- * the home directory could not be found, this function returns "/tmp".
- */
-__must_check __malloc char *get_homedir(void)
-{
- struct passwd *pw = getpwuid(getuid());
- return dss_strdup(pw? pw->pw_dir : "/tmp");
-}
-
-/**
- * Convert a string to a 64-bit signed integer value.
- *
- * \param str The string to be converted.
- * \param value Result pointer.
- *
- * \return Standard.
- *
- * \sa strtol(3), atoi(3).
- */
-int dss_atoi64(const char *str, int64_t *value)
-{
- char *endptr;
- long long tmp;
-
- errno = 0; /* To distinguish success/failure after call */
- tmp = strtoll(str, &endptr, 10);
- if (errno == ERANGE && (tmp == LLONG_MAX || tmp == LLONG_MIN))
- return -E_ATOI_OVERFLOW;
- if (errno != 0 && tmp == 0) /* other error */
- return -E_STRTOLL;
- if (endptr == str)
- return -E_ATOI_NO_DIGITS;
- if (*endptr != '\0') /* Further characters after number */
- return -E_ATOI_JUNK_AT_END;
- *value = tmp;
- return 1;
-}
-
-/**
- * Get the logname of the current user.
- *
- * \return A dynammically allocated string that must be freed by the caller. On
- * errors, the string "unknown user" is returned, i.e. this function never
- * returns \p NULL.
- *
- * \sa getpwuid(3).
- */
-__must_check __malloc char *dss_logname(void)
-{
- struct passwd *pw = getpwuid(getuid());
- return dss_strdup(pw? pw->pw_name : "unknown_user");
-}
-
-/**
- * Split string and return pointers to its parts.
- *
- * \param args The string to be split.
- * \param argv_ptr Pointer to the list of substrings.
- * \param delim Delimiter.
- *
- * This function modifies \a args by replacing each occurance of \a delim by
- * zero. A \p NULL-terminated array of pointers to char* is allocated dynamically
- * and these pointers are initialized to point to the broken-up substrings
- * within \a args. A pointer to this array is returned via \a argv_ptr.
- *
- * \return The number of substrings found in \a args.
- */
-unsigned split_args(char *args, char *** const argv_ptr, const char *delim)
-{
- char *p = args;
- char **argv;
- size_t n = 0, i, j;
-
- p = args + strspn(args, delim);
- for (;;) {
- i = strcspn(p, delim);
- if (!i)
- break;
- p += i;
- n++;
- p += strspn(p, delim);
- }
- *argv_ptr = dss_malloc((n + 1) * sizeof(char *));
- argv = *argv_ptr;
- i = 0;
- p = args + strspn(args, delim);
- while (p) {
- argv[i] = p;
- j = strcspn(p, delim);
- if (!j)
- break;
- p += strcspn(p, delim);
- if (*p) {
- *p = '\0';
- p++;
- p += strspn(p, delim);
- }
- i++;
- }
- argv[n] = NULL;
- return n;
-}
+++ /dev/null
-__must_check __malloc void *dss_realloc(void *p, size_t size);
-__must_check __malloc void *dss_malloc(size_t size);
-__must_check __malloc void *dss_calloc(size_t size);
-__must_check __printf_1_2 __malloc char *make_message(const char *fmt, ...);
-__must_check __malloc char *dss_strdup(const char *s);
-__must_check __malloc char *get_homedir(void);
-int dss_atoi64(const char *str, int64_t *value);
-__must_check __malloc char *dss_logname(void);
-unsigned split_args(char *args, char *** const argv_ptr, const char *delim);
-
-
-/** \cond LLONG_MAX and LLONG_LIN might not be defined. */
-#ifndef LLONG_MAX
-#define LLONG_MAX (1 << (sizeof(long) - 1))
-#endif
-#ifndef LLONG_MIN
-#define LLONG_MIN (-LLONG_MAX - 1LL)
-#endif
-/** \endcond */
-
+++ /dev/null
-/*
- * Copyright (C) 2005-2010 Andre Noll <maan@systemlinux.org>
- *
- * Licensed under the GPL v2. For licencing details see COPYING.
- */
-
-/** \file time.c Helper functions for dealing with time values. */
-
-#include <sys/time.h>
-#include <time.h>
-#include <inttypes.h>
-#include <assert.h>
-#include <string.h>
-
-#include "gcc-compat.h"
-#include "error.h"
-#include "string.h"
-#include "log.h"
-
-/**
- * Convert struct timeval to milliseconds.
- *
- * \param tv The time value value to convert.
- *
- * \return The number off milliseconds in \a tv.
- */
-long unsigned tv2ms(const struct timeval *tv)
-{
- return tv->tv_sec * 1000 + (tv->tv_usec + 500)/ 1000;
-}
-
-/**
- * Convert milliseconds to a struct timeval.
- *
- * \param n The number of milliseconds.
- * \param tv Result pointer.
- */
-void ms2tv(long unsigned n, struct timeval *tv)
-{
- tv->tv_sec = n / 1000;
- tv->tv_usec = (n % 1000) * 1000;
-}
-
-/**
- * Convert a double to a struct timeval.
- *
- * \param x The value to convert.
- * \param tv Result pointer.
- */
-void d2tv(double x, struct timeval *tv)
-{
- tv->tv_sec = x;
- tv->tv_usec = (x - (double)tv->tv_sec) * 1000.0 * 1000.0 + 0.5;
-}
-
-/**
- * Compute the difference of two time values.
- *
- * \param b Minuend.
- * \param a Subtrahend.
- * \param diff Result pointer.
- *
- * If \a diff is not \p NULL, it contains the absolute value |\a b - \a a| on
- * return.
- *
- * \return If \a b < \a a, this function returns -1, otherwise it returns 1.
- */
-int tv_diff(const struct timeval *b, const struct timeval *a, struct timeval *diff)
-{
- int ret = 1;
-
- if ((b->tv_sec < a->tv_sec) ||
- ((b->tv_sec == a->tv_sec) && (b->tv_usec < a->tv_usec))) {
- const struct timeval *tmp = a;
- a = b;
- b = tmp;
- ret = -1;
- }
- if (!diff)
- return ret;
- diff->tv_sec = b->tv_sec - a->tv_sec;
- if (b->tv_usec < a->tv_usec) {
- diff->tv_sec--;
- diff->tv_usec = 1000 * 1000 - a->tv_usec + b->tv_usec;
- } else
- diff->tv_usec = b->tv_usec - a->tv_usec;
- return ret;
-}
-
-/**
- * Add two time values.
- *
- * \param a First addend.
- * \param b Second addend.
- * \param sum Contains the sum \a + \a b on return.
- */
-void tv_add(const struct timeval *a, const struct timeval *b,
- struct timeval *sum)
-{
- sum->tv_sec = a->tv_sec + b->tv_sec;
- if (a->tv_usec + b->tv_usec >= 1000 * 1000) {
- sum->tv_sec++;
- sum->tv_usec = a->tv_usec + b->tv_usec - 1000 * 1000;
- } else
- sum->tv_usec = a->tv_usec + b->tv_usec;
-}
-
-/**
- * Compute integer multiple of given struct timeval.
- *
- * \param mult The integer value to multiply with.
- * \param tv The timevalue to multiply.
- *
- * \param result Contains \a mult * \a tv on return.
- */
-void tv_scale(const unsigned long mult, const struct timeval *tv,
- struct timeval *result)
-{
- result->tv_sec = mult * tv->tv_sec;
- result->tv_sec += tv->tv_usec * mult / 1000 / 1000;
- result->tv_usec = tv->tv_usec * mult % (1000 * 1000);
-}
-
-/**
- * Compute a fraction of given struct timeval.
- *
- * \param divisor The integer value to divide by.
- * \param tv The timevalue to divide.
- * \param result Contains (1 / mult) * tv on return.
- */
-void tv_divide(const unsigned long divisor, const struct timeval *tv,
- struct timeval *result)
-{
- uint64_t x = ((uint64_t)tv->tv_sec * 1000 * 1000 + tv->tv_usec) / divisor;
-
- result->tv_sec = x / 1000 / 1000;
- result->tv_usec = x % (1000 * 1000);
-}
-
-int64_t get_current_time(void)
-{
- time_t now;
- time(&now);
- DSS_DEBUG_LOG("now: %jd\n", (intmax_t)now);
- return (int64_t)now;
-}
+++ /dev/null
-int tv_diff(const struct timeval *b, const struct timeval *a, struct timeval *diff);
-long unsigned tv2ms(const struct timeval*);
-void d2tv(double, struct timeval*);
-void tv_add(const struct timeval*, const struct timeval *, struct timeval *);
-void tv_scale(const unsigned long, const struct timeval *, struct timeval *);
-void tv_divide(const unsigned long divisor, const struct timeval *tv,
- struct timeval *result);
-void ms2tv(const long unsigned n, struct timeval *tv);
-int64_t get_current_time(void);
--- /dev/null
+/*
+ * Copyright (C) 2005-2010 Andre Noll <maan@systemlinux.org>
+ *
+ * Licensed under the GPL v2. For licencing details see COPYING.
+ */
+
+#include <sys/time.h>
+#include <time.h>
+#include <inttypes.h>
+#include <assert.h>
+#include <string.h>
+
+#include "gcc-compat.h"
+#include "err.h"
+#include "str.h"
+#include "log.h"
+#include "time.h"
+
+/**
+ * Convert struct timeval to milliseconds.
+ *
+ * \param tv The time value value to convert.
+ *
+ * \return The number off milliseconds in \a tv.
+ */
+long unsigned tv2ms(const struct timeval *tv)
+{
+ return tv->tv_sec * 1000 + (tv->tv_usec + 500)/ 1000;
+}
+
+/**
+ * Convert milliseconds to a struct timeval.
+ *
+ * \param n The number of milliseconds.
+ * \param tv Result pointer.
+ */
+void ms2tv(long unsigned n, struct timeval *tv)
+{
+ tv->tv_sec = n / 1000;
+ tv->tv_usec = (n % 1000) * 1000;
+}
+
+/**
+ * Convert a double to a struct timeval.
+ *
+ * \param x The value to convert.
+ * \param tv Result pointer.
+ */
+void d2tv(double x, struct timeval *tv)
+{
+ tv->tv_sec = x;
+ tv->tv_usec = (x - (double)tv->tv_sec) * 1000.0 * 1000.0 + 0.5;
+}
+
+/**
+ * Compute the difference of two time values.
+ *
+ * \param b Minuend.
+ * \param a Subtrahend.
+ * \param diff Result pointer.
+ *
+ * If \a diff is not \p NULL, it contains the absolute value |\a b - \a a| on
+ * return.
+ *
+ * \return If \a b < \a a, this function returns -1, otherwise it returns 1.
+ */
+int tv_diff(const struct timeval *b, const struct timeval *a, struct timeval *diff)
+{
+ int ret = 1;
+
+ if ((b->tv_sec < a->tv_sec) ||
+ ((b->tv_sec == a->tv_sec) && (b->tv_usec < a->tv_usec))) {
+ const struct timeval *tmp = a;
+ a = b;
+ b = tmp;
+ ret = -1;
+ }
+ if (!diff)
+ return ret;
+ diff->tv_sec = b->tv_sec - a->tv_sec;
+ if (b->tv_usec < a->tv_usec) {
+ diff->tv_sec--;
+ diff->tv_usec = 1000 * 1000 - a->tv_usec + b->tv_usec;
+ } else
+ diff->tv_usec = b->tv_usec - a->tv_usec;
+ return ret;
+}
+
+/**
+ * Add two time values.
+ *
+ * \param a First addend.
+ * \param b Second addend.
+ * \param sum Contains the sum \a + \a b on return.
+ */
+void tv_add(const struct timeval *a, const struct timeval *b,
+ struct timeval *sum)
+{
+ sum->tv_sec = a->tv_sec + b->tv_sec;
+ if (a->tv_usec + b->tv_usec >= 1000 * 1000) {
+ sum->tv_sec++;
+ sum->tv_usec = a->tv_usec + b->tv_usec - 1000 * 1000;
+ } else
+ sum->tv_usec = a->tv_usec + b->tv_usec;
+}
+
+/**
+ * Compute integer multiple of given struct timeval.
+ *
+ * \param mult The integer value to multiply with.
+ * \param tv The timevalue to multiply.
+ *
+ * \param result Contains \a mult * \a tv on return.
+ */
+void tv_scale(const unsigned long mult, const struct timeval *tv,
+ struct timeval *result)
+{
+ result->tv_sec = mult * tv->tv_sec;
+ result->tv_sec += tv->tv_usec * mult / 1000 / 1000;
+ result->tv_usec = tv->tv_usec * mult % (1000 * 1000);
+}
+
+/**
+ * Compute a fraction of given struct timeval.
+ *
+ * \param divisor The integer value to divide by.
+ * \param tv The timevalue to divide.
+ * \param result Contains (1 / mult) * tv on return.
+ */
+void tv_divide(const unsigned long divisor, const struct timeval *tv,
+ struct timeval *result)
+{
+ uint64_t x = ((uint64_t)tv->tv_sec * 1000 * 1000 + tv->tv_usec) / divisor;
+
+ result->tv_sec = x / 1000 / 1000;
+ result->tv_usec = x % (1000 * 1000);
+}
+
+int64_t get_current_time(void)
+{
+ time_t now;
+ time(&now);
+ DSS_DEBUG_LOG(("now: %jd\n", (intmax_t)now));
+ return (int64_t)now;
+}
--- /dev/null
+int tv_diff(const struct timeval *b, const struct timeval *a, struct timeval *diff);
+long unsigned tv2ms(const struct timeval*);
+void d2tv(double, struct timeval*);
+void tv_add(const struct timeval*, const struct timeval *, struct timeval *);
+void tv_scale(const unsigned long, const struct timeval *, struct timeval *);
+void tv_divide(const unsigned long divisor, const struct timeval *tv,
+ struct timeval *result);
+void ms2tv(const long unsigned n, struct timeval *tv);
+int64_t get_current_time(void);