X-Git-Url: http://git.thejh.net/?p=libjh.git;a=blobdiff_plain;f=io.c;h=ef1f9125f75e3c07782dbcbdac9b391fc328eae2;hp=a7696f9f7fd74c277b7914483d81c8ad8b7213b8;hb=d8f6e4ade23d1a31e538244c596c7d459738b9e8;hpb=483ad7514b32f4557c8866bbde2091aed69e98b4;ds=sidebyside diff --git a/io.c b/io.c index a7696f9..ef1f912 100644 --- a/io.c +++ b/io.c @@ -1,11 +1,10 @@ // Copyright (2013) Jann Horn -// This code is licensed under the AGPLv3. HEADER #include #include #include #include -#include +HEADER #include #include #include #include @@ -24,6 +23,7 @@ PUBLIC_FN ssize_t read_nointr(int fd, void *buf, size_t count, int *last_res) { size_t done = 0; while (done < count) { ssize_t part_res = read(fd, buf+done, count-done); + if (part_res == -1 && errno == EINTR) continue; if (part_res <= 0) { if (last_res) *last_res = part_res; if (done) return done; @@ -42,11 +42,13 @@ PUBLIC_FN ssize_t read_nointr(int fd, void *buf, size_t count, int *last_res) { // - -1: error // - 0: stream ended // - 1: no problems occured -PUBLIC_FN ssize_t write_nointr(int fd, void *buf, size_t count, int *last_res) { +PUBLIC_FN ssize_t write_nointr(int fd, void *buf, ssize_t count, int *last_res) { + if (count == -1) count = strlen(buf); errno = 0; size_t done = 0; while (done < count) { ssize_t part_res = write(fd, buf+done, count-done); + if (part_res == -1 && errno == EINTR) continue; if (part_res <= 0) { if (last_res) *last_res = part_res; if (done) return done; @@ -66,7 +68,11 @@ PUBLIC_FN ssize_t write_nointr(int fd, void *buf, size_t count, int *last_res) { // this and can specify len_out as NULL. PUBLIC_CONST JH_SLURP_NO_STAT 1 PUBLIC_CONST JH_SLURP_REALLOC 2 /* realloc result block if it saves RAM */ -PUBLIC_FN char *slurp_fd(int fd, size_t *len_out, int flags) { +PUBLIC_CONST JH_SLURP_8BYTE_PAD 4 /* pad buffer with eight nullbytes, not one */ +PUBLIC_CONST JH_SLURP_FIXSIZE 8 /* len_out is actually input and specifies +HEADER the expected length. if there is more data, +HEADER that might be ignored silently. */ +PUBLIC_FN void *slurp_fd(int fd, size_t *len_out, int flags) { int errno_; // Let's just guess that the file is 1023 bytes. Will become 1024 with @@ -74,6 +80,15 @@ PUBLIC_FN char *slurp_fd(int fd, size_t *len_out, int flags) { size_t size_guess = 1023; bool trusted_guess = false; /* can we rely on the guess? */ + if (flags&JH_SLURP_FIXSIZE) { + size_guess = *len_out; + trusted_guess = true; + // if we want a fixed size, of course we don't want to stat + flags |= JH_SLURP_NO_STAT; + } + + int padlen = (flags&JH_SLURP_8BYTE_PAD)?8:1; + // If we can determine the exact size, we don't have to guess. So try // to determine the exact size. if (!(flags&JH_SLURP_NO_STAT)) { @@ -90,7 +105,7 @@ PUBLIC_FN char *slurp_fd(int fd, size_t *len_out, int flags) { int done = 0; while (1) { - buf = realloc(buf, size_guess+1); + buf = realloc(buf, size_guess+padlen); if (buf == NULL) return NULL; int last_res; ssize_t read_res = read_nointr(fd, buf+done, size_guess-done, &last_res); @@ -98,14 +113,24 @@ PUBLIC_FN char *slurp_fd(int fd, size_t *len_out, int flags) { done += read_res; if (last_res == 0 || trusted_guess) { // out - buf[done] = '\0'; + if (padlen == 1) { + buf[done] = '\0'; + } else { + *(uint64_t*)(buf+done) = 0; + } if (done != size_guess && (flags&JH_SLURP_REALLOC)) { // Well, it'd be weird if shrinking could fail... but meh, I can't find // an explicit statement about this being disallowed, so try staying on // the safe side. - char *buf_ = realloc(buf, done+1); + char *buf_ = realloc(buf, done+padlen); if (buf_) buf = buf_; } + if (done != size_guess && (flags&JH_SLURP_FIXSIZE)) { + free(buf); + // not the most correct error message ever, but whatever. + errno = EFBIG; + return NULL; + } if (len_out) *len_out = done; return buf; } @@ -113,7 +138,7 @@ PUBLIC_FN char *slurp_fd(int fd, size_t *len_out, int flags) { } } -PUBLIC_FN char *slurp_file(char *path, size_t *len_out, int flags) { +PUBLIC_FN void *slurp_file(char *path, size_t *len_out, int flags) { int fd = open(path, O_RDONLY|O_CLOEXEC); if (fd == -1) return NULL; char *res = slurp_fd(fd, len_out, flags); @@ -125,10 +150,10 @@ PUBLIC_FN char *slurp_file(char *path, size_t *len_out, int flags) { // Write data into a file. len can be -1; that means that // the real length is strlen(buf). -PUBLIC_FN int write_file(char *path, char *buf, ssize_t len, int open_flags) { +PUBLIC_FN int write_file(char *path, void *buf, ssize_t len, int open_flags) { if (len == -1) len = strlen(buf); - int fd = open(path, open_flags|O_CLOEXEC, 0777); + int fd = open(path, open_flags|O_CLOEXEC|O_WRONLY, 0777); if (fd == -1) return 1; ssize_t write_res = write_nointr(fd, buf, len, NULL); int write_errno = errno; @@ -156,3 +181,37 @@ PUBLIC_FN void *mmap_file(void *addr, size_t length, int prot, int flags, char * errno = errno_; return (r==MAP_FAILED) ? NULL : r; } + +// on error, fd remains unchanged, no matter whether you specified "keep" or not +HEADER #define JH_OBS_KEEPFD 1 +HEADER #define JH_OBS_BUFFER 2 +PUBLIC_FN int fopen_bistream(FILE **in, FILE **out, int fd, int flags) { + // check input + if (fd < 0) goto err_out; + bool keep = flags & JH_OBS_KEEPFD; + bool buffer = flags & JH_OBS_BUFFER; + + // create input FILE* + int in_fd = dup(fd); + if (in_fd < 0) goto err_out; + *in = fdopen(in_fd, "r"); + if (!*in) { close(in_fd); goto err_out; } + + // create output FILE* + int out_fd = keep ? dup(fd) : fd; + if (out_fd < 0) goto err_dup_out; + *out = fdopen(out_fd, "w"); + if (!*out) { if (keep) close(out_fd); goto err_dup_out; } + + // avoid buffering data unless the caller really wants it + if (!buffer) setbuf(*out, NULL); + + // success! + return 0; + + +err_dup_out: + fclose(*in); +err_out: + return EAI_SYSTEM; +} \ No newline at end of file