blob: ade07866986544617162b60c0629ce1a9d9e12cc [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 Landleyf5757162007-02-16 21:08:22 -0500236// atol() with the kilo/mega/giga/tera/peta/exa extensions.
237// (zetta and yotta don't fit in 64 bits.)
Rob Landley5e6dca62012-02-09 06:09:27 -0600238long atolx(char *numstr)
Rob Landleyf5757162007-02-16 21:08:22 -0500239{
Rob Landley87c06e12014-07-19 20:54:29 -0500240 char *c, *suffixes="cbkmgtpe", *end;
Rob Landley7aa651a2012-11-13 17:14:08 -0600241 long val = strtol(numstr, &c, 0);
Rob Landleyf5757162007-02-16 21:08:22 -0500242
Rob Landley7aa651a2012-11-13 17:14:08 -0600243 if (*c) {
244 if (c != numstr && (end = strchr(suffixes, tolower(*c)))) {
Rob Landley87c06e12014-07-19 20:54:29 -0500245 int shift = end-suffixes-2;
246 if (shift >= 0) val *= 1024L<<(shift*10);
Rob Landley7aa651a2012-11-13 17:14:08 -0600247 } else {
248 while (isspace(*c)) c++;
249 if (*c) error_exit("not integer: %s", numstr);
250 }
251 }
Rob Landleyad63f4b2011-12-12 15:19:52 -0600252
Rob Landley7aa651a2012-11-13 17:14:08 -0600253 return val;
Rob Landleyf5757162007-02-16 21:08:22 -0500254}
255
Rob Landleyb5e74162013-11-28 21:11:34 -0600256long atolx_range(char *numstr, long low, long high)
257{
258 long val = atolx(numstr);
259
260 if (val < low) error_exit("%ld < %ld", val, low);
261 if (val > high) error_exit("%ld > %ld", val, high);
262
263 return val;
264}
265
Rob Landleyeb7ea222012-04-14 22:30:41 -0500266int numlen(long l)
267{
Rob Landley7aa651a2012-11-13 17:14:08 -0600268 int len = 0;
269 while (l) {
270 l /= 10;
271 len++;
272 }
273 return len;
Rob Landleyeb7ea222012-04-14 22:30:41 -0500274}
275
Rob Landley2037b832012-07-15 16:56:20 -0500276int stridx(char *haystack, char needle)
277{
Rob Landley7aa651a2012-11-13 17:14:08 -0600278 char *off;
Rob Landley2037b832012-07-15 16:56:20 -0500279
Rob Landley7aa651a2012-11-13 17:14:08 -0600280 if (!needle) return -1;
281 off = strchr(haystack, needle);
282 if (!off) return -1;
Rob Landley2037b832012-07-15 16:56:20 -0500283
Rob Landley7aa651a2012-11-13 17:14:08 -0600284 return off-haystack;
Rob Landley2037b832012-07-15 16:56:20 -0500285}
286
Rob Landley5fcc7152014-10-18 17:14:12 -0500287int unescape(char c)
288{
289 char *from = "\\abefnrtv", *to = "\\\a\b\033\f\n\r\t\v";
290 int idx = stridx(from, c);
291
292 return (idx == -1) ? 0 : to[idx];
293}
294
Rob Landley8115fc12014-06-09 07:12:49 -0500295// If *a starts with b, advance *a past it and return 1, else return 0;
296int strstart(char **a, char *b)
297{
298 int len = strlen(b), i = !strncmp(*a, b, len);
299
300 if (i) *a += len;
301
302 return i;
303}
304
Rob Landley055cfcb2007-01-14 20:20:06 -0500305// Return how long the file at fd is, if there's any way to determine it.
306off_t fdlength(int fd)
307{
Rob Landley035f27a2013-08-08 02:46:45 -0500308 struct stat st;
309 off_t base = 0, range = 1, expand = 1, old;
310
311 if (!fstat(fd, &st) && S_ISREG(st.st_mode)) return st.st_size;
Rob Landley055cfcb2007-01-14 20:20:06 -0500312
Rob Landley7aa651a2012-11-13 17:14:08 -0600313 // If the ioctl works for this, return it.
Rob Landley035f27a2013-08-08 02:46:45 -0500314 // TODO: is blocksize still always 512, or do we stat for it?
315 // unsigned int size;
316 // if (ioctl(fd, BLKGETSIZE, &size) >= 0) return size*512L;
Rob Landley055cfcb2007-01-14 20:20:06 -0500317
Rob Landley7aa651a2012-11-13 17:14:08 -0600318 // If not, do a binary search for the last location we can read. (Some
319 // block devices don't do BLKGETSIZE right.) This should probably have
320 // a CONFIG option...
Rob Landley055cfcb2007-01-14 20:20:06 -0500321
Rob Landley035f27a2013-08-08 02:46:45 -0500322 // If not, do a binary search for the last location we can read.
323
Rob Landley7aa651a2012-11-13 17:14:08 -0600324 old = lseek(fd, 0, SEEK_CUR);
325 do {
326 char temp;
Rob Landley035f27a2013-08-08 02:46:45 -0500327 off_t pos = base + range / 2;
Rob Landley055cfcb2007-01-14 20:20:06 -0500328
Rob Landley7aa651a2012-11-13 17:14:08 -0600329 if (lseek(fd, pos, 0)>=0 && read(fd, &temp, 1)==1) {
Rob Landley035f27a2013-08-08 02:46:45 -0500330 off_t delta = (pos + 1) - base;
Rob Landley055cfcb2007-01-14 20:20:06 -0500331
Rob Landley035f27a2013-08-08 02:46:45 -0500332 base += delta;
333 if (expand) range = (expand <<= 1) - base;
334 else range -= delta;
Rob Landley7aa651a2012-11-13 17:14:08 -0600335 } else {
Rob Landley035f27a2013-08-08 02:46:45 -0500336 expand = 0;
337 range = pos - base;
Rob Landley7aa651a2012-11-13 17:14:08 -0600338 }
Rob Landley035f27a2013-08-08 02:46:45 -0500339 } while (range > 0);
Rob Landley055cfcb2007-01-14 20:20:06 -0500340
Rob Landley7aa651a2012-11-13 17:14:08 -0600341 lseek(fd, old, SEEK_SET);
Rob Landleyf15387d2008-07-18 05:43:44 -0500342
Rob Landley035f27a2013-08-08 02:46:45 -0500343 return base;
Rob Landley055cfcb2007-01-14 20:20:06 -0500344}
345
Rob Landley8fdcfdb2013-09-03 17:56:28 -0500346// Read contents of file as a single nul-terminated string.
347// malloc new one if buf=len=0
Ashwini Sharma26b21882014-05-02 06:24:11 -0500348char *readfile(char *name, char *ibuf, off_t len)
Rob Landley055cfcb2007-01-14 20:20:06 -0500349{
Rob Landley7aa651a2012-11-13 17:14:08 -0600350 int fd;
Ashwini Sharma26b21882014-05-02 06:24:11 -0500351 char *buf;
Rob Landley055cfcb2007-01-14 20:20:06 -0500352
Rob Landley7aa651a2012-11-13 17:14:08 -0600353 fd = open(name, O_RDONLY);
354 if (fd == -1) return 0;
Rob Landley8fdcfdb2013-09-03 17:56:28 -0500355
356 if (len<1) {
357 len = fdlength(fd);
358 // proc files don't report a length, so try 1 page minimum.
359 if (len<4096) len = 4096;
360 }
Ashwini Sharma26b21882014-05-02 06:24:11 -0500361 if (!ibuf) buf = xmalloc(len+1);
362 else buf = ibuf;
Rob Landley8fdcfdb2013-09-03 17:56:28 -0500363
364 len = readall(fd, buf, len-1);
365 close(fd);
366 if (len<0) {
Ashwini Sharma26b21882014-05-02 06:24:11 -0500367 if (ibuf != buf) free(buf);
Rob Landley8fdcfdb2013-09-03 17:56:28 -0500368 buf = 0;
369 } else buf[len] = 0;
Rob Landley055cfcb2007-01-14 20:20:06 -0500370
Rob Landley7aa651a2012-11-13 17:14:08 -0600371 return buf;
Rob Landley055cfcb2007-01-14 20:20:06 -0500372}
373
Rob Landleyf0153442013-04-26 02:41:05 -0500374// Sleep for this many thousandths of a second
375void msleep(long miliseconds)
376{
377 struct timespec ts;
378
379 ts.tv_sec = miliseconds/1000;
380 ts.tv_nsec = (miliseconds%1000)*1000000;
381 nanosleep(&ts, &ts);
382}
383
Rob Landley546b2932014-07-21 19:56:53 -0500384// Inefficient, but deals with unaligned access
385int64_t peek_le(void *ptr, unsigned size)
Rob Landley6b283412013-06-01 20:41:35 -0500386{
Rob Landley546b2932014-07-21 19:56:53 -0500387 int64_t ret = 0;
388 char *c = ptr;
389 int i;
390
391 for (i=0; i<size; i++) ret |= ((int64_t)c[i])<<i;
392
393 return ret;
394}
395
396int64_t peek_be(void *ptr, unsigned size)
397{
398 int64_t ret = 0;
399 char *c = ptr;
400
401 while (size--) ret = (ret<<8)|c[size];
402
403 return ret;
404}
405
406int64_t peek(void *ptr, unsigned size)
407{
408 return IS_BIG_ENDIAN ? peek_be(ptr, size) : peek_le(ptr, size);
Rob Landley6b283412013-06-01 20:41:35 -0500409}
410
411void poke(void *ptr, uint64_t val, int size)
412{
413 if (size & 8) {
Rob Landleya8b88fe2014-03-11 18:11:12 -0500414 volatile uint64_t *p = (uint64_t *)ptr;
Rob Landley6b283412013-06-01 20:41:35 -0500415 *p = val;
416 } else if (size & 4) {
Rob Landleya8b88fe2014-03-11 18:11:12 -0500417 volatile int *p = (int *)ptr;
Rob Landley6b283412013-06-01 20:41:35 -0500418 *p = val;
419 } else if (size & 2) {
Rob Landleya8b88fe2014-03-11 18:11:12 -0500420 volatile short *p = (short *)ptr;
Rob Landley6b283412013-06-01 20:41:35 -0500421 *p = val;
422 } else {
Rob Landleya8b88fe2014-03-11 18:11:12 -0500423 volatile char *p = (char *)ptr;
Rob Landley6b283412013-06-01 20:41:35 -0500424 *p = val;
425 }
426}
427
Rob Landley2bfaaf22008-07-03 19:19:00 -0500428// Iterate through an array of files, opening each one and calling a function
429// on that filehandle and name. The special filename "-" means stdin if
430// flags is O_RDONLY, stdout otherwise. An empty argument list calls
431// function() on just stdin/stdout.
432//
Rob Landley784eb9c2014-10-14 14:16:34 -0500433// Note: pass O_CLOEXEC to automatically close filehandles when function()
434// returns, otherwise filehandles must be closed by function()
Rob Landleyad63f4b2011-12-12 15:19:52 -0600435void loopfiles_rw(char **argv, int flags, int permissions, int failok,
Rob Landley7aa651a2012-11-13 17:14:08 -0600436 void (*function)(int fd, char *name))
Rob Landley7634b552007-11-29 17:49:50 -0600437{
Rob Landley7aa651a2012-11-13 17:14:08 -0600438 int fd;
Rob Landley7634b552007-11-29 17:49:50 -0600439
Rob Landley7aa651a2012-11-13 17:14:08 -0600440 // If no arguments, read from stdin.
Rob Landley45b38822014-10-27 18:08:59 -0500441 if (!*argv) function((flags & O_ACCMODE) != O_RDONLY ? 1 : 0, "-");
Rob Landley7aa651a2012-11-13 17:14:08 -0600442 else do {
443 // Filename "-" means read from stdin.
444 // Inability to open a file prints a warning, but doesn't exit.
Rob Landley7634b552007-11-29 17:49:50 -0600445
Rob Landley45b38822014-10-27 18:08:59 -0500446 if (!strcmp(*argv, "-")) fd=0;
Rob Landley7aa651a2012-11-13 17:14:08 -0600447 else if (0>(fd = open(*argv, flags, permissions)) && !failok) {
448 perror_msg("%s", *argv);
449 toys.exitval = 1;
450 continue;
451 }
452 function(fd, *argv);
Rob Landley784eb9c2014-10-14 14:16:34 -0500453 if (flags & O_CLOEXEC) close(fd);
Rob Landley7aa651a2012-11-13 17:14:08 -0600454 } while (*++argv);
Rob Landley7634b552007-11-29 17:49:50 -0600455}
Rob Landleybc078652007-12-15 21:47:25 -0600456
Rob Landley784eb9c2014-10-14 14:16:34 -0500457// Call loopfiles_rw with O_RDONLY|O_CLOEXEC and !failok (common case).
Rob Landley2bfaaf22008-07-03 19:19:00 -0500458void loopfiles(char **argv, void (*function)(int fd, char *name))
459{
Rob Landley784eb9c2014-10-14 14:16:34 -0500460 loopfiles_rw(argv, O_RDONLY|O_CLOEXEC, 0, 0, function);
Rob Landley2bfaaf22008-07-03 19:19:00 -0500461}
462
Rob Landleybc078652007-12-15 21:47:25 -0600463// Slow, but small.
464
Rob Landley3fc4e0f2008-04-13 00:29:00 -0500465char *get_rawline(int fd, long *plen, char end)
Rob Landleybc078652007-12-15 21:47:25 -0600466{
Rob Landley7aa651a2012-11-13 17:14:08 -0600467 char c, *buf = NULL;
468 long len = 0;
Rob Landleybc078652007-12-15 21:47:25 -0600469
Rob Landley7aa651a2012-11-13 17:14:08 -0600470 for (;;) {
471 if (1>read(fd, &c, 1)) break;
472 if (!(len & 63)) buf=xrealloc(buf, len+65);
473 if ((buf[len++]=c) == end) break;
474 }
475 if (buf) buf[len]=0;
476 if (plen) *plen = len;
Rob Landleybc078652007-12-15 21:47:25 -0600477
Rob Landley7aa651a2012-11-13 17:14:08 -0600478 return buf;
Rob Landleybc078652007-12-15 21:47:25 -0600479}
480
481char *get_line(int fd)
482{
Rob Landley7aa651a2012-11-13 17:14:08 -0600483 long len;
484 char *buf = get_rawline(fd, &len, '\n');
Rob Landleybc078652007-12-15 21:47:25 -0600485
Rob Landley7aa651a2012-11-13 17:14:08 -0600486 if (buf && buf[--len]=='\n') buf[len]=0;
Rob Landleybc078652007-12-15 21:47:25 -0600487
Rob Landley7aa651a2012-11-13 17:14:08 -0600488 return buf;
Rob Landleybc078652007-12-15 21:47:25 -0600489}
490
Rob Landley67a069d2012-06-03 00:32:12 -0500491int wfchmodat(int fd, char *name, mode_t mode)
492{
Rob Landley7aa651a2012-11-13 17:14:08 -0600493 int rc = fchmodat(fd, name, mode, 0);
Rob Landley67a069d2012-06-03 00:32:12 -0500494
Rob Landley7aa651a2012-11-13 17:14:08 -0600495 if (rc) {
496 perror_msg("chmod '%s' to %04o", name, mode);
497 toys.exitval=1;
498 }
499 return rc;
Rob Landley67a069d2012-06-03 00:32:12 -0500500}
501
Rob Landleyc52db602012-07-30 01:01:33 -0500502static char *tempfile2zap;
503static void tempfile_handler(int i)
504{
Rob Landley7aa651a2012-11-13 17:14:08 -0600505 if (1 < (long)tempfile2zap) unlink(tempfile2zap);
506 _exit(1);
Rob Landleyc52db602012-07-30 01:01:33 -0500507}
508
Rob Landley42ecbab2007-12-18 02:02:21 -0600509// Open a temporary file to copy an existing file into.
510int copy_tempfile(int fdin, char *name, char **tempname)
511{
Rob Landley7aa651a2012-11-13 17:14:08 -0600512 struct stat statbuf;
513 int fd;
Rob Landley42ecbab2007-12-18 02:02:21 -0600514
Rob Landley9b5000c2014-12-22 17:04:47 -0600515 *tempname = xmprintf("%s%s", name, "XXXXXX");
Rob Landley7aa651a2012-11-13 17:14:08 -0600516 if(-1 == (fd = mkstemp(*tempname))) error_exit("no temp file");
517 if (!tempfile2zap) sigatexit(tempfile_handler);
518 tempfile2zap = *tempname;
Rob Landley42ecbab2007-12-18 02:02:21 -0600519
Rob Landley7aa651a2012-11-13 17:14:08 -0600520 // Set permissions of output file
Rob Landley42ecbab2007-12-18 02:02:21 -0600521
Rob Landley7aa651a2012-11-13 17:14:08 -0600522 fstat(fdin, &statbuf);
523 fchmod(fd, statbuf.st_mode);
Rob Landley42ecbab2007-12-18 02:02:21 -0600524
Rob Landley7aa651a2012-11-13 17:14:08 -0600525 return fd;
Rob Landley42ecbab2007-12-18 02:02:21 -0600526}
527
528// Abort the copy and delete the temporary file.
529void delete_tempfile(int fdin, int fdout, char **tempname)
530{
Rob Landley7aa651a2012-11-13 17:14:08 -0600531 close(fdin);
532 close(fdout);
533 unlink(*tempname);
534 tempfile2zap = (char *)1;
535 free(*tempname);
536 *tempname = NULL;
Rob Landley42ecbab2007-12-18 02:02:21 -0600537}
538
539// Copy the rest of the data and replace the original with the copy.
540void replace_tempfile(int fdin, int fdout, char **tempname)
541{
Rob Landley7aa651a2012-11-13 17:14:08 -0600542 char *temp = xstrdup(*tempname);
Rob Landley42ecbab2007-12-18 02:02:21 -0600543
Rob Landley7aa651a2012-11-13 17:14:08 -0600544 temp[strlen(temp)-6]=0;
545 if (fdin != -1) {
546 xsendfile(fdin, fdout);
547 xclose(fdin);
548 }
549 xclose(fdout);
550 rename(*tempname, temp);
551 tempfile2zap = (char *)1;
552 free(*tempname);
553 free(temp);
554 *tempname = NULL;
Rob Landleybc078652007-12-15 21:47:25 -0600555}
Rob Landley7e849c52009-01-03 18:15:18 -0600556
557// Create a 256 entry CRC32 lookup table.
558
Rob Landleyb15b8fa2009-01-05 01:05:43 -0600559void crc_init(unsigned int *crc_table, int little_endian)
Rob Landley7e849c52009-01-03 18:15:18 -0600560{
Rob Landley7aa651a2012-11-13 17:14:08 -0600561 unsigned int i;
Rob Landley7e849c52009-01-03 18:15:18 -0600562
Rob Landley7aa651a2012-11-13 17:14:08 -0600563 // Init the CRC32 table (big endian)
564 for (i=0; i<256; i++) {
565 unsigned int j, c = little_endian ? i : i<<24;
566 for (j=8; j; j--)
567 if (little_endian) c = (c&1) ? (c>>1)^0xEDB88320 : c>>1;
568 else c=c&0x80000000 ? (c<<1)^0x04c11db7 : (c<<1);
569 crc_table[i] = c;
570 }
Rob Landley7e849c52009-01-03 18:15:18 -0600571}
Rob Landley26e7b5e2012-02-02 07:27:35 -0600572
Rob Landley0517eb72014-12-13 11:58:08 -0600573// Init base64 table
574
575void base64_init(char *p)
576{
577 int i;
578
579 for (i = 'A'; i != ':'; i++) {
580 if (i == 'Z'+1) i = 'a';
581 if (i == 'z'+1) i = '0';
582 *(p++) = i;
583 }
584 *(p++) = '+';
585 *(p++) = '/';
586}
587
Rob Landley26e7b5e2012-02-02 07:27:35 -0600588// Quick and dirty query size of terminal, doesn't do ANSI probe fallback.
Rob Landley10bdaa42013-11-07 09:04:50 -0600589// set x=80 y=25 before calling to provide defaults. Returns 0 if couldn't
590// determine size.
Rob Landley26e7b5e2012-02-02 07:27:35 -0600591
Rob Landley10bdaa42013-11-07 09:04:50 -0600592int terminal_size(unsigned *xx, unsigned *yy)
Rob Landley26e7b5e2012-02-02 07:27:35 -0600593{
Rob Landley7aa651a2012-11-13 17:14:08 -0600594 struct winsize ws;
Rob Landley10bdaa42013-11-07 09:04:50 -0600595 unsigned i, x = 0, y = 0;
Rob Landleyc9cc5302013-10-27 00:02:56 -0500596 char *s;
Rob Landley26e7b5e2012-02-02 07:27:35 -0600597
Rob Landley10bdaa42013-11-07 09:04:50 -0600598 // stdin, stdout, stderr
Rob Landley7aa651a2012-11-13 17:14:08 -0600599 for (i=0; i<3; i++) {
Rob Landleyc9cc5302013-10-27 00:02:56 -0500600 memset(&ws, 0, sizeof(ws));
601 if (!ioctl(i, TIOCGWINSZ, &ws)) {
602 if (ws.ws_col) x = ws.ws_col;
603 if (ws.ws_row) y = ws.ws_row;
Rob Landley26e7b5e2012-02-02 07:27:35 -0600604
Rob Landleyc9cc5302013-10-27 00:02:56 -0500605 break;
606 }
Rob Landley7aa651a2012-11-13 17:14:08 -0600607 }
Rob Landleyc9cc5302013-10-27 00:02:56 -0500608 s = getenv("COLUMNS");
609 if (s) sscanf(s, "%u", &x);
610 s = getenv("ROWS");
611 if (s) sscanf(s, "%u", &y);
Rob Landley26e7b5e2012-02-02 07:27:35 -0600612
Rob Landley10bdaa42013-11-07 09:04:50 -0600613 // Never return 0 for either value, leave it at default instead.
614 if (xx && x) *xx = x;
615 if (yy && y) *yy = y;
616
617 return x || y;
Rob Landley26e7b5e2012-02-02 07:27:35 -0600618}
619
Rob Landleyf793d532012-02-27 21:56:49 -0600620int yesno(char *prompt, int def)
Rob Landley26e7b5e2012-02-02 07:27:35 -0600621{
Rob Landley7aa651a2012-11-13 17:14:08 -0600622 char buf;
Rob Landley26e7b5e2012-02-02 07:27:35 -0600623
Rob Landleydb8eb322012-12-08 02:25:32 -0600624 fprintf(stderr, "%s (%c/%c):", prompt, def ? 'Y' : 'y', def ? 'n' : 'N');
625 fflush(stderr);
626 while (fread(&buf, 1, 1, stdin)) {
627 int new;
Rob Landley26e7b5e2012-02-02 07:27:35 -0600628
Rob Landley22791082013-01-31 04:13:07 -0600629 // The letter changes the value, the newline (or space) returns it.
Rob Landleydb8eb322012-12-08 02:25:32 -0600630 if (isspace(buf)) break;
631 if (-1 != (new = stridx("ny", tolower(buf)))) def = new;
Rob Landley7aa651a2012-11-13 17:14:08 -0600632 }
Rob Landleyee00a7f2012-03-19 19:19:21 -0500633
Rob Landley7aa651a2012-11-13 17:14:08 -0600634 return def;
Rob Landley26e7b5e2012-02-02 07:27:35 -0600635}
Rob Landleyff9ee8f2012-02-18 15:12:41 -0600636
Rob Landley2dd50ad2012-02-26 13:48:00 -0600637struct signame {
Rob Landley7aa651a2012-11-13 17:14:08 -0600638 int num;
639 char *name;
Rob Landley2dd50ad2012-02-26 13:48:00 -0600640};
641
642// Signals required by POSIX 2008:
643// http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/signal.h.html
644
645#define SIGNIFY(x) {SIG##x, #x}
646
647static struct signame signames[] = {
Rob Landley7aa651a2012-11-13 17:14:08 -0600648 SIGNIFY(ABRT), SIGNIFY(ALRM), SIGNIFY(BUS),
649 SIGNIFY(FPE), SIGNIFY(HUP), SIGNIFY(ILL), SIGNIFY(INT), SIGNIFY(KILL),
650 SIGNIFY(PIPE), SIGNIFY(QUIT), SIGNIFY(SEGV), SIGNIFY(TERM),
651 SIGNIFY(USR1), SIGNIFY(USR2), SIGNIFY(SYS), SIGNIFY(TRAP),
652 SIGNIFY(VTALRM), SIGNIFY(XCPU), SIGNIFY(XFSZ),
Rob Landleyc52db602012-07-30 01:01:33 -0500653
Rob Landley7aa651a2012-11-13 17:14:08 -0600654 // Start of non-terminal signals
Rob Landleyc52db602012-07-30 01:01:33 -0500655
Rob Landley7aa651a2012-11-13 17:14:08 -0600656 SIGNIFY(CHLD), SIGNIFY(CONT), SIGNIFY(STOP), SIGNIFY(TSTP),
657 SIGNIFY(TTIN), SIGNIFY(TTOU), SIGNIFY(URG)
Rob Landley2dd50ad2012-02-26 13:48:00 -0600658};
659
660// not in posix: SIGNIFY(STKFLT), SIGNIFY(WINCH), SIGNIFY(IO), SIGNIFY(PWR)
661// obsolete: SIGNIFY(PROF) SIGNIFY(POLL)
662
Rob Landley1bc52242014-05-21 07:24:16 -0500663// Handler that sets toys.signal, and writes to toys.signalfd if set
664void generic_signal(int sig)
665{
666 if (toys.signalfd) {
667 char c = sig;
668
669 writeall(toys.signalfd, &c, 1);
670 }
671 toys.signal = sig;
672}
673
Rob Landleyc52db602012-07-30 01:01:33 -0500674// Install the same handler on every signal that defaults to killing the process
675void sigatexit(void *handler)
676{
Rob Landley7aa651a2012-11-13 17:14:08 -0600677 int i;
678 for (i=0; signames[i].num != SIGCHLD; i++) signal(signames[i].num, handler);
Rob Landleyc52db602012-07-30 01:01:33 -0500679}
Rob Landley1bc52242014-05-21 07:24:16 -0500680
Rob Landley2dd50ad2012-02-26 13:48:00 -0600681// Convert name to signal number. If name == NULL print names.
682int sig_to_num(char *pidstr)
683{
Rob Landley7aa651a2012-11-13 17:14:08 -0600684 int i;
Rob Landley2dd50ad2012-02-26 13:48:00 -0600685
Rob Landley7aa651a2012-11-13 17:14:08 -0600686 if (pidstr) {
687 char *s;
688 i = strtol(pidstr, &s, 10);
689 if (!*s) return i;
Rob Landley2dd50ad2012-02-26 13:48:00 -0600690
Rob Landley7aa651a2012-11-13 17:14:08 -0600691 if (!strncasecmp(pidstr, "sig", 3)) pidstr+=3;
692 }
693 for (i = 0; i < sizeof(signames)/sizeof(struct signame); i++)
694 if (!pidstr) xputs(signames[i].name);
695 else if (!strcasecmp(pidstr, signames[i].name)) return signames[i].num;
Rob Landley2dd50ad2012-02-26 13:48:00 -0600696
Rob Landley7aa651a2012-11-13 17:14:08 -0600697 return -1;
Rob Landley2dd50ad2012-02-26 13:48:00 -0600698}
699
700char *num_to_sig(int sig)
701{
Rob Landley7aa651a2012-11-13 17:14:08 -0600702 int i;
Rob Landley2dd50ad2012-02-26 13:48:00 -0600703
Rob Landley7aa651a2012-11-13 17:14:08 -0600704 for (i=0; i<sizeof(signames)/sizeof(struct signame); i++)
705 if (signames[i].num == sig) return signames[i].name;
706 return NULL;
Rob Landley2dd50ad2012-02-26 13:48:00 -0600707}
Daniel Walter05744b32012-03-19 19:57:56 -0500708
Rob Landleyc52db602012-07-30 01:01:33 -0500709// premute mode bits based on posix mode strings.
Rob Landleyb6f601e2012-05-16 21:11:43 -0500710mode_t string_to_mode(char *modestr, mode_t mode)
Daniel Walter05744b32012-03-19 19:57:56 -0500711{
Rob Landley3b5b19e2014-08-15 10:50:39 -0500712 char *whos = "ogua", *hows = "=+-", *whats = "xwrstX", *whys = "ogu",
713 *s, *str = modestr;
714 mode_t extrabits = mode & ~(07777);
Rob Landleycf6bcb22012-03-19 20:56:18 -0500715
Rob Landley7aa651a2012-11-13 17:14:08 -0600716 // Handle octal mode
717 if (isdigit(*str)) {
718 mode = strtol(str, &s, 8);
719 if (*s || (mode & ~(07777))) goto barf;
Rob Landleyb6f601e2012-05-16 21:11:43 -0500720
Rob Landley3b5b19e2014-08-15 10:50:39 -0500721 return mode | extrabits;
Rob Landley7aa651a2012-11-13 17:14:08 -0600722 }
Rob Landleycf6bcb22012-03-19 20:56:18 -0500723
Rob Landley7aa651a2012-11-13 17:14:08 -0600724 // Gaze into the bin of permission...
725 for (;;) {
726 int i, j, dowho, dohow, dowhat, amask;
Rob Landleycf6bcb22012-03-19 20:56:18 -0500727
Rob Landley7aa651a2012-11-13 17:14:08 -0600728 dowho = dohow = dowhat = amask = 0;
Daniel Walter05744b32012-03-19 19:57:56 -0500729
Rob Landley7aa651a2012-11-13 17:14:08 -0600730 // Find the who, how, and what stanzas, in that order
731 while (*str && (s = strchr(whos, *str))) {
732 dowho |= 1<<(s-whos);
733 str++;
734 }
735 // If who isn't specified, like "a" but honoring umask.
736 if (!dowho) {
737 dowho = 8;
738 umask(amask=umask(0));
739 }
740 if (!*str || !(s = strchr(hows, *str))) goto barf;
741 dohow = *(str++);
Rob Landley67a069d2012-06-03 00:32:12 -0500742
Rob Landley7aa651a2012-11-13 17:14:08 -0600743 if (!dohow) goto barf;
744 while (*str && (s = strchr(whats, *str))) {
745 dowhat |= 1<<(s-whats);
746 str++;
747 }
Rob Landleyb6f601e2012-05-16 21:11:43 -0500748
Rob Landley7aa651a2012-11-13 17:14:08 -0600749 // Convert X to x for directory or if already executable somewhere
750 if ((dowhat&32) && (S_ISDIR(mode) || (mode&0111))) dowhat |= 1;
Rob Landleyb6f601e2012-05-16 21:11:43 -0500751
Rob Landley7aa651a2012-11-13 17:14:08 -0600752 // Copy mode from another category?
753 if (!dowhat && *str && (s = strchr(whys, *str))) {
754 dowhat = (mode>>(3*(s-whys)))&7;
755 str++;
756 }
Rob Landleyb6f601e2012-05-16 21:11:43 -0500757
Rob Landley7aa651a2012-11-13 17:14:08 -0600758 // Are we ready to do a thing yet?
759 if (*str && *(str++) != ',') goto barf;
Rob Landleyb6f601e2012-05-16 21:11:43 -0500760
Rob Landley7aa651a2012-11-13 17:14:08 -0600761 // Ok, apply the bits to the mode.
762 for (i=0; i<4; i++) {
763 for (j=0; j<3; j++) {
764 mode_t bit = 0;
765 int where = 1<<((3*i)+j);
Rob Landley31f49e72012-07-21 22:45:05 -0500766
Rob Landley7aa651a2012-11-13 17:14:08 -0600767 if (amask & where) continue;
Rob Landleyb6f601e2012-05-16 21:11:43 -0500768
Rob Landley7aa651a2012-11-13 17:14:08 -0600769 // Figure out new value at this location
770 if (i == 3) {
771 // suid/sticky bit.
772 if (j) {
773 if ((dowhat & 8) && (dowho&(8|(1<<i)))) bit++;
774 } else if (dowhat & 16) bit++;
775 } else {
776 if (!(dowho&(8|(1<<i)))) continue;
777 if (dowhat&(1<<j)) bit++;
778 }
Rob Landleyb6f601e2012-05-16 21:11:43 -0500779
Rob Landley7aa651a2012-11-13 17:14:08 -0600780 // When selection active, modify bit
Rob Landleyb6f601e2012-05-16 21:11:43 -0500781
Rob Landley7aa651a2012-11-13 17:14:08 -0600782 if (dohow == '=' || (bit && dohow == '-')) mode &= ~where;
783 if (bit && dohow != '-') mode |= where;
784 }
785 }
Rob Landleyb6f601e2012-05-16 21:11:43 -0500786
Rob Landley7aa651a2012-11-13 17:14:08 -0600787 if (!*str) break;
788 }
Rob Landley3b5b19e2014-08-15 10:50:39 -0500789
790 return mode|extrabits;
Rob Landleyb6f601e2012-05-16 21:11:43 -0500791barf:
Rob Landley7aa651a2012-11-13 17:14:08 -0600792 error_exit("bad mode '%s'", modestr);
Daniel Walter05744b32012-03-19 19:57:56 -0500793}
Ashwini Kumar1a0eedf2012-08-26 21:17:00 -0500794
Rob Landley5a26a862013-06-02 00:24:24 -0500795// Format access mode into a drwxrwxrwx string
796void mode_to_string(mode_t mode, char *buf)
Felix Janda5a221e62013-04-22 22:29:43 +0200797{
798 char c, d;
799 int i, bit;
800
Rob Landley5a26a862013-06-02 00:24:24 -0500801 buf[10]=0;
Felix Janda5a221e62013-04-22 22:29:43 +0200802 for (i=0; i<9; i++) {
803 bit = mode & (1<<i);
804 c = i%3;
805 if (!c && (mode & (1<<((d=i/3)+9)))) {
806 c = "tss"[d];
807 if (!bit) c &= ~0x20;
808 } else c = bit ? "xwr"[c] : '-';
Rob Landley5a26a862013-06-02 00:24:24 -0500809 buf[9-i] = c;
Felix Janda5a221e62013-04-22 22:29:43 +0200810 }
811
812 if (S_ISDIR(mode)) c = 'd';
813 else if (S_ISBLK(mode)) c = 'b';
814 else if (S_ISCHR(mode)) c = 'c';
815 else if (S_ISLNK(mode)) c = 'l';
816 else if (S_ISFIFO(mode)) c = 'p';
817 else if (S_ISSOCK(mode)) c = 's';
818 else c = '-';
Rob Landley5a26a862013-06-02 00:24:24 -0500819 *buf = c;
Felix Janda5a221e62013-04-22 22:29:43 +0200820}
Rob Landleydb1009d2013-12-19 09:32:30 -0600821
822// Execute a callback for each PID that matches a process name from a list.
823void names_to_pid(char **names, int (*callback)(pid_t pid, char *name))
824{
825 DIR *dp;
826 struct dirent *entry;
827
828 if (!(dp = opendir("/proc"))) perror_exit("opendir");
829
830 while ((entry = readdir(dp))) {
831 unsigned u;
832 char *cmd, **curname;
833
834 if (!(u = atoi(entry->d_name))) continue;
835 sprintf(libbuf, "/proc/%u/cmdline", u);
836 if (!(cmd = readfile(libbuf, libbuf, sizeof(libbuf)))) continue;
837
838 for (curname = names; *curname; curname++)
839 if (**curname == '/' ? !strcmp(cmd, *curname)
840 : !strcmp(basename(cmd), basename(*curname)))
841 if (callback(u, *curname)) break;
842 if (*curname) break;
843 }
844 closedir(dp);
845}
Rob Landley48c172b2014-05-06 06:31:28 -0500846
847// display first few digits of number with power of two units, except we're
848// actually just counting decimal digits and showing mil/bil/trillions.
849int human_readable(char *buf, unsigned long long num)
850{
851 int end, len;
852
853 len = sprintf(buf, "%lld", num);
854 end = ((len-1)%3)+1;
855 len /= 3;
856
857 if (len && end == 1) {
858 buf[2] = buf[1];
859 buf[1] = '.';
860 end = 3;
861 }
862 buf[end++] = ' ';
863 if (len) buf[end++] = " KMGTPE"[len];
864 buf[end++] = 'B';
865 buf[end++] = 0;
866
867 return end;
868}