1 /* lib.c - various reusable stuff.
3 * Copyright 2006 Rob Landley <rob@landley.net>
8 void verror_msg(char *msg, int err, va_list va)
12 fprintf(stderr, "%s: ", toys.which->name);
13 if (msg) vfprintf(stderr, msg, va);
15 if (err>0) fprintf(stderr, s, strerror(err));
16 if (err<0 && CFG_TOYBOX_HELP)
17 fprintf(stderr, " (see \"%s --help\")", toys.which->name);
18 if (msg || err) putc('\n', stderr);
19 if (!toys.exitval) toys.exitval++;
22 // These functions don't collapse together because of the va_stuff.
24 void error_msg(char *msg, ...)
29 verror_msg(msg, 0, va);
33 void perror_msg(char *msg, ...)
38 verror_msg(msg, errno, va);
42 // Die with an error message.
43 void error_exit(char *msg, ...)
48 verror_msg(msg, 0, va);
54 // Die with an error message and strerror(errno)
55 void perror_exit(char *msg, ...)
60 verror_msg(msg, errno, va);
66 // Exit with an error message after showing help text.
67 void help_exit(char *msg, ...)
71 if (!msg) show_help(stdout);
74 verror_msg(msg, -1, va);
81 // If you want to explicitly disable the printf() behavior (because you're
82 // printing user-supplied data, or because android's static checker produces
83 // false positives for 'char *s = x ? "blah1" : "blah2"; printf(s);' and it's
84 // -Werror there for policy reasons).
85 void error_msg_raw(char *msg)
90 void perror_msg_raw(char *msg)
92 perror_msg("%s", msg);
95 void error_exit_raw(char *msg)
97 error_exit("%s", msg);
100 void perror_exit_raw(char *msg)
102 perror_exit("%s", msg);
105 // Keep reading until full or EOF
106 ssize_t readall(int fd, void *buf, size_t len)
111 int i = read(fd, (char *)buf+count, len-count);
120 // Keep writing until done or EOF
121 ssize_t writeall(int fd, void *buf, size_t len)
125 int i = write(fd, count+(char *)buf, len-count);
133 // skip this many bytes of input. Return 0 for success, >0 means this much
134 // left after input skipped.
135 off_t lskip(int fd, off_t offset)
137 off_t cur = lseek(fd, 0, SEEK_CUR);
140 off_t end = lseek(fd, 0, SEEK_END) - cur;
142 if (end > 0 && end < offset) return offset - end;
144 if (end == lseek(fd, end, SEEK_SET)) return 0;
145 perror_exit("lseek");
149 int try = offset>sizeof(libbuf) ? sizeof(libbuf) : offset, or;
151 or = readall(fd, libbuf, try);
152 if (or < 0) perror_exit("lskip to %lld", (long long)offset);
160 // flags: 1=make last dir (with mode lastmode, otherwise skips last component)
161 // 2=make path (already exists is ok)
163 // returns 0 = path ok, 1 = error
164 int mkpathat(int atfd, char *dir, mode_t lastmode, int flags)
169 // mkdir -p one/two/three is not an error if the path already exists,
170 // but is if "three" is a file. The others we dereference and catch
171 // not-a-directory along the way, but the last one we must explicitly
172 // test for. Might as well do it up front.
174 if (!fstatat(atfd, dir, &buf, 0) && !S_ISDIR(buf.st_mode)) {
179 for (s = dir; ;s++) {
181 mode_t mode = (0777&~toys.old_umask)|0300;
183 // find next '/', but don't try to mkdir "" at start of absolute path
184 if (*s == '/' && (flags&2) && s != dir) {
187 } else if (*s) continue;
189 // Use the mode from the -m option only for the last directory.
191 if (flags&1) mode = lastmode;
195 if (mkdirat(atfd, dir, mode)) {
196 if (!(flags&2) || errno != EEXIST) return 1;
198 fprintf(stderr, "%s: created directory '%s'\n", toys.which->name, dir);
200 if (!(*s = save)) break;
206 // Split a path into linked list of components, tracking head and tail of list.
207 // Filters out // entries with no contents.
208 struct string_list **splitpath(char *path, struct string_list **list)
216 if (*path && *path != '/') continue;
219 *list = xmalloc(sizeof(struct string_list) + len + 1);
221 memcpy((*list)->str, new, len);
222 (*list)->str[len] = 0;
223 list = &(*list)->next;
231 // Find all file in a colon-separated path with access type "type" (generally
232 // X_OK or R_OK). Returns a list of absolute paths to each file found, in
235 struct string_list *find_in_path(char *path, char *filename)
237 struct string_list *rlist = NULL, **prlist=&rlist;
244 char *next = strchr(path, ':');
245 int len = next ? next-path : strlen(path);
246 struct string_list *rnext;
249 rnext = xmalloc(sizeof(void *) + strlen(filename)
250 + (len ? len : strlen(cwd)) + 2);
251 if (!len) sprintf(rnext->str, "%s/%s", cwd, filename);
253 char *res = rnext->str;
255 memcpy(res, path, len);
258 strcpy(res, filename);
261 // Confirm it's not a directory.
262 if (!stat(rnext->str, &st) && S_ISREG(st.st_mode)) {
265 prlist = &(rnext->next);
277 long long estrtol(char *str, char **end, int base)
281 return strtoll(str, end, base);
284 long long xstrtol(char *str, char **end, int base)
286 long long l = estrtol(str, end, base);
288 if (errno) perror_exit_raw(str);
293 // atol() with the kilo/mega/giga/tera/peta/exa extensions, plus word and block.
294 // (zetta and yotta don't fit in 64 bits.)
295 long long atolx(char *numstr)
297 char *c = numstr, *suffixes="cwbkmgtpe", *end;
300 val = xstrtol(numstr, &c, 0);
301 if (c != numstr && *c && (end = strchr(suffixes, tolower(*c)))) {
302 int shift = end-suffixes-2;
304 if (shift==-1) val *= 2;
305 if (!shift) val *= 512;
307 if (toupper(*++c)=='d') while (shift--) val *= 1000;
308 else val *= 1LL<<(shift*10);
311 while (isspace(*c)) c++;
312 if (c==numstr || *c) error_exit("not integer: %s", numstr);
317 long long atolx_range(char *numstr, long long low, long long high)
319 long long val = atolx(numstr);
321 if (val < low) error_exit("%lld < %lld", val, low);
322 if (val > high) error_exit("%lld > %lld", val, high);
327 int stridx(char *haystack, char needle)
331 if (!needle) return -1;
332 off = strchr(haystack, needle);
338 // Convert utf8 sequence to a unicode wide character
339 int utf8towc(wchar_t *wc, char *str, unsigned len)
341 unsigned result, mask, first;
345 if (len && *str<128) return !!(*wc = *str);
347 result = first = *(s = str++);
348 if (result<0xc2 || result>0xf4) return -1;
349 for (mask = 6; (first&0xc0)==0xc0; mask += 5, first <<= 1) {
350 if (!--len) return -2;
351 if (((c = *(str++))&0xc0) != 0x80) return -1;
352 result = (result<<6)|(c&0x3f);
354 result &= (1<<mask)-1;
357 // Avoid overlong encodings
358 if (result<(unsigned []){0x80,0x800,0x10000}[c-2]) return -1;
360 // Limit unicode so it can't encode anything UTF-16 can't.
361 if (result>0x10ffff || (result>=0xd800 && result<=0xdfff)) return -1;
367 char *strlower(char *s)
371 if (!CFG_TOYBOX_I18N) {
372 try = new = xstrdup(s);
373 for (; *s; s++) *(new++) = tolower(*s);
375 // I can't guarantee the string _won't_ expand during reencoding, so...?
376 try = new = xmalloc(strlen(s)*2+1);
380 int len = utf8towc(&c, s, MB_CUR_MAX);
382 if (len < 1) *(new++) = *(s++);
385 // squash title case too
388 // if we had a valid utf8 sequence, convert it to lower case, and can't
389 // encode back to utf8, something is wrong with your libc. But just
390 // in case somebody finds an exploit...
391 len = wcrtomb(new, c, 0);
392 if (len < 1) error_exit("bad utf8 %x", (int)c);
402 // strstr but returns pointer after match
403 char *strafter(char *haystack, char *needle)
405 char *s = strstr(haystack, needle);
407 return s ? s+strlen(needle) : s;
410 // Remove trailing \n
413 char *p = strrchr(s, '\n');
415 if (p && !p[1]) *p = 0;
421 char *from = "\\abefnrtv", *to = "\\\a\b\033\f\n\r\t\v";
422 int idx = stridx(from, c);
424 return (idx == -1) ? 0 : to[idx];
427 // If string ends with suffix return pointer to start of suffix in string,
429 char *strend(char *str, char *suffix)
431 long a = strlen(str), b = strlen(suffix);
433 if (a>b && !strcmp(str += a-b, suffix)) return str;
438 // If *a starts with b, advance *a past it and return 1, else return 0;
439 int strstart(char **a, char *b)
441 int len = strlen(b), i = !strncmp(*a, b, len);
448 // Return how long the file at fd is, if there's any way to determine it.
449 off_t fdlength(int fd)
452 off_t base = 0, range = 1, expand = 1, old;
454 if (!fstat(fd, &st) && S_ISREG(st.st_mode)) return st.st_size;
456 // If the ioctl works for this, return it.
457 // TODO: is blocksize still always 512, or do we stat for it?
458 // unsigned int size;
459 // if (ioctl(fd, BLKGETSIZE, &size) >= 0) return size*512L;
461 // If not, do a binary search for the last location we can read. (Some
462 // block devices don't do BLKGETSIZE right.) This should probably have
463 // a CONFIG option...
465 // If not, do a binary search for the last location we can read.
467 old = lseek(fd, 0, SEEK_CUR);
470 off_t pos = base + range / 2;
472 if (lseek(fd, pos, 0)>=0 && read(fd, &temp, 1)==1) {
473 off_t delta = (pos + 1) - base;
476 if (expand) range = (expand <<= 1) - base;
484 lseek(fd, old, SEEK_SET);
489 // Read contents of file as a single nul-terminated string.
490 // measure file size if !len, allocate buffer if !buf
491 // Existing buffers need len in *plen
492 // Returns amount of data read in *plen
493 char *readfileat(int dirfd, char *name, char *ibuf, off_t *plen)
499 // Unsafe to probe for size with a supplied buffer, don't ever do that.
500 if (CFG_TOYBOX_DEBUG && (ibuf ? !*plen : *plen)) error_exit("bad readfileat");
502 if (-1 == (fd = openat(dirfd, name, O_RDONLY))) return 0;
504 // If we dunno the length, probe it. If we can't probe, start with 1 page.
506 if ((len = fdlength(fd))>0) *plen = len;
508 } else len = *plen-1;
510 if (!ibuf) buf = xmalloc(len+1);
514 rlen = readall(fd, rbuf, len);
515 if (*plen || rlen<len) break;
517 // If reading unknown size, expand buffer by 1.5 each time we fill it up.
519 buf = xrealloc(buf, len = (rlen*3)/2);
523 *plen = len = rlen+(rbuf-buf);
527 if (ibuf != buf) free(buf);
534 char *readfile(char *name, char *ibuf, off_t len)
536 return readfileat(AT_FDCWD, name, ibuf, &len);
539 // Sleep for this many thousandths of a second
540 void msleep(long miliseconds)
544 ts.tv_sec = miliseconds/1000;
545 ts.tv_nsec = (miliseconds%1000)*1000000;
549 // return 1<<x of highest bit set
550 int highest_bit(unsigned long l)
554 for (i = 0; l; i++) l >>= 1;
559 // Inefficient, but deals with unaligned access
560 int64_t peek_le(void *ptr, unsigned size)
566 for (i=0; i<size; i++) ret |= ((int64_t)c[i])<<(i*8);
570 int64_t peek_be(void *ptr, unsigned size)
576 for (i=0; i<size; i++) ret = (ret<<8)|(c[i]&0xff);
580 int64_t peek(void *ptr, unsigned size)
582 return IS_BIG_ENDIAN ? peek_be(ptr, size) : peek_le(ptr, size);
585 void poke(void *ptr, uint64_t val, int size)
588 volatile uint64_t *p = (uint64_t *)ptr;
590 } else if (size & 4) {
591 volatile int *p = (int *)ptr;
593 } else if (size & 2) {
594 volatile short *p = (short *)ptr;
597 volatile char *p = (char *)ptr;
602 // Iterate through an array of files, opening each one and calling a function
603 // on that filehandle and name. The special filename "-" means stdin if
604 // flags is O_RDONLY, stdout otherwise. An empty argument list calls
605 // function() on just stdin/stdout.
607 // Note: pass O_CLOEXEC to automatically close filehandles when function()
608 // returns, otherwise filehandles must be closed by function().
609 // pass WARN_ONLY to produce warning messages about files it couldn't
610 // open/create, and skip them. Otherwise function is called with fd -1.
611 void loopfiles_rw(char **argv, int flags, int permissions,
612 void (*function)(int fd, char *name))
614 int fd, failok = !(flags&WARN_ONLY);
618 // If no arguments, read from stdin.
619 if (!*argv) function((flags & O_ACCMODE) != O_RDONLY ? 1 : 0, "-");
621 // Filename "-" means read from stdin.
622 // Inability to open a file prints a warning, but doesn't exit.
624 if (!strcmp(*argv, "-")) fd = 0;
625 else if (0>(fd = notstdio(open(*argv, flags, permissions))) && !failok) {
626 perror_msg_raw(*argv);
630 if ((flags & O_CLOEXEC) && fd) close(fd);
634 // Call loopfiles_rw with O_RDONLY|O_CLOEXEC|WARN_ONLY (common case)
635 void loopfiles(char **argv, void (*function)(int fd, char *name))
637 loopfiles_rw(argv, O_RDONLY|O_CLOEXEC|WARN_ONLY, 0, function);
640 // call loopfiles with do_lines()
641 static void (*do_lines_bridge)(char **pline, long len);
642 static void loopfile_lines_bridge(int fd, char *name)
644 do_lines(fd, do_lines_bridge);
647 void loopfiles_lines(char **argv, void (*function)(char **pline, long len))
649 do_lines_bridge = function;
650 loopfiles(argv, loopfile_lines_bridge);
655 char *get_rawline(int fd, long *plen, char end)
661 if (1>read(fd, &c, 1)) break;
662 if (!(len & 63)) buf=xrealloc(buf, len+65);
663 if ((buf[len++]=c) == end) break;
666 if (plen) *plen = len;
671 char *get_line(int fd)
674 char *buf = get_rawline(fd, &len, '\n');
676 if (buf && buf[--len]=='\n') buf[len]=0;
681 int wfchmodat(int fd, char *name, mode_t mode)
683 int rc = fchmodat(fd, name, mode, 0);
686 perror_msg("chmod '%s' to %04o", name, mode);
692 static char *tempfile2zap;
693 static void tempfile_handler(void)
695 if (1 < (long)tempfile2zap) unlink(tempfile2zap);
698 // Open a temporary file to copy an existing file into.
699 int copy_tempfile(int fdin, char *name, char **tempname)
703 int ignored __attribute__((__unused__));
705 *tempname = xmprintf("%s%s", name, "XXXXXX");
706 if(-1 == (fd = mkstemp(*tempname))) error_exit("no temp file");
707 if (!tempfile2zap) sigatexit(tempfile_handler);
708 tempfile2zap = *tempname;
710 // Set permissions of output file (ignoring errors, usually due to nonroot)
712 fstat(fdin, &statbuf);
713 fchmod(fd, statbuf.st_mode);
715 // We chmod before chown, which strips the suid bit. Caller has to explicitly
716 // switch it back on if they want to keep suid.
718 // Suppress warn-unused-result. Both gcc and clang clutch their pearls about
719 // this but it's _supposed_ to fail when we're not root.
720 ignored = fchown(fd, statbuf.st_uid, statbuf.st_gid);
725 // Abort the copy and delete the temporary file.
726 void delete_tempfile(int fdin, int fdout, char **tempname)
730 if (*tempname) unlink(*tempname);
731 tempfile2zap = (char *)1;
736 // Copy the rest of the data and replace the original with the copy.
737 void replace_tempfile(int fdin, int fdout, char **tempname)
739 char *temp = xstrdup(*tempname);
741 temp[strlen(temp)-6]=0;
743 xsendfile(fdin, fdout);
747 rename(*tempname, temp);
748 tempfile2zap = (char *)1;
754 // Create a 256 entry CRC32 lookup table.
756 void crc_init(unsigned int *crc_table, int little_endian)
760 // Init the CRC32 table (big endian)
761 for (i=0; i<256; i++) {
762 unsigned int j, c = little_endian ? i : i<<24;
764 if (little_endian) c = (c&1) ? (c>>1)^0xEDB88320 : c>>1;
765 else c=c&0x80000000 ? (c<<1)^0x04c11db7 : (c<<1);
772 void base64_init(char *p)
776 for (i = 'A'; i != ':'; i++) {
777 if (i == 'Z'+1) i = 'a';
778 if (i == 'z'+1) i = '0';
789 fprintf(stderr, " (%c/%c):", def ? 'Y' : 'y', def ? 'n' : 'N');
791 while (fread(&buf, 1, 1, stdin)) {
794 // The letter changes the value, the newline (or space) returns it.
795 if (isspace(buf)) break;
796 if (-1 != (new = stridx("ny", tolower(buf)))) def = new;
807 // Signals required by POSIX 2008:
808 // http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/signal.h.html
810 #define SIGNIFY(x) {SIG##x, #x}
812 static struct signame signames[] = {
813 SIGNIFY(ABRT), SIGNIFY(ALRM), SIGNIFY(BUS),
814 SIGNIFY(FPE), SIGNIFY(HUP), SIGNIFY(ILL), SIGNIFY(INT), SIGNIFY(KILL),
815 SIGNIFY(PIPE), SIGNIFY(QUIT), SIGNIFY(SEGV), SIGNIFY(TERM),
816 SIGNIFY(USR1), SIGNIFY(USR2), SIGNIFY(SYS), SIGNIFY(TRAP),
817 SIGNIFY(VTALRM), SIGNIFY(XCPU), SIGNIFY(XFSZ),
819 // Start of non-terminal signals
821 SIGNIFY(CHLD), SIGNIFY(CONT), SIGNIFY(STOP), SIGNIFY(TSTP),
822 SIGNIFY(TTIN), SIGNIFY(TTOU), SIGNIFY(URG)
825 // not in posix: SIGNIFY(STKFLT), SIGNIFY(WINCH), SIGNIFY(IO), SIGNIFY(PWR)
826 // obsolete: SIGNIFY(PROF) SIGNIFY(POLL)
828 // Handler that sets toys.signal, and writes to toys.signalfd if set
829 void generic_signal(int sig)
834 writeall(toys.signalfd, &c, 1);
839 void exit_signal(int sig)
841 if (sig) toys.exitval = sig|128;
845 // Install the same handler on every signal that defaults to killing the
846 // process, calling the handler on the way out. Calling multiple times
847 // adds the handlers to a list, to be called in order.
848 void sigatexit(void *handler)
850 struct arg_list *al = xmalloc(sizeof(struct arg_list));
853 for (i=0; signames[i].num != SIGCHLD; i++)
854 signal(signames[i].num, exit_signal);
855 al->next = toys.xexit;
860 // Convert name to signal number. If name == NULL print names.
861 int sig_to_num(char *pidstr)
868 i = estrtol(pidstr, &s, 10);
869 if (!errno && !*s) return i;
871 if (!strncasecmp(pidstr, "sig", 3)) pidstr+=3;
873 for (i = 0; i < sizeof(signames)/sizeof(struct signame); i++)
874 if (!pidstr) xputs(signames[i].name);
875 else if (!strcasecmp(pidstr, signames[i].name)) return signames[i].num;
880 char *num_to_sig(int sig)
884 for (i=0; i<sizeof(signames)/sizeof(struct signame); i++)
885 if (signames[i].num == sig) return signames[i].name;
889 // premute mode bits based on posix mode strings.
890 mode_t string_to_mode(char *modestr, mode_t mode)
892 char *whos = "ogua", *hows = "=+-", *whats = "xwrstX", *whys = "ogu",
894 mode_t extrabits = mode & ~(07777);
898 mode = estrtol(str, &s, 8);
899 if (errno || *s || (mode & ~(07777))) goto barf;
901 return mode | extrabits;
904 // Gaze into the bin of permission...
906 int i, j, dowho, dohow, dowhat, amask;
908 dowho = dohow = dowhat = amask = 0;
910 // Find the who, how, and what stanzas, in that order
911 while (*str && (s = strchr(whos, *str))) {
912 dowho |= 1<<(s-whos);
915 // If who isn't specified, like "a" but honoring umask.
918 umask(amask=umask(0));
920 if (!*str || !(s = strchr(hows, *str))) goto barf;
923 if (!dohow) goto barf;
924 while (*str && (s = strchr(whats, *str))) {
925 dowhat |= 1<<(s-whats);
929 // Convert X to x for directory or if already executable somewhere
930 if ((dowhat&32) && (S_ISDIR(mode) || (mode&0111))) dowhat |= 1;
932 // Copy mode from another category?
933 if (!dowhat && *str && (s = strchr(whys, *str))) {
934 dowhat = (mode>>(3*(s-whys)))&7;
938 // Are we ready to do a thing yet?
939 if (*str && *(str++) != ',') goto barf;
941 // Ok, apply the bits to the mode.
942 for (i=0; i<4; i++) {
943 for (j=0; j<3; j++) {
945 int where = 1<<((3*i)+j);
947 if (amask & where) continue;
949 // Figure out new value at this location
953 if ((dowhat & 8) && (dowho&(8|(1<<i)))) bit++;
954 } else if (dowhat & 16) bit++;
956 if (!(dowho&(8|(1<<i)))) continue;
957 if (dowhat&(1<<j)) bit++;
960 // When selection active, modify bit
962 if (dohow == '=' || (bit && dohow == '-')) mode &= ~where;
963 if (bit && dohow != '-') mode |= where;
970 return mode|extrabits;
972 error_exit("bad mode '%s'", modestr);
975 // Format access mode into a drwxrwxrwx string
976 void mode_to_string(mode_t mode, char *buf)
982 for (i=0; i<9; i++) {
985 if (!c && (mode & (1<<((d=i/3)+9)))) {
987 if (!bit) c &= ~0x20;
988 } else c = bit ? "xwr"[c] : '-';
992 if (S_ISDIR(mode)) c = 'd';
993 else if (S_ISBLK(mode)) c = 'b';
994 else if (S_ISCHR(mode)) c = 'c';
995 else if (S_ISLNK(mode)) c = 'l';
996 else if (S_ISFIFO(mode)) c = 'p';
997 else if (S_ISSOCK(mode)) c = 's';
1002 // basename() can modify its argument or return a pointer to a constant string
1003 // This just gives after the last '/' or the whole stirng if no /
1004 char *getbasename(char *name)
1006 char *s = strrchr(name, '/');
1013 // Execute a callback for each PID that matches a process name from a list.
1014 void names_to_pid(char **names, int (*callback)(pid_t pid, char *name))
1017 struct dirent *entry;
1019 if (!(dp = opendir("/proc"))) perror_exit("no /proc");
1021 while ((entry = readdir(dp))) {
1022 unsigned u = atoi(entry->d_name);
1023 char *cmd = 0, *comm, **cur;
1028 // Comm is original name of executable (argv[0] could be #! interpreter)
1029 // but it's limited to 15 characters
1030 sprintf(libbuf, "/proc/%u/comm", u);
1031 len = sizeof(libbuf);
1032 if (!(comm = readfileat(AT_FDCWD, libbuf, libbuf, &len)) || !len)
1034 if (libbuf[len-1] == '\n') libbuf[--len] = 0;
1036 for (cur = names; *cur; cur++) {
1037 struct stat st1, st2;
1038 char *bb = basename(*cur);
1041 // fast path: only matching a filename (no path) that fits in comm
1042 if (strncmp(comm, bb, 15)) continue;
1044 if (bb==*cur && len<16) goto match;
1046 // If we have a path to existing file only match if same inode
1047 if (bb!=*cur && !stat(*cur, &st1)) {
1050 sprintf(buf, "/proc/%u/exe", u);
1051 if (stat(buf, &st1)) continue;
1052 if (st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino) continue;
1056 // Nope, gotta read command line to confirm
1058 sprintf(cmd = libbuf+16, "/proc/%u/cmdline", u);
1059 len = sizeof(libbuf)-17;
1060 if (!(cmd = readfileat(AT_FDCWD, cmd, cmd, &len))) continue;
1061 // readfile only guarnatees one null terminator and we need two
1062 // (yes the kernel should do this for us, don't care)
1065 if (!strcmp(bb, basename(cmd))) goto match;
1066 if (bb!=*cur && !strcmp(bb, basename(cmd+strlen(cmd)+1))) goto match;
1069 if (callback(u, *cur)) break;
1075 // display first few digits of number with power of two units
1076 int human_readable(char *buf, unsigned long long num, int style)
1078 unsigned long long snap = 0;
1079 int len, unit, divisor = (style&HR_1000) ? 1000 : 1024;
1081 // Divide rounding up until we have 3 or fewer digits. Since the part we
1082 // print is decimal, the test is 999 even when we divide by 1024.
1083 // We can't run out of units because 2<<64 is 18 exabytes.
1084 // test 5675 is 5.5k not 5.6k.
1085 for (unit = 0; num > 999; unit++) num = ((snap = num)+(divisor/2))/divisor;
1086 len = sprintf(buf, "%llu", num);
1087 if (unit && len == 1) {
1088 // Redo rounding for 1.2M case, this works with and without HR_1000.
1090 snap -= num*divisor;
1091 snap = ((snap*100)+50)/divisor;
1093 len = sprintf(buf, "%llu.%llu", num, snap);
1095 if (style & HR_SPACE) buf[len++] = ' ';
1097 unit = " kMGTPE"[unit];
1099 if (!(style&HR_1000)) unit = toupper(unit);
1101 } else if (style & HR_B) buf[len++] = 'B';
1107 // The qsort man page says you can use alphasort, the posix committee
1108 // disagreed, and doubled down: http://austingroupbugs.net/view.php?id=142
1109 // So just do our own. (The const is entirely to humor the stupid compiler.)
1110 int qstrcmp(const void *a, const void *b)
1112 return strcmp(*(char **)a, *(char **)b);
1115 // According to http://www.opengroup.org/onlinepubs/9629399/apdxa.htm
1116 // we should generate a uuid structure by reading a clock with 100 nanosecond
1117 // precision, normalizing it to the start of the gregorian calendar in 1582,
1118 // and looking up our eth0 mac address.
1120 // On the other hand, we have 128 bits to come up with a unique identifier, of
1121 // which 6 have a defined value. /dev/urandom it is.
1123 void create_uuid(char *uuid)
1125 // Read 128 random bits
1126 int fd = xopenro("/dev/urandom");
1127 xreadall(fd, uuid, 16);
1130 // Claim to be a DCE format UUID.
1131 uuid[6] = (uuid[6] & 0x0F) | 0x40;
1132 uuid[8] = (uuid[8] & 0x3F) | 0x80;
1134 // rfc2518 section 6.4.1 suggests if we're not using a macaddr, we should
1135 // set bit 1 of the node ID, which is the mac multicast bit. This means we
1136 // should never collide with anybody actually using a macaddr.
1140 char *show_uuid(char *uuid)
1145 for (i=0; i<16; i++) out+=sprintf(out, "-%02x"+!(0x550&(1<<i)), uuid[i]);
1151 // Returns pointer to letter at end, 0 if none. *start = initial %
1152 char *next_printf(char *s, char **start)
1155 if (*s != '%') continue;
1156 if (*++s == '%') continue;
1157 if (start) *start = s-1;
1158 while (0 <= stridx("0'#-+ ", *s)) s++;
1159 while (isdigit(*s)) s++;
1161 while (isdigit(*s)) s++;
1169 // Posix inexplicably hasn't got this, so find str in line.
1170 char *strnstr(char *line, char *str)
1172 long len = strlen(str);
1175 for (s = line; *s; s++) if (!strncasecmp(s, str, len)) break;
1180 int dev_minor(int dev)
1182 return ((dev&0xfff00000)>>12)|(dev&0xff);
1185 int dev_major(int dev)
1187 return (dev&0xfff00)>>8;
1190 int dev_makedev(int major, int minor)
1192 return (minor&0xff)|((major&0xfff)<<8)|((minor&0xfff00)<<12);
1195 // Return cached passwd entries.
1196 struct passwd *bufgetpwuid(uid_t uid)
1198 struct pwuidbuf_list {
1199 struct pwuidbuf_list *next;
1202 struct passwd *temp;
1203 static struct pwuidbuf_list *pwuidbuf;
1205 for (list = pwuidbuf; list; list = list->next)
1206 if (list->pw.pw_uid == uid) return &(list->pw);
1208 list = xmalloc(512);
1209 list->next = pwuidbuf;
1211 errno = getpwuid_r(uid, &list->pw, sizeof(*list)+(char *)list,
1212 512-sizeof(*list), &temp);
1223 // Return cached passwd entries.
1224 struct group *bufgetgrgid(gid_t gid)
1226 struct grgidbuf_list {
1227 struct grgidbuf_list *next;
1231 static struct grgidbuf_list *grgidbuf;
1233 for (list = grgidbuf; list; list = list->next)
1234 if (list->gr.gr_gid == gid) return &(list->gr);
1236 list = xmalloc(512);
1237 list->next = grgidbuf;
1239 errno = getgrgid_r(gid, &list->gr, sizeof(*list)+(char *)list,
1240 512-sizeof(*list), &temp);
1251 // Always null terminates, returns 0 for failure, len for success
1252 int readlinkat0(int dirfd, char *path, char *buf, int len)
1256 len = readlinkat(dirfd, path, buf, len-1);
1257 if (len<1) return 0;
1263 int readlink0(char *path, char *buf, int len)
1265 return readlinkat0(AT_FDCWD, path, buf, len);
1268 // Do regex matching handling embedded NUL bytes in string (hence extra len
1269 // argument). Note that neither the pattern nor the match can currently include
1270 // NUL bytes (even with wildcards) and string must be null terminated at
1271 // string[len]. But this can find a match after the first NUL.
1272 int regexec0(regex_t *preg, char *string, long len, int nmatch,
1273 regmatch_t pmatch[], int eflags)
1281 while (len && !*s) {
1285 while (s[ll] && ll<len) ll++;
1287 rc = regexec(preg, s, nmatch, pmatch, eflags);
1289 for (rc = 0; rc<nmatch && pmatch[rc].rm_so!=-1; rc++) {
1290 pmatch[rc].rm_so += s-string;
1291 pmatch[rc].rm_eo += s-string;
1296 if (ll==len) return rc;
1303 // Return user name or string representation of number, returned buffer
1304 // lasts until next call.
1305 char *getusername(uid_t uid)
1307 struct passwd *pw = bufgetpwuid(uid);
1308 static char unum[12];
1310 sprintf(unum, "%u", (unsigned)uid);
1311 return pw ? pw->pw_name : unum;
1314 // Return group name or string representation of number, returned buffer
1315 // lasts until next call.
1316 char *getgroupname(gid_t gid)
1318 struct group *gr = bufgetgrgid(gid);
1319 static char gnum[12];
1321 sprintf(gnum, "%u", (unsigned)gid);
1322 return gr ? gr->gr_name : gnum;
1325 // Iterate over lines in file, calling function. Function can write 0 to
1326 // the line pointer if they want to keep it, or 1 to terminate processing,
1327 // otherwise line is freed. Passed file descriptor is closed at the end.
1328 void do_lines(int fd, void (*call)(char **pline, long len))
1330 FILE *fp = fd ? xfdopen(fd, "r") : stdin;
1336 len = getline(&line, (void *)&len, fp);
1339 if (line == (void *)1) break;
1347 // Returns the number of bytes taken by the environment variables. For use
1348 // when calculating the maximum bytes of environment+argument data that can
1349 // be passed to exec for find(1) and xargs(1).
1350 long environ_bytes()
1352 long bytes = sizeof(char *);
1355 for (ev = environ; *ev; ev++)
1356 bytes += sizeof(char *) + strlen(*ev) + 1;