X-Git-Url: http://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=tools%2Ftools.c;h=2a776f062a354cea9f233b011ef1a4122038d3b1;hp=2983cfca663bc730130899ae96cb16a75e62baa2;hb=dc8042b42500f79f613b1197df6cdf739615a89f;hpb=0939b69164c65329fa8f6b2c4ab5e9c7d9162678 diff --git a/tools/tools.c b/tools/tools.c index 2983cfca..2a776f06 100644 --- a/tools/tools.c +++ b/tools/tools.c @@ -1,8 +1,10 @@ -#include -#include +#include +#include #include +#include #include #include +#include #include #include #include @@ -12,49 +14,49 @@ #include #include #include -#include #include +#include +#include #include "tools.h" -static char *tmpdir = NULL; -static unsigned int count; +static const char *tmpdir = NULL; bool tools_verbose = false; /* Ten minutes. */ const unsigned int default_timeout_ms = 10 * 60 * 1000; -char *talloc_basename(const void *ctx, const char *dir) +char *tal_basename(const void *ctx, const char *dir) { - char *p = strrchr(dir, '/'); + const char *p = strrchr(dir, '/'); if (!p) - return talloc_strdup(ctx, dir); - return talloc_strdup(ctx, p+1); + return tal_strdup(ctx, dir); + return tal_strdup(ctx, p+1); } -char *talloc_dirname(const void *ctx, const char *dir) +char *tal_dirname(const void *ctx, const char *dir) { - char *p = strrchr(dir, '/'); + const char *p = strrchr(dir, '/'); if (!p) - return talloc_strdup(ctx, "."); - return talloc_strndup(ctx, dir, p - dir); + return tal_strdup(ctx, "."); + return tal_strndup(ctx, dir, p - dir); } -char *talloc_getcwd(const void *ctx) +char *tal_getcwd(const void *ctx) { unsigned int len; char *cwd; /* *This* is why people hate C. */ len = 32; - cwd = talloc_array(ctx, char, len); + cwd = tal_arr(ctx, char, len); while (!getcwd(cwd, len)) { if (errno != ERANGE) { - talloc_free(cwd); + tal_free(cwd); return NULL; } - cwd = talloc_realloc(ctx, cwd, char, len *= 2); + tal_resize(&cwd, len *= 2); } return cwd; } @@ -69,26 +71,26 @@ char *run_with_timeout(const void *ctx, const char *cmd, { pid_t pid; int p[2]; - char *ret; + struct rbuf in; int status, ms; - struct timeval start, end; + struct timespec start; *ok = false; if (pipe(p) != 0) - return talloc_asprintf(ctx, "Failed to create pipe: %s", - strerror(errno)); + return tal_fmt(ctx, "Failed to create pipe: %s", + strerror(errno)); if (tools_verbose) printf("Running: %s\n", cmd); - gettimeofday(&start, NULL); + /* Always flush buffers before fork! */ + fflush(stdout); + start = time_now(); pid = fork(); if (pid == -1) { close_noerr(p[0]); close_noerr(p[1]); - return talloc_asprintf(ctx, "Failed to fork: %s", - strerror(errno)); - return NULL; + return tal_fmt(ctx, "Failed to fork: %s", strerror(errno)); } if (pid == 0) { @@ -103,8 +105,7 @@ char *run_with_timeout(const void *ctx, const char *cmd, signal(SIGALRM, killme); itim.it_interval.tv_sec = itim.it_interval.tv_usec = 0; - itim.it_value.tv_sec = *timeout_ms / 1000; - itim.it_value.tv_usec = (*timeout_ms % 1000) * 1000; + itim.it_value = timespec_to_timeval(time_from_msec(*timeout_ms)); setitimer(ITIMER_REAL, &itim, NULL); status = system(cmd); @@ -115,66 +116,62 @@ char *run_with_timeout(const void *ctx, const char *cmd, } close(p[1]); - ret = grab_fd(ctx, p[0], NULL); + rbuf_init(&in, p[0], tal_arr(ctx, char, 4096), 4096); + if (!rbuf_read_str(&in, 0, do_tal_realloc) && errno) + in.buf = tal_free(in.buf); + /* This shouldn't fail... */ if (waitpid(pid, &status, 0) != pid) err(1, "Failed to wait for child"); - gettimeofday(&end, NULL); - if (end.tv_usec < start.tv_usec) { - end.tv_usec += 1000000; - end.tv_sec--; - } - ms = (end.tv_sec - start.tv_sec) * 1000 - + (end.tv_usec - start.tv_usec) / 1000; + ms = time_to_msec(time_sub(time_now(), start)); if (ms > *timeout_ms) *timeout_ms = 0; else *timeout_ms -= ms; - + close(p[0]); if (tools_verbose) { - printf("%s", ret); + printf("%s", in.buf); printf("Finished: %u ms, %s %u\n", ms, WIFEXITED(status) ? "exit status" : "killed by signal", WIFEXITED(status) ? WEXITSTATUS(status) : WTERMSIG(status)); } *ok = (WIFEXITED(status) && WEXITSTATUS(status) == 0); - return ret; + return in.buf; } -/* Returns output if command fails. */ -char *run_command(const void *ctx, unsigned int *time_ms, const char *fmt, ...) +/* Tals *output off ctx; return false if command fails. */ +bool run_command(const void *ctx, unsigned int *time_ms, char **output, + const char *fmt, ...) { va_list ap; - char *cmd, *contents; + char *cmd; bool ok; unsigned int default_time = default_timeout_ms; if (!time_ms) time_ms = &default_time; - else if (*time_ms == 0) - return talloc_strdup(ctx, "\n== TIMED OUT ==\n"); + else if (*time_ms == 0) { + *output = tal_strdup(ctx, "\n== TIMED OUT ==\n"); + return false; + } va_start(ap, fmt); - cmd = talloc_vasprintf(ctx, fmt, ap); + cmd = tal_vfmt(ctx, fmt, ap); va_end(ap); - contents = run_with_timeout(ctx, cmd, &ok, time_ms); - if (ok) { - talloc_free(contents); - return NULL; - } - - if (!contents) + *output = run_with_timeout(ctx, cmd, &ok, time_ms); + if (ok) + return true; + if (!*output) err(1, "Problem running child"); if (*time_ms == 0) - contents = talloc_asprintf_append(contents, - "\n== TIMED OUT ==\n"); - return contents; + *output = tal_strcat(ctx, take(*output), "\n== TIMED OUT ==\n"); + return false; } -static int unlink_all(char *dir) +static void unlink_all(const char *dir) { char cmd[strlen(dir) + sizeof("rm -rf ")]; sprintf(cmd, "rm -rf %s", dir); @@ -182,56 +179,78 @@ static int unlink_all(char *dir) printf("Running: %s\n", cmd); if (system(cmd) != 0) warn("Could not remove temporary work in %s", dir); - return 0; } -char *temp_dir(const void *ctx) +static pid_t *afree; +static void free_autofree(void) +{ + if (*afree == getpid()) + tal_free(afree); +} + +tal_t *autofree(void) +{ + if (!afree) { + afree = tal(NULL, pid_t); + *afree = getpid(); + atexit(free_autofree); + } + return afree; +} + +const char *temp_dir(void) { /* For first call, create dir. */ while (!tmpdir) { tmpdir = getenv("TMPDIR"); if (!tmpdir) tmpdir = "/tmp"; - tmpdir = talloc_asprintf(talloc_autofree_context(), - "%s/ccanlint-%u.%lu", - tmpdir, getpid(), random()); + tmpdir = tal_fmt(autofree(), "%s/ccanlint-%u.%lu", + tmpdir, getpid(), random()); if (mkdir(tmpdir, 0700) != 0) { if (errno == EEXIST) { - talloc_free(tmpdir); + tal_free(tmpdir); tmpdir = NULL; continue; } err(1, "mkdir %s failed", tmpdir); } - talloc_set_destructor(tmpdir, unlink_all); + tal_add_destructor(tmpdir, unlink_all); + if (tools_verbose) + printf("Created temporary directory %s\n", tmpdir); } - if (tools_verbose) - printf("Created temporary directory %s\n", tmpdir); return tmpdir; } -char *temp_file(const void *ctx, const char *extension) +void keep_temp_dir(void) { - char *f = talloc_asprintf(ctx, "%s/%u%s", - temp_dir(ctx), count++, extension); - if (tools_verbose) - printf("Created temporary file %s\n", f); - return f; + tal_del_destructor(temp_dir(), unlink_all); } -char *maybe_temp_file(const void *ctx, const char *extension, bool keep, - const char *srcname) +char *temp_file(const void *ctx, const char *extension, const char *srcname) { - size_t baselen; - char *f; + unsigned baselen; + char *f, *suffix = tal_strdup(ctx, ""); + struct stat st; + unsigned int count = 0; + + srcname = tal_basename(ctx, srcname); + if (strrchr(srcname, '.')) + baselen = strrchr(srcname, '.') - srcname; + else + baselen = strlen(srcname); - if (!keep) - return temp_file(ctx, extension); + do { + f = tal_fmt(ctx, "%s/%.*s%s%s", + temp_dir(), baselen, srcname, suffix, extension); + tal_free(suffix); + suffix = tal_fmt(ctx, "-%u", ++count); + } while (lstat(f, &st) == 0); - baselen = strrchr(srcname, '.') - srcname; - f = talloc_asprintf(ctx, "%.*s%s", baselen, srcname, extension); if (tools_verbose) printf("Creating file %s\n", f); + + tal_free(suffix); return f; } @@ -253,7 +272,7 @@ bool move_file(const char *oldname, const char *newname) } /* Try copy and delete: not atomic! */ - contents = grab_file(NULL, oldname, &size); + contents = tal_grab_file(NULL, oldname, &size); if (!contents) { if (tools_verbose) printf("read failed: %s\n", strerror(errno)); @@ -283,6 +302,32 @@ bool move_file(const char *oldname, const char *newname) } free: - talloc_free(contents); + tal_free(contents); return ret; } + +void *do_tal_realloc(void *p, size_t size) +{ + tal_resize((char **)&p, size); + return p; +} + +void *tal_grab_file(const void *ctx, const char *filename, size_t *size) +{ + struct rbuf rbuf; + char *buf = tal_arr(ctx, char, 0); + + if (!rbuf_open(&rbuf, filename, buf, 0)) + return tal_free(buf); + + if (!rbuf_fill_all(&rbuf, do_tal_realloc) && errno) + rbuf.buf = tal_free(rbuf.buf); + else { + rbuf.buf[rbuf.len] = '\0'; + if (size) + *size = rbuf.len; + } + close(rbuf.fd); + + return rbuf.buf; +}