1 // Copyright (2013) Jann Horn <jann@thejh.net>
2 // This code is licensed under the AGPLv3.
4 HEADER #include <sys/types.h>
13 // Wrapper for `read` that retries on partial reads.
14 // If last_res is non-NULL, it will be filled with the
15 // result of the last read() call (but all positive numbers
16 // become 1). In other words:
19 // - 1: no problems occured
20 PUBLIC_FN ssize_t read_nointr(int fd, void *buf, size_t count, int *last_res) {
23 while (done < count) {
24 ssize_t part_res = read(fd, buf+done, count-done);
26 if (last_res) *last_res = part_res;
27 if (done) return done;
32 if (last_res) *last_res = 1;
36 // Wrapper for `write` that retries on partial writes.
37 // If last_res is non-NULL, it will be filled with the
38 // result of the last write() call (but all positive numbers
39 // become 1). In other words:
42 // - 1: no problems occured
43 PUBLIC_FN ssize_t write_nointr(int fd, void *buf, size_t count, int *last_res) {
46 while (done < count) {
47 ssize_t part_res = write(fd, buf+done, count-done);
49 if (last_res) *last_res = part_res;
50 if (done) return done;
55 if (last_res) *last_res = 1;
59 // Read all data from the given file descriptor. Tries fstat()+read()
60 // first, but if fstat() doesn't work, falls back to multiple read()s.
61 // Specify JH_NO_STAT to prevent the fstat() call.
62 // The return value is a malloc'd buffer.
63 // The buffer will be null-terminated, so you can read text files with
64 // this and can specify len_out as NULL.
65 PUBLIC_CONST JH_SLURP_NO_STAT 1
66 PUBLIC_CONST JH_SLURP_REALLOC 2 /* realloc result block if it saves RAM */
67 PUBLIC_FN char *slurp_fd(int fd, size_t *len_out, int flags) {
70 // Let's just guess that the file is 1023 bytes. Will become 1024 with
72 size_t size_guess = 1023;
73 bool trusted_guess = false; /* can we rely on the guess? */
75 // If we can determine the exact size, we don't have to guess. So try
76 // to determine the exact size.
77 if (!(flags&JH_SLURP_NO_STAT)) {
79 if (fstat(fd, &st) == 0) {
81 size_guess = st.st_size;
91 buf = realloc(buf, size_guess+1);
92 if (buf == NULL) return NULL;
94 ssize_t read_res = read_nointr(fd, buf+done, size_guess-done, &last_res);
95 if (last_res == -1) { errno_=errno; free(buf); errno=errno_; return NULL; }
97 if (last_res == 0 || trusted_guess) {
100 if (done != size_guess && (flags&JH_SLURP_REALLOC)) {
101 // Well, it'd be weird if shrinking could fail... but meh, I can't find
102 // an explicit statement about this being disallowed, so try staying on
104 char *buf_ = realloc(buf, done+1);
105 if (buf_) buf = buf_;
107 if (len_out) *len_out = done;
110 size_guess<<=1; // try two times the buffer size
114 PUBLIC_FN char *slurp_file(char *path, size_t *len_out, int flags) {
115 int fd = open(path, O_RDONLY);
116 if (fd == -1) return NULL;
117 char *res = slurp_fd(fd, len_out, flags);
124 // Write data into a file. len can be -1; that means that
125 // the real length is strlen(buf).
126 PUBLIC_FN int write_file(char *path, char *buf, ssize_t len, int open_flags) {
127 if (len == -1) len = strlen(buf);
129 int fd = open(path, open_flags, 0777);
130 if (fd == -1) return 1;
131 ssize_t write_res = write_nointr(fd, buf, len, NULL);
132 int write_errno = errno;
133 int close_res = close(fd);
134 if (write_res != len) {
138 if (close_res) return 1;