X-Git-Url: http://git.thejh.net/?p=libjh.git;a=blobdiff_plain;f=io.c;h=ef1f9125f75e3c07782dbcbdac9b391fc328eae2;hp=d3b9a6d5599dfbe170a3d0047a7f44bad41a014c;hb=d8f6e4ade23d1a31e538244c596c7d459738b9e8;hpb=e3a7f339e843d1424aef577e5634ac70343ec49c;ds=sidebyside diff --git a/io.c b/io.c index d3b9a6d..ef1f912 100644 --- a/io.c +++ b/io.c @@ -1,11 +1,15 @@ +// Copyright (2013) Jann Horn + HEADER #include #include #include #include -#include +HEADER #include #include #include #include +#include +#include // Wrapper for `read` that retries on partial reads. // If last_res is non-NULL, it will be filled with the @@ -19,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; @@ -37,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; @@ -61,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 @@ -69,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)) { @@ -85,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); @@ -93,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; } @@ -108,8 +138,8 @@ 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) { - int fd = open(path, O_RDONLY); +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); int errno_ = errno; @@ -120,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, 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; @@ -135,3 +165,53 @@ PUBLIC_FN int write_file(char *path, char *buf, ssize_t len, int open_flags) { if (close_res) return 1; return 0; } + +PUBLIC_FN void *mmap_file(void *addr, size_t length, int prot, int flags, char *path, off_t offset) { + assert((flags&MAP_ANONYMOUS) == 0); + assert(prot&(PROT_EXEC|PROT_READ|PROT_WRITE)); + int open_flags = O_CLOEXEC; + if ((prot & (PROT_READ|PROT_EXEC)) && !(prot&PROT_WRITE)) open_flags |= O_RDONLY; + else if ((prot & (PROT_READ|PROT_EXEC))) open_flags |= O_RDWR; + else open_flags |= O_WRONLY; + int fd = open(path, open_flags); + if (fd == -1) return NULL; + void *r = mmap(addr, length, prot, flags, fd, offset); + int errno_ = errno; + close(fd); + 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