blob: 808c149a4f979ab2d239ff25546f19b7e1fe2584 [file] [log] [blame]
Rob Landleyd3904932013-07-16 00:04:56 -05001/* lib.c - various reusable stuff.
landley09ea7ac2006-10-30 01:38:00 -05002 *
3 * Copyright 2006 Rob Landley <rob@landley.net>
landley4f344e32006-10-05 16:18:03 -04004 */
5
6#include "toys.h"
7
landley09ea7ac2006-10-30 01:38:00 -05008void verror_msg(char *msg, int err, va_list va)
9{
Rob Landley7aa651a2012-11-13 17:14:08 -060010 char *s = ": %s";
Rob Landley12138e42008-01-27 15:26:08 -060011
Rob Landley7aa651a2012-11-13 17:14:08 -060012 fprintf(stderr, "%s: ", toys.which->name);
13 if (msg) vfprintf(stderr, msg, va);
14 else s+=2;
15 if (err) fprintf(stderr, s, strerror(err));
16 putc('\n', stderr);
Rob Landley662a2672013-01-02 02:00:35 -060017 if (!toys.exitval) toys.exitval++;
landley09ea7ac2006-10-30 01:38:00 -050018}
19
20void error_msg(char *msg, ...)
21{
Rob Landley7aa651a2012-11-13 17:14:08 -060022 va_list va;
landley09ea7ac2006-10-30 01:38:00 -050023
Rob Landley7aa651a2012-11-13 17:14:08 -060024 va_start(va, msg);
25 verror_msg(msg, 0, va);
26 va_end(va);
landley09ea7ac2006-10-30 01:38:00 -050027}
28
29void perror_msg(char *msg, ...)
30{
Rob Landley7aa651a2012-11-13 17:14:08 -060031 va_list va;
landley09ea7ac2006-10-30 01:38:00 -050032
Rob Landley7aa651a2012-11-13 17:14:08 -060033 va_start(va, msg);
34 verror_msg(msg, errno, va);
35 va_end(va);
landley09ea7ac2006-10-30 01:38:00 -050036}
37
landley4f344e32006-10-05 16:18:03 -040038// Die with an error message.
39void error_exit(char *msg, ...)
40{
Rob Landley7aa651a2012-11-13 17:14:08 -060041 va_list va;
landley4f344e32006-10-05 16:18:03 -040042
Rob Landley36ffc5a2013-04-14 21:43:22 -050043 if (CFG_TOYBOX_HELP && toys.exithelp) show_help();
Rob Landleyd06c58d2007-10-11 15:36:36 -050044
Rob Landley7aa651a2012-11-13 17:14:08 -060045 va_start(va, msg);
46 verror_msg(msg, 0, va);
47 va_end(va);
landley09ea7ac2006-10-30 01:38:00 -050048
Rob Landley55830302013-06-16 19:59:51 -050049 xexit();
landley09ea7ac2006-10-30 01:38:00 -050050}
51
52// Die with an error message and strerror(errno)
53void perror_exit(char *msg, ...)
54{
Rob Landley7aa651a2012-11-13 17:14:08 -060055 va_list va;
landley09ea7ac2006-10-30 01:38:00 -050056
Rob Landley7aa651a2012-11-13 17:14:08 -060057 va_start(va, msg);
58 verror_msg(msg, errno, va);
59 va_end(va);
landley09ea7ac2006-10-30 01:38:00 -050060
Rob Landley55830302013-06-16 19:59:51 -050061 xexit();
landley4f344e32006-10-05 16:18:03 -040062}
63
landley64b2e232006-10-30 10:01:19 -050064// Keep reading until full or EOF
Rob Landley90163772007-01-18 21:54:08 -050065ssize_t readall(int fd, void *buf, size_t len)
landley64b2e232006-10-30 10:01:19 -050066{
Rob Landley7aa651a2012-11-13 17:14:08 -060067 size_t count = 0;
Rob Landley15b23152008-07-18 04:15:59 -050068
Rob Landley7aa651a2012-11-13 17:14:08 -060069 while (count<len) {
Rob Landleydbbd3d62013-12-08 13:26:05 -060070 int i = read(fd, (char *)buf+count, len-count);
Rob Landley7aa651a2012-11-13 17:14:08 -060071 if (!i) break;
72 if (i<0) return i;
73 count += i;
74 }
landley64b2e232006-10-30 10:01:19 -050075
Rob Landley7aa651a2012-11-13 17:14:08 -060076 return count;
landley64b2e232006-10-30 10:01:19 -050077}
78
Rob Landleyf3e452a2007-01-08 02:49:39 -050079// Keep writing until done or EOF
Rob Landley90163772007-01-18 21:54:08 -050080ssize_t writeall(int fd, void *buf, size_t len)
Rob Landleyf3e452a2007-01-08 02:49:39 -050081{
Rob Landley7aa651a2012-11-13 17:14:08 -060082 size_t count = 0;
83 while (count<len) {
Rob Landley1fb3ae72014-02-16 11:09:23 -060084 int i = write(fd, count+(char *)buf, len-count);
Rob Landley7aa651a2012-11-13 17:14:08 -060085 if (i<1) return i;
86 count += i;
87 }
Rob Landleyf3e452a2007-01-08 02:49:39 -050088
Rob Landley7aa651a2012-11-13 17:14:08 -060089 return count;
Rob Landleyf3e452a2007-01-08 02:49:39 -050090}
91
Rob Landleybc382be2013-09-16 23:41:51 -050092// skip this many bytes of input. Return 0 for success, >0 means this much
93// left after input skipped.
Rob Landley2037b832012-07-15 16:56:20 -050094off_t lskip(int fd, off_t offset)
95{
Rob Landleybc382be2013-09-16 23:41:51 -050096 off_t cur = lseek(fd, 0, SEEK_CUR);
Rob Landley2037b832012-07-15 16:56:20 -050097
Rob Landleybc382be2013-09-16 23:41:51 -050098 if (cur != -1) {
99 off_t end = lseek(fd, 0, SEEK_END) - cur;
Rob Landley2037b832012-07-15 16:56:20 -0500100
Rob Landleybc382be2013-09-16 23:41:51 -0500101 if (end > 0 && end < offset) return offset - end;
102 end = offset+cur;
103 if (end == lseek(fd, end, SEEK_SET)) return 0;
104 perror_exit("lseek");
Rob Landley7aa651a2012-11-13 17:14:08 -0600105 }
Rob Landleybc382be2013-09-16 23:41:51 -0500106
107 while (offset>0) {
108 int try = offset>sizeof(libbuf) ? sizeof(libbuf) : offset, or;
109
110 or = readall(fd, libbuf, try);
111 if (or < 0) perror_exit("lskip to %lld", (long long)offset);
Rob Landley4dd800c2014-02-28 23:10:03 -0600112 else offset -= or;
Rob Landleybc382be2013-09-16 23:41:51 -0500113 if (or < try) break;
114 }
115
116 return offset;
Rob Landley2037b832012-07-15 16:56:20 -0500117}
118
Rob Landleyca1b60e2014-03-11 20:44:55 -0500119// flags: 1=make last dir (with mode lastmode, otherwise skips last component)
120// 2=make path (already exists is ok)
121// 4=verbose
122// returns 0 = path ok, 1 = error
123int mkpathat(int atfd, char *dir, mode_t lastmode, int flags)
124{
125 struct stat buf;
126 char *s;
127
128 // mkdir -p one/two/three is not an error if the path already exists,
129 // but is if "three" is a file. The others we dereference and catch
130 // not-a-directory along the way, but the last one we must explicitly
131 // test for. Might as well do it up front.
132
133 if (!fstatat(atfd, dir, &buf, 0) && !S_ISDIR(buf.st_mode)) {
134 errno = EEXIST;
135 return 1;
136 }
137
Rob Landley02f5a302014-03-24 06:26:49 -0500138 for (s = dir; ;s++) {
Rob Landleyca1b60e2014-03-11 20:44:55 -0500139 char save = 0;
140 mode_t mode = (0777&~toys.old_umask)|0300;
141
Rob Landley02f5a302014-03-24 06:26:49 -0500142 // find next '/', but don't try to mkdir "" at start of absolute path
143 if (*s == '/' && (flags&2) && s != dir) {
Rob Landleyca1b60e2014-03-11 20:44:55 -0500144 save = *s;
145 *s = 0;
146 } else if (*s) continue;
147
148 // Use the mode from the -m option only for the last directory.
149 if (!save) {
150 if (flags&1) mode = lastmode;
151 else break;
152 }
153
154 if (mkdirat(atfd, dir, mode)) {
155 if (!(flags&2) || errno != EEXIST) return 1;
156 } else if (flags&4)
157 fprintf(stderr, "%s: created directory '%s'\n", toys.which->name, dir);
158
159 if (!(*s = save)) break;
160 }
161
162 return 0;
163}
164
Rob Landleyfe91e682012-11-22 21:18:09 -0600165// Split a path into linked list of components, tracking head and tail of list.
166// Filters out // entries with no contents.
167struct string_list **splitpath(char *path, struct string_list **list)
landley00f87f12006-10-25 18:38:37 -0400168{
Rob Landleyfe91e682012-11-22 21:18:09 -0600169 char *new = path;
landley00f87f12006-10-25 18:38:37 -0400170
Rob Landleyfe91e682012-11-22 21:18:09 -0600171 *list = 0;
172 do {
173 int len;
landley00f87f12006-10-25 18:38:37 -0400174
Rob Landleyfe91e682012-11-22 21:18:09 -0600175 if (*path && *path != '/') continue;
176 len = path-new;
177 if (len > 0) {
178 *list = xmalloc(sizeof(struct string_list) + len + 1);
179 (*list)->next = 0;
Rob Landley87fbe122014-12-13 11:56:41 -0600180 memcpy((*list)->str, new, len);
Rob Landleyfe91e682012-11-22 21:18:09 -0600181 (*list)->str[len] = 0;
182 list = &(*list)->next;
183 }
184 new = path+1;
185 } while (*path++);
186
187 return list;
188}
189
Rob Landley0a04b3e2006-11-03 00:05:52 -0500190// Find all file in a colon-separated path with access type "type" (generally
191// X_OK or R_OK). Returns a list of absolute paths to each file found, in
192// order.
193
194struct string_list *find_in_path(char *path, char *filename)
Rob Landleyfa98d012006-11-02 02:57:27 -0500195{
Rob Landley7aa651a2012-11-13 17:14:08 -0600196 struct string_list *rlist = NULL, **prlist=&rlist;
Rob Landley0aad9e42014-06-24 08:19:24 -0500197 char *cwd;
Rob Landleyfa98d012006-11-02 02:57:27 -0500198
Rob Landley0aad9e42014-06-24 08:19:24 -0500199 if (!path) return 0;
200
201 cwd = xgetcwd();
Rob Landley7aa651a2012-11-13 17:14:08 -0600202 for (;;) {
Rob Landley0aad9e42014-06-24 08:19:24 -0500203 char *next = strchr(path, ':');
Rob Landley7aa651a2012-11-13 17:14:08 -0600204 int len = next ? next-path : strlen(path);
205 struct string_list *rnext;
206 struct stat st;
Rob Landleyfa98d012006-11-02 02:57:27 -0500207
Rob Landley7aa651a2012-11-13 17:14:08 -0600208 rnext = xmalloc(sizeof(void *) + strlen(filename)
209 + (len ? len : strlen(cwd)) + 2);
210 if (!len) sprintf(rnext->str, "%s/%s", cwd, filename);
211 else {
212 char *res = rnext->str;
Rob Landley87fbe122014-12-13 11:56:41 -0600213
214 memcpy(res, path, len);
Rob Landley7aa651a2012-11-13 17:14:08 -0600215 res += len;
216 *(res++) = '/';
217 strcpy(res, filename);
218 }
Rob Landleyfa98d012006-11-02 02:57:27 -0500219
Rob Landley7aa651a2012-11-13 17:14:08 -0600220 // Confirm it's not a directory.
221 if (!stat(rnext->str, &st) && S_ISREG(st.st_mode)) {
222 *prlist = rnext;
223 rnext->next = NULL;
224 prlist = &(rnext->next);
225 } else free(rnext);
Rob Landleyfa98d012006-11-02 02:57:27 -0500226
Rob Landley7aa651a2012-11-13 17:14:08 -0600227 if (!next) break;
228 path += len;
229 path++;
230 }
231 free(cwd);
landley00f87f12006-10-25 18:38:37 -0400232
Rob Landley7aa651a2012-11-13 17:14:08 -0600233 return rlist;
landley00f87f12006-10-25 18:38:37 -0400234}
landley09ea7ac2006-10-30 01:38:00 -0500235
Rob Landley86c747a2015-01-01 16:28:51 -0600236long estrtol(char *str, char **end, int base)
237{
238 errno = 0;
239
240 return strtol(str, end, base);
241}
242
243long xstrtol(char *str, char **end, int base)
244{
245 long l = estrtol(str, end, base);
246
247 if (errno) perror_exit("%s", str);
248
249 return l;
250}
251
Rob Landleyf5757162007-02-16 21:08:22 -0500252// atol() with the kilo/mega/giga/tera/peta/exa extensions.
253// (zetta and yotta don't fit in 64 bits.)
Rob Landley5e6dca62012-02-09 06:09:27 -0600254long atolx(char *numstr)
Rob Landleyf5757162007-02-16 21:08:22 -0500255{
Rob Landley87c06e12014-07-19 20:54:29 -0500256 char *c, *suffixes="cbkmgtpe", *end;
Rob Landley86c747a2015-01-01 16:28:51 -0600257 long val;
Rob Landleyf5757162007-02-16 21:08:22 -0500258
Rob Landley86c747a2015-01-01 16:28:51 -0600259 val = xstrtol(numstr, &c, 0);
Rob Landley7aa651a2012-11-13 17:14:08 -0600260 if (*c) {
261 if (c != numstr && (end = strchr(suffixes, tolower(*c)))) {
Rob Landley87c06e12014-07-19 20:54:29 -0500262 int shift = end-suffixes-2;
263 if (shift >= 0) val *= 1024L<<(shift*10);
Rob Landley7aa651a2012-11-13 17:14:08 -0600264 } else {
265 while (isspace(*c)) c++;
266 if (*c) error_exit("not integer: %s", numstr);
267 }
268 }
Rob Landleyad63f4b2011-12-12 15:19:52 -0600269
Rob Landley7aa651a2012-11-13 17:14:08 -0600270 return val;
Rob Landleyf5757162007-02-16 21:08:22 -0500271}
272
Rob Landleyb5e74162013-11-28 21:11:34 -0600273long atolx_range(char *numstr, long low, long high)
274{
275 long val = atolx(numstr);
276
277 if (val < low) error_exit("%ld < %ld", val, low);
278 if (val > high) error_exit("%ld > %ld", val, high);
279
280 return val;
281}
282
Rob Landleyeb7ea222012-04-14 22:30:41 -0500283int numlen(long l)
284{
Rob Landley7aa651a2012-11-13 17:14:08 -0600285 int len = 0;
286 while (l) {
287 l /= 10;
288 len++;
289 }
290 return len;
Rob Landleyeb7ea222012-04-14 22:30:41 -0500291}
292
Rob Landley2037b832012-07-15 16:56:20 -0500293int stridx(char *haystack, char needle)
294{
Rob Landley7aa651a2012-11-13 17:14:08 -0600295 char *off;
Rob Landley2037b832012-07-15 16:56:20 -0500296
Rob Landley7aa651a2012-11-13 17:14:08 -0600297 if (!needle) return -1;
298 off = strchr(haystack, needle);
299 if (!off) return -1;
Rob Landley2037b832012-07-15 16:56:20 -0500300
Rob Landley7aa651a2012-11-13 17:14:08 -0600301 return off-haystack;
Rob Landley2037b832012-07-15 16:56:20 -0500302}
303
Rob Landley5fcc7152014-10-18 17:14:12 -0500304int unescape(char c)
305{
306 char *from = "\\abefnrtv", *to = "\\\a\b\033\f\n\r\t\v";
307 int idx = stridx(from, c);
308
309 return (idx == -1) ? 0 : to[idx];
310}
311
Rob Landley8115fc12014-06-09 07:12:49 -0500312// If *a starts with b, advance *a past it and return 1, else return 0;
313int strstart(char **a, char *b)
314{
315 int len = strlen(b), i = !strncmp(*a, b, len);
316
317 if (i) *a += len;
318
319 return i;
320}
321
Rob Landley055cfcb2007-01-14 20:20:06 -0500322// Return how long the file at fd is, if there's any way to determine it.
323off_t fdlength(int fd)
324{
Rob Landley035f27a2013-08-08 02:46:45 -0500325 struct stat st;
326 off_t base = 0, range = 1, expand = 1, old;
327
328 if (!fstat(fd, &st) && S_ISREG(st.st_mode)) return st.st_size;
Rob Landley055cfcb2007-01-14 20:20:06 -0500329
Rob Landley7aa651a2012-11-13 17:14:08 -0600330 // If the ioctl works for this, return it.
Rob Landley035f27a2013-08-08 02:46:45 -0500331 // TODO: is blocksize still always 512, or do we stat for it?
332 // unsigned int size;
333 // if (ioctl(fd, BLKGETSIZE, &size) >= 0) return size*512L;
Rob Landley055cfcb2007-01-14 20:20:06 -0500334
Rob Landley7aa651a2012-11-13 17:14:08 -0600335 // If not, do a binary search for the last location we can read. (Some
336 // block devices don't do BLKGETSIZE right.) This should probably have
337 // a CONFIG option...
Rob Landley055cfcb2007-01-14 20:20:06 -0500338
Rob Landley035f27a2013-08-08 02:46:45 -0500339 // If not, do a binary search for the last location we can read.
340
Rob Landley7aa651a2012-11-13 17:14:08 -0600341 old = lseek(fd, 0, SEEK_CUR);
342 do {
343 char temp;
Rob Landley035f27a2013-08-08 02:46:45 -0500344 off_t pos = base + range / 2;
Rob Landley055cfcb2007-01-14 20:20:06 -0500345
Rob Landley7aa651a2012-11-13 17:14:08 -0600346 if (lseek(fd, pos, 0)>=0 && read(fd, &temp, 1)==1) {
Rob Landley035f27a2013-08-08 02:46:45 -0500347 off_t delta = (pos + 1) - base;
Rob Landley055cfcb2007-01-14 20:20:06 -0500348
Rob Landley035f27a2013-08-08 02:46:45 -0500349 base += delta;
350 if (expand) range = (expand <<= 1) - base;
351 else range -= delta;
Rob Landley7aa651a2012-11-13 17:14:08 -0600352 } else {
Rob Landley035f27a2013-08-08 02:46:45 -0500353 expand = 0;
354 range = pos - base;
Rob Landley7aa651a2012-11-13 17:14:08 -0600355 }
Rob Landley035f27a2013-08-08 02:46:45 -0500356 } while (range > 0);
Rob Landley055cfcb2007-01-14 20:20:06 -0500357
Rob Landley7aa651a2012-11-13 17:14:08 -0600358 lseek(fd, old, SEEK_SET);
Rob Landleyf15387d2008-07-18 05:43:44 -0500359
Rob Landley035f27a2013-08-08 02:46:45 -0500360 return base;
Rob Landley055cfcb2007-01-14 20:20:06 -0500361}
362
Rob Landley8fdcfdb2013-09-03 17:56:28 -0500363// Read contents of file as a single nul-terminated string.
364// malloc new one if buf=len=0
Ashwini Sharma26b21882014-05-02 06:24:11 -0500365char *readfile(char *name, char *ibuf, off_t len)
Rob Landley055cfcb2007-01-14 20:20:06 -0500366{
Rob Landley7aa651a2012-11-13 17:14:08 -0600367 int fd;
Ashwini Sharma26b21882014-05-02 06:24:11 -0500368 char *buf;
Rob Landley055cfcb2007-01-14 20:20:06 -0500369
Rob Landley7aa651a2012-11-13 17:14:08 -0600370 fd = open(name, O_RDONLY);
371 if (fd == -1) return 0;
Rob Landley8fdcfdb2013-09-03 17:56:28 -0500372
373 if (len<1) {
374 len = fdlength(fd);
375 // proc files don't report a length, so try 1 page minimum.
376 if (len<4096) len = 4096;
377 }
Ashwini Sharma26b21882014-05-02 06:24:11 -0500378 if (!ibuf) buf = xmalloc(len+1);
379 else buf = ibuf;
Rob Landley8fdcfdb2013-09-03 17:56:28 -0500380
381 len = readall(fd, buf, len-1);
382 close(fd);
383 if (len<0) {
Ashwini Sharma26b21882014-05-02 06:24:11 -0500384 if (ibuf != buf) free(buf);
Rob Landley8fdcfdb2013-09-03 17:56:28 -0500385 buf = 0;
386 } else buf[len] = 0;
Rob Landley055cfcb2007-01-14 20:20:06 -0500387
Rob Landley7aa651a2012-11-13 17:14:08 -0600388 return buf;
Rob Landley055cfcb2007-01-14 20:20:06 -0500389}
390
Rob Landleyf0153442013-04-26 02:41:05 -0500391// Sleep for this many thousandths of a second
392void msleep(long miliseconds)
393{
394 struct timespec ts;
395
396 ts.tv_sec = miliseconds/1000;
397 ts.tv_nsec = (miliseconds%1000)*1000000;
398 nanosleep(&ts, &ts);
399}
400
Rob Landley546b2932014-07-21 19:56:53 -0500401// Inefficient, but deals with unaligned access
402int64_t peek_le(void *ptr, unsigned size)
Rob Landley6b283412013-06-01 20:41:35 -0500403{
Rob Landley546b2932014-07-21 19:56:53 -0500404 int64_t ret = 0;
405 char *c = ptr;
406 int i;
407
408 for (i=0; i<size; i++) ret |= ((int64_t)c[i])<<i;
409
410 return ret;
411}
412
413int64_t peek_be(void *ptr, unsigned size)
414{
415 int64_t ret = 0;
416 char *c = ptr;
417
418 while (size--) ret = (ret<<8)|c[size];
419
420 return ret;
421}
422
423int64_t peek(void *ptr, unsigned size)
424{
425 return IS_BIG_ENDIAN ? peek_be(ptr, size) : peek_le(ptr, size);
Rob Landley6b283412013-06-01 20:41:35 -0500426}
427
428void poke(void *ptr, uint64_t val, int size)
429{
430 if (size & 8) {
Rob Landleya8b88fe2014-03-11 18:11:12 -0500431 volatile uint64_t *p = (uint64_t *)ptr;
Rob Landley6b283412013-06-01 20:41:35 -0500432 *p = val;
433 } else if (size & 4) {
Rob Landleya8b88fe2014-03-11 18:11:12 -0500434 volatile int *p = (int *)ptr;
Rob Landley6b283412013-06-01 20:41:35 -0500435 *p = val;
436 } else if (size & 2) {
Rob Landleya8b88fe2014-03-11 18:11:12 -0500437 volatile short *p = (short *)ptr;
Rob Landley6b283412013-06-01 20:41:35 -0500438 *p = val;
439 } else {
Rob Landleya8b88fe2014-03-11 18:11:12 -0500440 volatile char *p = (char *)ptr;
Rob Landley6b283412013-06-01 20:41:35 -0500441 *p = val;
442 }
443}
444
Rob Landley2bfaaf22008-07-03 19:19:00 -0500445// Iterate through an array of files, opening each one and calling a function
446// on that filehandle and name. The special filename "-" means stdin if
447// flags is O_RDONLY, stdout otherwise. An empty argument list calls
448// function() on just stdin/stdout.
449//
Rob Landley784eb9c2014-10-14 14:16:34 -0500450// Note: pass O_CLOEXEC to automatically close filehandles when function()
451// returns, otherwise filehandles must be closed by function()
Rob Landleyad63f4b2011-12-12 15:19:52 -0600452void loopfiles_rw(char **argv, int flags, int permissions, int failok,
Rob Landley7aa651a2012-11-13 17:14:08 -0600453 void (*function)(int fd, char *name))
Rob Landley7634b552007-11-29 17:49:50 -0600454{
Rob Landley7aa651a2012-11-13 17:14:08 -0600455 int fd;
Rob Landley7634b552007-11-29 17:49:50 -0600456
Rob Landley7aa651a2012-11-13 17:14:08 -0600457 // If no arguments, read from stdin.
Rob Landley45b38822014-10-27 18:08:59 -0500458 if (!*argv) function((flags & O_ACCMODE) != O_RDONLY ? 1 : 0, "-");
Rob Landley7aa651a2012-11-13 17:14:08 -0600459 else do {
460 // Filename "-" means read from stdin.
461 // Inability to open a file prints a warning, but doesn't exit.
Rob Landley7634b552007-11-29 17:49:50 -0600462
Rob Landley45b38822014-10-27 18:08:59 -0500463 if (!strcmp(*argv, "-")) fd=0;
Rob Landley7aa651a2012-11-13 17:14:08 -0600464 else if (0>(fd = open(*argv, flags, permissions)) && !failok) {
465 perror_msg("%s", *argv);
466 toys.exitval = 1;
467 continue;
468 }
469 function(fd, *argv);
Rob Landley784eb9c2014-10-14 14:16:34 -0500470 if (flags & O_CLOEXEC) close(fd);
Rob Landley7aa651a2012-11-13 17:14:08 -0600471 } while (*++argv);
Rob Landley7634b552007-11-29 17:49:50 -0600472}
Rob Landleybc078652007-12-15 21:47:25 -0600473
Rob Landley784eb9c2014-10-14 14:16:34 -0500474// Call loopfiles_rw with O_RDONLY|O_CLOEXEC and !failok (common case).
Rob Landley2bfaaf22008-07-03 19:19:00 -0500475void loopfiles(char **argv, void (*function)(int fd, char *name))
476{
Rob Landley784eb9c2014-10-14 14:16:34 -0500477 loopfiles_rw(argv, O_RDONLY|O_CLOEXEC, 0, 0, function);
Rob Landley2bfaaf22008-07-03 19:19:00 -0500478}
479
Rob Landleybc078652007-12-15 21:47:25 -0600480// Slow, but small.
481
Rob Landley3fc4e0f2008-04-13 00:29:00 -0500482char *get_rawline(int fd, long *plen, char end)
Rob Landleybc078652007-12-15 21:47:25 -0600483{
Rob Landley7aa651a2012-11-13 17:14:08 -0600484 char c, *buf = NULL;
485 long len = 0;
Rob Landleybc078652007-12-15 21:47:25 -0600486
Rob Landley7aa651a2012-11-13 17:14:08 -0600487 for (;;) {
488 if (1>read(fd, &c, 1)) break;
489 if (!(len & 63)) buf=xrealloc(buf, len+65);
490 if ((buf[len++]=c) == end) break;
491 }
492 if (buf) buf[len]=0;
493 if (plen) *plen = len;
Rob Landleybc078652007-12-15 21:47:25 -0600494
Rob Landley7aa651a2012-11-13 17:14:08 -0600495 return buf;
Rob Landleybc078652007-12-15 21:47:25 -0600496}
497
498char *get_line(int fd)
499{
Rob Landley7aa651a2012-11-13 17:14:08 -0600500 long len;
501 char *buf = get_rawline(fd, &len, '\n');
Rob Landleybc078652007-12-15 21:47:25 -0600502
Rob Landley7aa651a2012-11-13 17:14:08 -0600503 if (buf && buf[--len]=='\n') buf[len]=0;
Rob Landleybc078652007-12-15 21:47:25 -0600504
Rob Landley7aa651a2012-11-13 17:14:08 -0600505 return buf;
Rob Landleybc078652007-12-15 21:47:25 -0600506}
507
Rob Landley67a069d2012-06-03 00:32:12 -0500508int wfchmodat(int fd, char *name, mode_t mode)
509{
Rob Landley7aa651a2012-11-13 17:14:08 -0600510 int rc = fchmodat(fd, name, mode, 0);
Rob Landley67a069d2012-06-03 00:32:12 -0500511
Rob Landley7aa651a2012-11-13 17:14:08 -0600512 if (rc) {
513 perror_msg("chmod '%s' to %04o", name, mode);
514 toys.exitval=1;
515 }
516 return rc;
Rob Landley67a069d2012-06-03 00:32:12 -0500517}
518
Rob Landleyc52db602012-07-30 01:01:33 -0500519static char *tempfile2zap;
520static void tempfile_handler(int i)
521{
Rob Landley7aa651a2012-11-13 17:14:08 -0600522 if (1 < (long)tempfile2zap) unlink(tempfile2zap);
523 _exit(1);
Rob Landleyc52db602012-07-30 01:01:33 -0500524}
525
Rob Landley42ecbab2007-12-18 02:02:21 -0600526// Open a temporary file to copy an existing file into.
527int copy_tempfile(int fdin, char *name, char **tempname)
528{
Rob Landley7aa651a2012-11-13 17:14:08 -0600529 struct stat statbuf;
530 int fd;
Rob Landley42ecbab2007-12-18 02:02:21 -0600531
Rob Landley9b5000c2014-12-22 17:04:47 -0600532 *tempname = xmprintf("%s%s", name, "XXXXXX");
Rob Landley7aa651a2012-11-13 17:14:08 -0600533 if(-1 == (fd = mkstemp(*tempname))) error_exit("no temp file");
534 if (!tempfile2zap) sigatexit(tempfile_handler);
535 tempfile2zap = *tempname;
Rob Landley42ecbab2007-12-18 02:02:21 -0600536
Rob Landley7aa651a2012-11-13 17:14:08 -0600537 // Set permissions of output file
Rob Landley42ecbab2007-12-18 02:02:21 -0600538
Rob Landley7aa651a2012-11-13 17:14:08 -0600539 fstat(fdin, &statbuf);
540 fchmod(fd, statbuf.st_mode);
Rob Landley42ecbab2007-12-18 02:02:21 -0600541
Rob Landley7aa651a2012-11-13 17:14:08 -0600542 return fd;
Rob Landley42ecbab2007-12-18 02:02:21 -0600543}
544
545// Abort the copy and delete the temporary file.
546void delete_tempfile(int fdin, int fdout, char **tempname)
547{
Rob Landley7aa651a2012-11-13 17:14:08 -0600548 close(fdin);
549 close(fdout);
550 unlink(*tempname);
551 tempfile2zap = (char *)1;
552 free(*tempname);
553 *tempname = NULL;
Rob Landley42ecbab2007-12-18 02:02:21 -0600554}
555
556// Copy the rest of the data and replace the original with the copy.
557void replace_tempfile(int fdin, int fdout, char **tempname)
558{
Rob Landley7aa651a2012-11-13 17:14:08 -0600559 char *temp = xstrdup(*tempname);
Rob Landley42ecbab2007-12-18 02:02:21 -0600560
Rob Landley7aa651a2012-11-13 17:14:08 -0600561 temp[strlen(temp)-6]=0;
562 if (fdin != -1) {
563 xsendfile(fdin, fdout);
564 xclose(fdin);
565 }
566 xclose(fdout);
567 rename(*tempname, temp);
568 tempfile2zap = (char *)1;
569 free(*tempname);
570 free(temp);
571 *tempname = NULL;
Rob Landleybc078652007-12-15 21:47:25 -0600572}
Rob Landley7e849c52009-01-03 18:15:18 -0600573
574// Create a 256 entry CRC32 lookup table.
575
Rob Landleyb15b8fa2009-01-05 01:05:43 -0600576void crc_init(unsigned int *crc_table, int little_endian)
Rob Landley7e849c52009-01-03 18:15:18 -0600577{
Rob Landley7aa651a2012-11-13 17:14:08 -0600578 unsigned int i;
Rob Landley7e849c52009-01-03 18:15:18 -0600579
Rob Landley7aa651a2012-11-13 17:14:08 -0600580 // Init the CRC32 table (big endian)
581 for (i=0; i<256; i++) {
582 unsigned int j, c = little_endian ? i : i<<24;
583 for (j=8; j; j--)
584 if (little_endian) c = (c&1) ? (c>>1)^0xEDB88320 : c>>1;
585 else c=c&0x80000000 ? (c<<1)^0x04c11db7 : (c<<1);
586 crc_table[i] = c;
587 }
Rob Landley7e849c52009-01-03 18:15:18 -0600588}
Rob Landley26e7b5e2012-02-02 07:27:35 -0600589
Rob Landley0517eb72014-12-13 11:58:08 -0600590// Init base64 table
591
592void base64_init(char *p)
593{
594 int i;
595
596 for (i = 'A'; i != ':'; i++) {
597 if (i == 'Z'+1) i = 'a';
598 if (i == 'z'+1) i = '0';
599 *(p++) = i;
600 }
601 *(p++) = '+';
602 *(p++) = '/';
603}
604
Rob Landley26e7b5e2012-02-02 07:27:35 -0600605// Quick and dirty query size of terminal, doesn't do ANSI probe fallback.
Rob Landley10bdaa42013-11-07 09:04:50 -0600606// set x=80 y=25 before calling to provide defaults. Returns 0 if couldn't
607// determine size.
Rob Landley26e7b5e2012-02-02 07:27:35 -0600608
Rob Landley10bdaa42013-11-07 09:04:50 -0600609int terminal_size(unsigned *xx, unsigned *yy)
Rob Landley26e7b5e2012-02-02 07:27:35 -0600610{
Rob Landley7aa651a2012-11-13 17:14:08 -0600611 struct winsize ws;
Rob Landley10bdaa42013-11-07 09:04:50 -0600612 unsigned i, x = 0, y = 0;
Rob Landleyc9cc5302013-10-27 00:02:56 -0500613 char *s;
Rob Landley26e7b5e2012-02-02 07:27:35 -0600614
Rob Landley10bdaa42013-11-07 09:04:50 -0600615 // stdin, stdout, stderr
Rob Landley7aa651a2012-11-13 17:14:08 -0600616 for (i=0; i<3; i++) {
Rob Landleyc9cc5302013-10-27 00:02:56 -0500617 memset(&ws, 0, sizeof(ws));
618 if (!ioctl(i, TIOCGWINSZ, &ws)) {
619 if (ws.ws_col) x = ws.ws_col;
620 if (ws.ws_row) y = ws.ws_row;
Rob Landley26e7b5e2012-02-02 07:27:35 -0600621
Rob Landleyc9cc5302013-10-27 00:02:56 -0500622 break;
623 }
Rob Landley7aa651a2012-11-13 17:14:08 -0600624 }
Rob Landleyc9cc5302013-10-27 00:02:56 -0500625 s = getenv("COLUMNS");
626 if (s) sscanf(s, "%u", &x);
627 s = getenv("ROWS");
628 if (s) sscanf(s, "%u", &y);
Rob Landley26e7b5e2012-02-02 07:27:35 -0600629
Rob Landley10bdaa42013-11-07 09:04:50 -0600630 // Never return 0 for either value, leave it at default instead.
631 if (xx && x) *xx = x;
632 if (yy && y) *yy = y;
633
634 return x || y;
Rob Landley26e7b5e2012-02-02 07:27:35 -0600635}
636
Rob Landleyf793d532012-02-27 21:56:49 -0600637int yesno(char *prompt, int def)
Rob Landley26e7b5e2012-02-02 07:27:35 -0600638{
Rob Landley7aa651a2012-11-13 17:14:08 -0600639 char buf;
Rob Landley26e7b5e2012-02-02 07:27:35 -0600640
Rob Landleydb8eb322012-12-08 02:25:32 -0600641 fprintf(stderr, "%s (%c/%c):", prompt, def ? 'Y' : 'y', def ? 'n' : 'N');
642 fflush(stderr);
643 while (fread(&buf, 1, 1, stdin)) {
644 int new;
Rob Landley26e7b5e2012-02-02 07:27:35 -0600645
Rob Landley22791082013-01-31 04:13:07 -0600646 // The letter changes the value, the newline (or space) returns it.
Rob Landleydb8eb322012-12-08 02:25:32 -0600647 if (isspace(buf)) break;
648 if (-1 != (new = stridx("ny", tolower(buf)))) def = new;
Rob Landley7aa651a2012-11-13 17:14:08 -0600649 }
Rob Landleyee00a7f2012-03-19 19:19:21 -0500650
Rob Landley7aa651a2012-11-13 17:14:08 -0600651 return def;
Rob Landley26e7b5e2012-02-02 07:27:35 -0600652}
Rob Landleyff9ee8f2012-02-18 15:12:41 -0600653
Rob Landley2dd50ad2012-02-26 13:48:00 -0600654struct signame {
Rob Landley7aa651a2012-11-13 17:14:08 -0600655 int num;
656 char *name;
Rob Landley2dd50ad2012-02-26 13:48:00 -0600657};
658
659// Signals required by POSIX 2008:
660// http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/signal.h.html
661
662#define SIGNIFY(x) {SIG##x, #x}
663
664static struct signame signames[] = {
Rob Landley7aa651a2012-11-13 17:14:08 -0600665 SIGNIFY(ABRT), SIGNIFY(ALRM), SIGNIFY(BUS),
666 SIGNIFY(FPE), SIGNIFY(HUP), SIGNIFY(ILL), SIGNIFY(INT), SIGNIFY(KILL),
667 SIGNIFY(PIPE), SIGNIFY(QUIT), SIGNIFY(SEGV), SIGNIFY(TERM),
668 SIGNIFY(USR1), SIGNIFY(USR2), SIGNIFY(SYS), SIGNIFY(TRAP),
669 SIGNIFY(VTALRM), SIGNIFY(XCPU), SIGNIFY(XFSZ),
Rob Landleyc52db602012-07-30 01:01:33 -0500670
Rob Landley7aa651a2012-11-13 17:14:08 -0600671 // Start of non-terminal signals
Rob Landleyc52db602012-07-30 01:01:33 -0500672
Rob Landley7aa651a2012-11-13 17:14:08 -0600673 SIGNIFY(CHLD), SIGNIFY(CONT), SIGNIFY(STOP), SIGNIFY(TSTP),
674 SIGNIFY(TTIN), SIGNIFY(TTOU), SIGNIFY(URG)
Rob Landley2dd50ad2012-02-26 13:48:00 -0600675};
676
677// not in posix: SIGNIFY(STKFLT), SIGNIFY(WINCH), SIGNIFY(IO), SIGNIFY(PWR)
678// obsolete: SIGNIFY(PROF) SIGNIFY(POLL)
679
Rob Landley1bc52242014-05-21 07:24:16 -0500680// Handler that sets toys.signal, and writes to toys.signalfd if set
681void generic_signal(int sig)
682{
683 if (toys.signalfd) {
684 char c = sig;
685
686 writeall(toys.signalfd, &c, 1);
687 }
688 toys.signal = sig;
689}
690
Rob Landleyc52db602012-07-30 01:01:33 -0500691// Install the same handler on every signal that defaults to killing the process
692void sigatexit(void *handler)
693{
Rob Landley7aa651a2012-11-13 17:14:08 -0600694 int i;
695 for (i=0; signames[i].num != SIGCHLD; i++) signal(signames[i].num, handler);
Rob Landleyc52db602012-07-30 01:01:33 -0500696}
Rob Landley1bc52242014-05-21 07:24:16 -0500697
Rob Landley2dd50ad2012-02-26 13:48:00 -0600698// Convert name to signal number. If name == NULL print names.
699int sig_to_num(char *pidstr)
700{
Rob Landley7aa651a2012-11-13 17:14:08 -0600701 int i;
Rob Landley2dd50ad2012-02-26 13:48:00 -0600702
Rob Landley7aa651a2012-11-13 17:14:08 -0600703 if (pidstr) {
704 char *s;
Rob Landley86c747a2015-01-01 16:28:51 -0600705
706 i = estrtol(pidstr, &s, 10);
707 if (!errno && !*s) return i;
Rob Landley2dd50ad2012-02-26 13:48:00 -0600708
Rob Landley7aa651a2012-11-13 17:14:08 -0600709 if (!strncasecmp(pidstr, "sig", 3)) pidstr+=3;
710 }
711 for (i = 0; i < sizeof(signames)/sizeof(struct signame); i++)
712 if (!pidstr) xputs(signames[i].name);
713 else if (!strcasecmp(pidstr, signames[i].name)) return signames[i].num;
Rob Landley2dd50ad2012-02-26 13:48:00 -0600714
Rob Landley7aa651a2012-11-13 17:14:08 -0600715 return -1;
Rob Landley2dd50ad2012-02-26 13:48:00 -0600716}
717
718char *num_to_sig(int sig)
719{
Rob Landley7aa651a2012-11-13 17:14:08 -0600720 int i;
Rob Landley2dd50ad2012-02-26 13:48:00 -0600721
Rob Landley7aa651a2012-11-13 17:14:08 -0600722 for (i=0; i<sizeof(signames)/sizeof(struct signame); i++)
723 if (signames[i].num == sig) return signames[i].name;
724 return NULL;
Rob Landley2dd50ad2012-02-26 13:48:00 -0600725}
Daniel Walter05744b32012-03-19 19:57:56 -0500726
Rob Landleyc52db602012-07-30 01:01:33 -0500727// premute mode bits based on posix mode strings.
Rob Landleyb6f601e2012-05-16 21:11:43 -0500728mode_t string_to_mode(char *modestr, mode_t mode)
Daniel Walter05744b32012-03-19 19:57:56 -0500729{
Rob Landley3b5b19e2014-08-15 10:50:39 -0500730 char *whos = "ogua", *hows = "=+-", *whats = "xwrstX", *whys = "ogu",
731 *s, *str = modestr;
732 mode_t extrabits = mode & ~(07777);
Rob Landleycf6bcb22012-03-19 20:56:18 -0500733
Rob Landley7aa651a2012-11-13 17:14:08 -0600734 // Handle octal mode
735 if (isdigit(*str)) {
Rob Landley86c747a2015-01-01 16:28:51 -0600736 mode = estrtol(str, &s, 8);
737 if (errno || *s || (mode & ~(07777))) goto barf;
Rob Landleyb6f601e2012-05-16 21:11:43 -0500738
Rob Landley3b5b19e2014-08-15 10:50:39 -0500739 return mode | extrabits;
Rob Landley7aa651a2012-11-13 17:14:08 -0600740 }
Rob Landleycf6bcb22012-03-19 20:56:18 -0500741
Rob Landley7aa651a2012-11-13 17:14:08 -0600742 // Gaze into the bin of permission...
743 for (;;) {
744 int i, j, dowho, dohow, dowhat, amask;
Rob Landleycf6bcb22012-03-19 20:56:18 -0500745
Rob Landley7aa651a2012-11-13 17:14:08 -0600746 dowho = dohow = dowhat = amask = 0;
Daniel Walter05744b32012-03-19 19:57:56 -0500747
Rob Landley7aa651a2012-11-13 17:14:08 -0600748 // Find the who, how, and what stanzas, in that order
749 while (*str && (s = strchr(whos, *str))) {
750 dowho |= 1<<(s-whos);
751 str++;
752 }
753 // If who isn't specified, like "a" but honoring umask.
754 if (!dowho) {
755 dowho = 8;
756 umask(amask=umask(0));
757 }
758 if (!*str || !(s = strchr(hows, *str))) goto barf;
759 dohow = *(str++);
Rob Landley67a069d2012-06-03 00:32:12 -0500760
Rob Landley7aa651a2012-11-13 17:14:08 -0600761 if (!dohow) goto barf;
762 while (*str && (s = strchr(whats, *str))) {
763 dowhat |= 1<<(s-whats);
764 str++;
765 }
Rob Landleyb6f601e2012-05-16 21:11:43 -0500766
Rob Landley7aa651a2012-11-13 17:14:08 -0600767 // Convert X to x for directory or if already executable somewhere
768 if ((dowhat&32) && (S_ISDIR(mode) || (mode&0111))) dowhat |= 1;
Rob Landleyb6f601e2012-05-16 21:11:43 -0500769
Rob Landley7aa651a2012-11-13 17:14:08 -0600770 // Copy mode from another category?
771 if (!dowhat && *str && (s = strchr(whys, *str))) {
772 dowhat = (mode>>(3*(s-whys)))&7;
773 str++;
774 }
Rob Landleyb6f601e2012-05-16 21:11:43 -0500775
Rob Landley7aa651a2012-11-13 17:14:08 -0600776 // Are we ready to do a thing yet?
777 if (*str && *(str++) != ',') goto barf;
Rob Landleyb6f601e2012-05-16 21:11:43 -0500778
Rob Landley7aa651a2012-11-13 17:14:08 -0600779 // Ok, apply the bits to the mode.
780 for (i=0; i<4; i++) {
781 for (j=0; j<3; j++) {
782 mode_t bit = 0;
783 int where = 1<<((3*i)+j);
Rob Landley31f49e72012-07-21 22:45:05 -0500784
Rob Landley7aa651a2012-11-13 17:14:08 -0600785 if (amask & where) continue;
Rob Landleyb6f601e2012-05-16 21:11:43 -0500786
Rob Landley7aa651a2012-11-13 17:14:08 -0600787 // Figure out new value at this location
788 if (i == 3) {
789 // suid/sticky bit.
790 if (j) {
791 if ((dowhat & 8) && (dowho&(8|(1<<i)))) bit++;
792 } else if (dowhat & 16) bit++;
793 } else {
794 if (!(dowho&(8|(1<<i)))) continue;
795 if (dowhat&(1<<j)) bit++;
796 }
Rob Landleyb6f601e2012-05-16 21:11:43 -0500797
Rob Landley7aa651a2012-11-13 17:14:08 -0600798 // When selection active, modify bit
Rob Landleyb6f601e2012-05-16 21:11:43 -0500799
Rob Landley7aa651a2012-11-13 17:14:08 -0600800 if (dohow == '=' || (bit && dohow == '-')) mode &= ~where;
801 if (bit && dohow != '-') mode |= where;
802 }
803 }
Rob Landleyb6f601e2012-05-16 21:11:43 -0500804
Rob Landley7aa651a2012-11-13 17:14:08 -0600805 if (!*str) break;
806 }
Rob Landley3b5b19e2014-08-15 10:50:39 -0500807
808 return mode|extrabits;
Rob Landleyb6f601e2012-05-16 21:11:43 -0500809barf:
Rob Landley7aa651a2012-11-13 17:14:08 -0600810 error_exit("bad mode '%s'", modestr);
Daniel Walter05744b32012-03-19 19:57:56 -0500811}
Ashwini Kumar1a0eedf2012-08-26 21:17:00 -0500812
Rob Landley5a26a862013-06-02 00:24:24 -0500813// Format access mode into a drwxrwxrwx string
814void mode_to_string(mode_t mode, char *buf)
Felix Janda5a221e62013-04-22 22:29:43 +0200815{
816 char c, d;
817 int i, bit;
818
Rob Landley5a26a862013-06-02 00:24:24 -0500819 buf[10]=0;
Felix Janda5a221e62013-04-22 22:29:43 +0200820 for (i=0; i<9; i++) {
821 bit = mode & (1<<i);
822 c = i%3;
823 if (!c && (mode & (1<<((d=i/3)+9)))) {
824 c = "tss"[d];
825 if (!bit) c &= ~0x20;
826 } else c = bit ? "xwr"[c] : '-';
Rob Landley5a26a862013-06-02 00:24:24 -0500827 buf[9-i] = c;
Felix Janda5a221e62013-04-22 22:29:43 +0200828 }
829
830 if (S_ISDIR(mode)) c = 'd';
831 else if (S_ISBLK(mode)) c = 'b';
832 else if (S_ISCHR(mode)) c = 'c';
833 else if (S_ISLNK(mode)) c = 'l';
834 else if (S_ISFIFO(mode)) c = 'p';
835 else if (S_ISSOCK(mode)) c = 's';
836 else c = '-';
Rob Landley5a26a862013-06-02 00:24:24 -0500837 *buf = c;
Felix Janda5a221e62013-04-22 22:29:43 +0200838}
Rob Landleydb1009d2013-12-19 09:32:30 -0600839
840// Execute a callback for each PID that matches a process name from a list.
841void names_to_pid(char **names, int (*callback)(pid_t pid, char *name))
842{
843 DIR *dp;
844 struct dirent *entry;
845
846 if (!(dp = opendir("/proc"))) perror_exit("opendir");
847
848 while ((entry = readdir(dp))) {
849 unsigned u;
850 char *cmd, **curname;
851
852 if (!(u = atoi(entry->d_name))) continue;
853 sprintf(libbuf, "/proc/%u/cmdline", u);
854 if (!(cmd = readfile(libbuf, libbuf, sizeof(libbuf)))) continue;
855
856 for (curname = names; *curname; curname++)
857 if (**curname == '/' ? !strcmp(cmd, *curname)
858 : !strcmp(basename(cmd), basename(*curname)))
859 if (callback(u, *curname)) break;
860 if (*curname) break;
861 }
862 closedir(dp);
863}
Rob Landley48c172b2014-05-06 06:31:28 -0500864
865// display first few digits of number with power of two units, except we're
866// actually just counting decimal digits and showing mil/bil/trillions.
867int human_readable(char *buf, unsigned long long num)
868{
869 int end, len;
870
871 len = sprintf(buf, "%lld", num);
872 end = ((len-1)%3)+1;
873 len /= 3;
874
875 if (len && end == 1) {
876 buf[2] = buf[1];
877 buf[1] = '.';
878 end = 3;
879 }
880 buf[end++] = ' ';
881 if (len) buf[end++] = " KMGTPE"[len];
882 buf[end++] = 'B';
883 buf[end++] = 0;
884
885 return end;
886}