add sse2 stuff for doing stuff with certain chars in strings
[libjh.git] / io.c
1 // Copyright (2013) Jann Horn <jann@thejh.net>
2 // This code is licensed under the AGPLv3.
3
4 HEADER #include <sys/types.h>
5 #include <unistd.h>
6 #include <errno.h>
7 #include <stdlib.h>
8 #include <stdbool.h>
9 #include <sys/stat.h>
10 #include <fcntl.h>
11 #include <string.h>
12 #include <assert.h>
13 #include <sys/mman.h>
14
15 // Wrapper for `read` that retries on partial reads.
16 // If last_res is non-NULL, it will be filled with the
17 // result of the last read() call (but all positive numbers
18 // become 1). In other words:
19 //  - -1: error
20 //  - 0: stream ended
21 //  - 1: no problems occured
22 PUBLIC_FN ssize_t read_nointr(int fd, void *buf, size_t count, int *last_res) {
23   errno = 0;
24   size_t done = 0;
25   while (done < count) {
26     ssize_t part_res = read(fd, buf+done, count-done);
27     if (part_res <= 0) {
28       if (last_res) *last_res = part_res;
29       if (done) return done;
30       return part_res;
31     }
32     done += part_res;
33   }
34   if (last_res) *last_res = 1;
35   return done;
36 }
37
38 // Wrapper for `write` that retries on partial writes.
39 // If last_res is non-NULL, it will be filled with the
40 // result of the last write() call (but all positive numbers
41 // become 1). In other words:
42 //  - -1: error
43 //  - 0: stream ended
44 //  - 1: no problems occured
45 PUBLIC_FN ssize_t write_nointr(int fd, void *buf, size_t count, int *last_res) {
46   errno = 0;
47   size_t done = 0;
48   while (done < count) {
49     ssize_t part_res = write(fd, buf+done, count-done);
50     if (part_res <= 0) {
51       if (last_res) *last_res = part_res;
52       if (done) return done;
53       return part_res;
54     }
55     done += part_res;
56   }
57   if (last_res) *last_res = 1;
58   return done;
59 }
60
61 // Read all data from the given file descriptor. Tries fstat()+read()
62 // first, but if fstat() doesn't work, falls back to multiple read()s.
63 // Specify JH_NO_STAT to prevent the fstat() call.
64 // The return value is a malloc'd buffer.
65 // The buffer will be null-terminated, so you can read text files with
66 // this and can specify len_out as NULL.
67 PUBLIC_CONST JH_SLURP_NO_STAT 1
68 PUBLIC_CONST JH_SLURP_REALLOC 2 /* realloc result block if it saves RAM */
69 PUBLIC_FN char *slurp_fd(int fd, size_t *len_out, int flags) {
70   int errno_;
71   
72   // Let's just guess that the file is 1023 bytes. Will become 1024 with
73   // the nullbyte.
74   size_t size_guess = 1023;
75   bool trusted_guess = false; /* can we rely on the guess? */
76   
77   // If we can determine the exact size, we don't have to guess. So try
78   // to determine the exact size.
79   if (!(flags&JH_SLURP_NO_STAT)) {
80     struct stat st;
81     if (fstat(fd, &st) == 0) {
82       if (st.st_size > 0) {
83         size_guess = st.st_size;
84         trusted_guess = true;
85       }
86     }
87   }
88   
89   char *buf = NULL;
90   int done = 0;
91   
92   while (1) {
93     buf = realloc(buf, size_guess+1);
94     if (buf == NULL) return NULL;
95     int last_res;
96     ssize_t read_res = read_nointr(fd, buf+done, size_guess-done, &last_res);
97     if (last_res == -1) { errno_=errno; free(buf); errno=errno_; return NULL; }
98     done += read_res;
99     if (last_res == 0 || trusted_guess) {
100       // out
101       buf[done] = '\0';
102       if (done != size_guess && (flags&JH_SLURP_REALLOC)) {
103         // Well, it'd be weird if shrinking could fail... but meh, I can't find
104         // an explicit statement about this being disallowed, so try staying on
105         // the safe side.
106         char *buf_ = realloc(buf, done+1);
107         if (buf_) buf = buf_;
108       }
109       if (len_out) *len_out = done;
110       return buf;
111     }
112     size_guess<<=1; // try two times the buffer size
113   }
114 }
115
116 PUBLIC_FN char *slurp_file(char *path, size_t *len_out, int flags) {
117   int fd = open(path, O_RDONLY|O_CLOEXEC);
118   if (fd == -1) return NULL;
119   char *res = slurp_fd(fd, len_out, flags);
120   int errno_ = errno;
121   close(fd);
122   errno = errno_;
123   return res;
124 }
125
126 // Write data into a file. len can be -1; that means that
127 // the real length is strlen(buf).
128 PUBLIC_FN int write_file(char *path, char *buf, ssize_t len, int open_flags) {
129   if (len == -1) len = strlen(buf);
130   
131   int fd = open(path, open_flags|O_CLOEXEC, 0777);
132   if (fd == -1) return 1;
133   ssize_t write_res = write_nointr(fd, buf, len, NULL);
134   int write_errno = errno;
135   int close_res = close(fd);
136   if (write_res != len) {
137     errno = write_errno;
138     return 1;
139   }
140   if (close_res) return 1;
141   return 0;
142 }
143
144 PUBLIC_FN void *mmap_file(void *addr, size_t length, int prot, int flags, char *path, off_t offset) {
145   assert((flags&MAP_ANONYMOUS) == 0);
146   assert(prot&(PROT_EXEC|PROT_READ|PROT_WRITE));
147   int open_flags = O_CLOEXEC;
148   if ((prot & (PROT_READ|PROT_EXEC)) && !(prot&PROT_WRITE)) open_flags |= O_RDONLY;
149   else if ((prot & (PROT_READ|PROT_EXEC))) open_flags |= O_RDWR;
150   else open_flags |= O_WRONLY;
151   int fd = open(path, open_flags);
152   if (fd == -1) return NULL;
153   void *r = mmap(addr, length, prot, flags, fd, offset);
154   int errno_ = errno;
155   close(fd);
156   errno = errno_;
157   return (r==MAP_FAILED) ? NULL : r;
158 }