// Copyright (2013) Jann Horn <jann@thejh.net>
-// This code is licensed under the AGPLv3.
HEADER #include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
-#include <stdbool.h>
+HEADER #include <stdbool.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
+#include <sys/mman.h>
// Wrapper for `read` that retries on partial reads.
// If last_res is non-NULL, it will be filled with the
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;
// - -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, const 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;
// 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
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)) {
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);
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;
}
}
}
-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);
// 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;
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;
+}
projects / libjh.git / blobdiff