1
2
3
4
5
6#define SYSLOG_NAMES
7#include "toys.h"
8
9void verror_msg(char *msg, int err, va_list va)
10{
11 char *s = ": %s";
12
13 fprintf(stderr, "%s: ", toys.which->name);
14 if (msg) vfprintf(stderr, msg, va);
15 else s+=2;
16 if (err>0) fprintf(stderr, s, strerror(err));
17 if (err<0 && CFG_TOYBOX_HELP)
18 fprintf(stderr, " (see \"%s --help\")", toys.which->name);
19 if (msg || err) putc('\n', stderr);
20 if (!toys.exitval) toys.exitval++;
21}
22
23
24
25void error_msg(char *msg, ...)
26{
27 va_list va;
28
29 va_start(va, msg);
30 verror_msg(msg, 0, va);
31 va_end(va);
32}
33
34void perror_msg(char *msg, ...)
35{
36 va_list va;
37
38 va_start(va, msg);
39 verror_msg(msg, errno, va);
40 va_end(va);
41}
42
43
44void error_exit(char *msg, ...)
45{
46 va_list va;
47
48 va_start(va, msg);
49 verror_msg(msg, 0, va);
50 va_end(va);
51
52 xexit();
53}
54
55
56void perror_exit(char *msg, ...)
57{
58
59 if (errno != EPIPE) {
60 va_list va;
61
62 va_start(va, msg);
63 verror_msg(msg, errno, va);
64 va_end(va);
65 }
66
67 xexit();
68}
69
70
71void help_exit(char *msg, ...)
72{
73 va_list va;
74
75 if (!msg) show_help(stdout);
76 else {
77 va_start(va, msg);
78 verror_msg(msg, -1, va);
79 va_end(va);
80 }
81
82 xexit();
83}
84
85
86
87
88
89void error_msg_raw(char *msg)
90{
91 error_msg("%s", msg);
92}
93
94void perror_msg_raw(char *msg)
95{
96 perror_msg("%s", msg);
97}
98
99void error_exit_raw(char *msg)
100{
101 error_exit("%s", msg);
102}
103
104void perror_exit_raw(char *msg)
105{
106 perror_exit("%s", msg);
107}
108
109
110ssize_t readall(int fd, void *buf, size_t len)
111{
112 size_t count = 0;
113
114 while (count<len) {
115 int i = read(fd, (char *)buf+count, len-count);
116 if (!i) break;
117 if (i<0) return i;
118 count += i;
119 }
120
121 return count;
122}
123
124
125ssize_t writeall(int fd, void *buf, size_t len)
126{
127 size_t count = 0;
128
129 while (count<len) {
130 int i = write(fd, count+(char *)buf, len-count);
131 if (i<1) return i;
132 count += i;
133 }
134
135 return count;
136}
137
138
139
140off_t lskip(int fd, off_t offset)
141{
142 off_t cur = lseek(fd, 0, SEEK_CUR);
143
144 if (cur != -1) {
145 off_t end = lseek(fd, 0, SEEK_END) - cur;
146
147 if (end > 0 && end < offset) return offset - end;
148 end = offset+cur;
149 if (end == lseek(fd, end, SEEK_SET)) return 0;
150 perror_exit("lseek");
151 }
152
153 while (offset>0) {
154 int try = offset>sizeof(libbuf) ? sizeof(libbuf) : offset, or;
155
156 or = readall(fd, libbuf, try);
157 if (or < 0) perror_exit("lskip to %lld", (long long)offset);
158 else offset -= or;
159 if (or < try) break;
160 }
161
162 return offset;
163}
164
165
166
167
168
169int mkpathat(int atfd, char *dir, mode_t lastmode, int flags)
170{
171 struct stat buf;
172 char *s;
173
174
175
176
177
178
179 if (!fstatat(atfd, dir, &buf, 0) && !S_ISDIR(buf.st_mode)) {
180 errno = EEXIST;
181 return 1;
182 }
183
184 for (s = dir; ;s++) {
185 char save = 0;
186 mode_t mode = (0777&~toys.old_umask)|0300;
187
188
189 if (*s == '/' && (flags&2) && s != dir) {
190 save = *s;
191 *s = 0;
192 } else if (*s) continue;
193
194
195 if (!save) {
196 if (flags&1) mode = lastmode;
197 else break;
198 }
199
200 if (mkdirat(atfd, dir, mode)) {
201 if (!(flags&2) || errno != EEXIST) return 1;
202 } else if (flags&4)
203 fprintf(stderr, "%s: created directory '%s'\n", toys.which->name, dir);
204
205 if (!(*s = save)) break;
206 }
207
208 return 0;
209}
210
211
212int mkpath(char *dir)
213{
214 return mkpathat(AT_FDCWD, dir, 0, MKPATHAT_MAKE);
215}
216
217
218
219struct string_list **splitpath(char *path, struct string_list **list)
220{
221 char *new = path;
222
223 *list = 0;
224 do {
225 int len;
226
227 if (*path && *path != '/') continue;
228 len = path-new;
229 if (len > 0) {
230 *list = xmalloc(sizeof(struct string_list) + len + 1);
231 (*list)->next = 0;
232 memcpy((*list)->str, new, len);
233 (*list)->str[len] = 0;
234 list = &(*list)->next;
235 }
236 new = path+1;
237 } while (*path++);
238
239 return list;
240}
241
242
243
244
245
246struct string_list *find_in_path(char *path, char *filename)
247{
248 struct string_list *rlist = NULL, **prlist=&rlist;
249 char *cwd;
250
251 if (!path) return 0;
252
253 cwd = xgetcwd();
254 for (;;) {
255 char *res, *next = strchr(path, ':');
256 int len = next ? next-path : strlen(path);
257 struct string_list *rnext;
258 struct stat st;
259
260 rnext = xmalloc(sizeof(void *) + strlen(filename)
261 + (len ? len : strlen(cwd)) + 2);
262 if (!len) sprintf(rnext->str, "%s/%s", cwd, filename);
263 else {
264 memcpy(res = rnext->str, path, len);
265 res += len;
266 *(res++) = '/';
267 strcpy(res, filename);
268 }
269
270
271 if (!stat(rnext->str, &st) && S_ISREG(st.st_mode)) {
272 *prlist = rnext;
273 rnext->next = NULL;
274 prlist = &(rnext->next);
275 } else free(rnext);
276
277 if (!next) break;
278 path += len;
279 path++;
280 }
281 free(cwd);
282
283 return rlist;
284}
285
286long long estrtol(char *str, char **end, int base)
287{
288 errno = 0;
289
290 return strtoll(str, end, base);
291}
292
293long long xstrtol(char *str, char **end, int base)
294{
295 long long l = estrtol(str, end, base);
296
297 if (errno) perror_exit_raw(str);
298
299 return l;
300}
301
302
303
304long long atolx(char *numstr)
305{
306 char *c = numstr, *suffixes="cwbkmgtpe", *end;
307 long long val;
308
309 val = xstrtol(numstr, &c, 0);
310 if (c != numstr && *c && (end = strchr(suffixes, tolower(*c)))) {
311 int shift = end-suffixes-2;
312 ++c;
313 if (shift==-1) val *= 2;
314 else if (!shift) val *= 512;
315 else if (shift>0) {
316 if (*c && tolower(*c++)=='d') while (shift--) val *= 1000;
317 else val *= 1LL<<(shift*10);
318 }
319 }
320 while (isspace(*c)) c++;
321 if (c==numstr || *c) error_exit("not integer: %s", numstr);
322
323 return val;
324}
325
326long long atolx_range(char *numstr, long long low, long long high)
327{
328 long long val = atolx(numstr);
329
330 if (val < low) error_exit("%lld < %lld", val, low);
331 if (val > high) error_exit("%lld > %lld", val, high);
332
333 return val;
334}
335
336int stridx(char *haystack, char needle)
337{
338 char *off;
339
340 if (!needle) return -1;
341 off = strchr(haystack, needle);
342 if (!off) return -1;
343
344 return off-haystack;
345}
346
347
348int utf8towc(wchar_t *wc, char *str, unsigned len)
349{
350 unsigned result, mask, first;
351 char *s, c;
352
353
354 if (len && *str<128) return !!(*wc = *str);
355
356 result = first = *(s = str++);
357 if (result<0xc2 || result>0xf4) return -1;
358 for (mask = 6; (first&0xc0)==0xc0; mask += 5, first <<= 1) {
359 if (!--len) return -2;
360 if (((c = *(str++))&0xc0) != 0x80) return -1;
361 result = (result<<6)|(c&0x3f);
362 }
363 result &= (1<<mask)-1;
364 c = str-s;
365
366
367 if (result<(unsigned []){0x80,0x800,0x10000}[c-2]) return -1;
368
369
370 if (result>0x10ffff || (result>=0xd800 && result<=0xdfff)) return -1;
371 *wc = result;
372
373 return str-s;
374}
375
376char *strlower(char *s)
377{
378 char *try, *new;
379
380 if (!CFG_TOYBOX_I18N) {
381 try = new = xstrdup(s);
382 for (; *s; s++) *(new++) = tolower(*s);
383 } else {
384
385 try = new = xmalloc(strlen(s)*2+1);
386
387 while (*s) {
388 wchar_t c;
389 int len = utf8towc(&c, s, MB_CUR_MAX);
390
391 if (len < 1) *(new++) = *(s++);
392 else {
393 s += len;
394
395 c = towlower(c);
396
397
398
399
400 len = wcrtomb(new, c, 0);
401 if (len < 1) error_exit("bad utf8 %x", (int)c);
402 new += len;
403 }
404 }
405 *new = 0;
406 }
407
408 return try;
409}
410
411
412char *strafter(char *haystack, char *needle)
413{
414 char *s = strstr(haystack, needle);
415
416 return s ? s+strlen(needle) : s;
417}
418
419
420char *chomp(char *s)
421{
422 char *p = strrchr(s, '\n');
423
424 if (p && !p[1]) *p = 0;
425 return s;
426}
427
428int unescape(char c)
429{
430 char *from = "\\abefnrtv", *to = "\\\a\b\033\f\n\r\t\v";
431 int idx = stridx(from, c);
432
433 return (idx == -1) ? 0 : to[idx];
434}
435
436
437
438char *strend(char *str, char *suffix)
439{
440 long a = strlen(str), b = strlen(suffix);
441
442 if (a>b && !strcmp(str += a-b, suffix)) return str;
443
444 return 0;
445}
446
447
448int strstart(char **a, char *b)
449{
450 char *c = *a;
451
452 while (*b && *c == *b) b++, c++;
453 if (!*b) *a = c;
454
455 return !*b;
456}
457
458
459int strcasestart(char **a, char *b)
460{
461 int len = strlen(b), i = !strncasecmp(*a, b, len);
462
463 if (i) *a += len;
464
465 return i;
466}
467
468
469off_t fdlength(int fd)
470{
471 struct stat st;
472 off_t base = 0, range = 1, expand = 1, old;
473
474 if (!fstat(fd, &st) && S_ISREG(st.st_mode)) return st.st_size;
475
476
477
478
479
480
481
482
483
484
485
486
487 old = lseek(fd, 0, SEEK_CUR);
488 do {
489 char temp;
490 off_t pos = base + range / 2;
491
492 if (lseek(fd, pos, 0)>=0 && read(fd, &temp, 1)==1) {
493 off_t delta = (pos + 1) - base;
494
495 base += delta;
496 if (expand) range = (expand <<= 1) - base;
497 else range -= delta;
498 } else {
499 expand = 0;
500 range = pos - base;
501 }
502 } while (range > 0);
503
504 lseek(fd, old, SEEK_SET);
505
506 return base;
507}
508
509
510
511
512
513char *readfileat(int dirfd, char *name, char *ibuf, off_t *plen)
514{
515 off_t len, rlen;
516 int fd;
517 char *buf, *rbuf;
518
519
520 if (CFG_TOYBOX_DEBUG && (ibuf ? !*plen : *plen)) error_exit("bad readfileat");
521
522 if (-1 == (fd = openat(dirfd, name, O_RDONLY))) return 0;
523
524
525 if (!*plen) {
526 if ((len = fdlength(fd))>0) *plen = len;
527 else len = 4096;
528 } else len = *plen-1;
529
530 if (!ibuf) buf = xmalloc(len+1);
531 else buf = ibuf;
532
533 for (rbuf = buf;;) {
534 rlen = readall(fd, rbuf, len);
535 if (*plen || rlen<len) break;
536
537
538 rlen += rbuf-buf;
539 buf = xrealloc(buf, len = (rlen*3)/2);
540 rbuf = buf+rlen;
541 len -= rlen;
542 }
543 *plen = len = rlen+(rbuf-buf);
544 close(fd);
545
546 if (rlen<0) {
547 if (ibuf != buf) free(buf);
548 buf = 0;
549 } else buf[len] = 0;
550
551 return buf;
552}
553
554char *readfile(char *name, char *ibuf, off_t len)
555{
556 return readfileat(AT_FDCWD, name, ibuf, &len);
557}
558
559
560void msleep(long milliseconds)
561{
562 struct timespec ts;
563
564 ts.tv_sec = milliseconds/1000;
565 ts.tv_nsec = (milliseconds%1000)*1000000;
566 nanosleep(&ts, &ts);
567}
568
569
570void nanomove(struct timespec *ts, long long offset)
571{
572 long long nano = ts->tv_nsec + offset, secs = nano/1000000000;
573
574 ts->tv_sec += secs;
575 nano %= 1000000000;
576 if (nano<0) {
577 ts->tv_sec--;
578 nano += 1000000000;
579 }
580 ts->tv_nsec = nano;
581}
582
583
584long long nanodiff(struct timespec *old, struct timespec *new)
585{
586 return (new->tv_sec - old->tv_sec)*1000000000LL+(new->tv_nsec - old->tv_nsec);
587}
588
589
590int highest_bit(unsigned long l)
591{
592 int i;
593
594 for (i = 0; l; i++) l >>= 1;
595
596 return i-1;
597}
598
599
600int64_t peek_le(void *ptr, unsigned size)
601{
602 int64_t ret = 0;
603 char *c = ptr;
604 int i;
605
606 for (i=0; i<size; i++) ret |= ((int64_t)c[i])<<(i*8);
607 return ret;
608}
609
610int64_t peek_be(void *ptr, unsigned size)
611{
612 int64_t ret = 0;
613 char *c = ptr;
614 int i;
615
616 for (i=0; i<size; i++) ret = (ret<<8)|(c[i]&0xff);
617 return ret;
618}
619
620int64_t peek(void *ptr, unsigned size)
621{
622 return (IS_BIG_ENDIAN ? peek_be : peek_le)(ptr, size);
623}
624
625void poke_le(void *ptr, long long val, unsigned size)
626{
627 char *c = ptr;
628
629 while (size--) {
630 *c++ = val&255;
631 val >>= 8;
632 }
633}
634
635void poke_be(void *ptr, long long val, unsigned size)
636{
637 char *c = ptr + size;
638
639 while (size--) {
640 *--c = val&255;
641 val >>=8;
642 }
643}
644
645void poke(void *ptr, long long val, unsigned size)
646{
647 (IS_BIG_ENDIAN ? poke_be : poke_le)(ptr, val, size);
648}
649
650
651
652
653
654
655
656
657
658
659void loopfiles_rw(char **argv, int flags, int permissions,
660 void (*function)(int fd, char *name))
661{
662 int fd, failok = !(flags&WARN_ONLY);
663
664 flags &= ~WARN_ONLY;
665
666
667 if (!*argv) function((flags & O_ACCMODE) != O_RDONLY ? 1 : 0, "-");
668 else do {
669
670
671
672 if (!strcmp(*argv, "-")) fd = 0;
673 else if (0>(fd = notstdio(open(*argv, flags, permissions))) && !failok) {
674 perror_msg_raw(*argv);
675 continue;
676 }
677 function(fd, *argv);
678 if ((flags & O_CLOEXEC) && fd) close(fd);
679 } while (*++argv);
680}
681
682
683void loopfiles(char **argv, void (*function)(int fd, char *name))
684{
685 loopfiles_rw(argv, O_RDONLY|O_CLOEXEC|WARN_ONLY, 0, function);
686}
687
688
689static void (*do_lines_bridge)(char **pline, long len);
690static void loopfile_lines_bridge(int fd, char *name)
691{
692 do_lines(fd, '\n', do_lines_bridge);
693}
694
695void loopfiles_lines(char **argv, void (*function)(char **pline, long len))
696{
697 do_lines_bridge = function;
698
699 loopfiles_rw(argv, O_RDONLY|WARN_ONLY, 0, loopfile_lines_bridge);
700}
701
702
703char *get_line(int fd)
704{
705 char c, *buf = NULL;
706 long len = 0;
707
708 for (;;) {
709 if (1>read(fd, &c, 1)) break;
710 if (!(len & 63)) buf=xrealloc(buf, len+65);
711 if ((buf[len++]=c) == '\n') break;
712 }
713 if (buf) {
714 buf[len]=0;
715 if (buf[--len]=='\n') buf[len]=0;
716 }
717
718 return buf;
719}
720
721int wfchmodat(int fd, char *name, mode_t mode)
722{
723 int rc = fchmodat(fd, name, mode, 0);
724
725 if (rc) {
726 perror_msg("chmod '%s' to %04o", name, mode);
727 toys.exitval=1;
728 }
729 return rc;
730}
731
732static char *tempfile2zap;
733static void tempfile_handler(void)
734{
735 if (1 < (long)tempfile2zap) unlink(tempfile2zap);
736}
737
738
739int copy_tempfile(int fdin, char *name, char **tempname)
740{
741 struct stat statbuf;
742 int fd = xtempfile(name, tempname), ignored __attribute__((__unused__));
743
744
745 if (!tempfile2zap) sigatexit(tempfile_handler);
746 tempfile2zap = *tempname;
747
748
749 if (!fstat(fdin, &statbuf)) fchmod(fd, statbuf.st_mode);
750
751
752
753
754
755
756 ignored = fchown(fd, statbuf.st_uid, statbuf.st_gid);
757
758 return fd;
759}
760
761
762void delete_tempfile(int fdin, int fdout, char **tempname)
763{
764 close(fdin);
765 close(fdout);
766 if (*tempname) unlink(*tempname);
767 tempfile2zap = (char *)1;
768 free(*tempname);
769 *tempname = NULL;
770}
771
772
773void replace_tempfile(int fdin, int fdout, char **tempname)
774{
775 char *temp = xstrdup(*tempname);
776
777 temp[strlen(temp)-6]=0;
778 if (fdin != -1) {
779 xsendfile(fdin, fdout);
780 xclose(fdin);
781 }
782 xclose(fdout);
783 xrename(*tempname, temp);
784 tempfile2zap = (char *)1;
785 free(*tempname);
786 free(temp);
787 *tempname = NULL;
788}
789
790
791
792void crc_init(unsigned int *crc_table, int little_endian)
793{
794 unsigned int i;
795
796
797 for (i=0; i<256; i++) {
798 unsigned int j, c = little_endian ? i : i<<24;
799 for (j=8; j; j--)
800 if (little_endian) c = (c&1) ? (c>>1)^0xEDB88320 : c>>1;
801 else c=c&0x80000000 ? (c<<1)^0x04c11db7 : (c<<1);
802 crc_table[i] = c;
803 }
804}
805
806
807
808void base64_init(char *p)
809{
810 int i;
811
812 for (i = 'A'; i != ':'; i++) {
813 if (i == 'Z'+1) i = 'a';
814 if (i == 'z'+1) i = '0';
815 *(p++) = i;
816 }
817 *(p++) = '+';
818 *(p++) = '/';
819}
820
821int yesno(int def)
822{
823 return fyesno(stdin, def);
824}
825
826int fyesno(FILE *in, int def)
827{
828 char buf;
829
830 fprintf(stderr, " (%c/%c):", def ? 'Y' : 'y', def ? 'n' : 'N');
831 fflush(stderr);
832 while (fread(&buf, 1, 1, in)) {
833 int new;
834
835
836 if (isspace(buf)) break;
837 if (-1 != (new = stridx("ny", tolower(buf)))) def = new;
838 }
839
840 return def;
841}
842
843
844void generic_signal(int sig)
845{
846 if (toys.signalfd) {
847 char c = sig;
848
849 writeall(toys.signalfd, &c, 1);
850 }
851 toys.signal = sig;
852}
853
854void exit_signal(int sig)
855{
856 if (sig) toys.exitval = sig|128;
857 xexit();
858}
859
860
861
862
863void sigatexit(void *handler)
864{
865 xsignal_all_killers(handler ? exit_signal : SIG_DFL);
866
867 if (handler) {
868 struct arg_list *al = xmalloc(sizeof(struct arg_list));
869
870 al->next = toys.xexit;
871 al->arg = handler;
872 toys.xexit = al;
873 } else {
874 llist_traverse(toys.xexit, free);
875 toys.xexit = 0;
876 }
877}
878
879
880void list_signals()
881{
882 int i = 0, count = 0;
883 char *name;
884
885 for (; i<=NSIG; i++) {
886 if ((name = num_to_sig(i))) {
887 printf("%2d) SIG%-9s", i, name);
888 if (++count % 5 == 0) putchar('\n');
889 }
890 }
891 putchar('\n');
892}
893
894
895mode_t string_to_mode(char *modestr, mode_t mode)
896{
897 char *whos = "ogua", *hows = "=+-", *whats = "xwrstX", *whys = "ogu",
898 *s, *str = modestr;
899 mode_t extrabits = mode & ~(07777);
900
901
902 if (isdigit(*str)) {
903 mode = estrtol(str, &s, 8);
904 if (errno || *s || (mode & ~(07777))) goto barf;
905
906 return mode | extrabits;
907 }
908
909
910 for (;;) {
911 int i, j, dowho, dohow, dowhat, amask;
912
913 dowho = dohow = dowhat = amask = 0;
914
915
916 while (*str && (s = strchr(whos, *str))) {
917 dowho |= 1<<(s-whos);
918 str++;
919 }
920
921 if (!dowho) {
922 dowho = 8;
923 umask(amask=umask(0));
924 }
925 if (!*str || !(s = strchr(hows, *str))) goto barf;
926 dohow = *(str++);
927
928 if (!dohow) goto barf;
929 while (*str && (s = strchr(whats, *str))) {
930 dowhat |= 1<<(s-whats);
931 str++;
932 }
933
934
935 if ((dowhat&32) && (S_ISDIR(mode) || (mode&0111))) dowhat |= 1;
936
937
938 if (!dowhat && *str && (s = strchr(whys, *str))) {
939 dowhat = (mode>>(3*(s-whys)))&7;
940 str++;
941 }
942
943
944 if (*str && *(str++) != ',') goto barf;
945
946
947 for (i=0; i<4; i++) {
948 for (j=0; j<3; j++) {
949 mode_t bit = 0;
950 int where = 1<<((3*i)+j);
951
952 if (amask & where) continue;
953
954
955 if (i == 3) {
956
957 if (j) {
958 if ((dowhat & 8) && (dowho&(8|(1<<i)))) bit++;
959 } else if (dowhat & 16) bit++;
960 } else {
961 if (!(dowho&(8|(1<<i)))) continue;
962 if (dowhat&(1<<j)) bit++;
963 }
964
965
966
967 if (dohow == '=' || (bit && dohow == '-')) mode &= ~where;
968 if (bit && dohow != '-') mode |= where;
969 }
970 }
971
972 if (!*str) break;
973 }
974
975 return mode|extrabits;
976barf:
977 error_exit("bad mode '%s'", modestr);
978}
979
980
981void mode_to_string(mode_t mode, char *buf)
982{
983 char c, d;
984 int i, bit;
985
986 buf[10]=0;
987 for (i=0; i<9; i++) {
988 bit = mode & (1<<i);
989 c = i%3;
990 if (!c && (mode & (1<<((d=i/3)+9)))) {
991 c = "tss"[d];
992 if (!bit) c &= ~0x20;
993 } else c = bit ? "xwr"[c] : '-';
994 buf[9-i] = c;
995 }
996
997 if (S_ISDIR(mode)) c = 'd';
998 else if (S_ISBLK(mode)) c = 'b';
999 else if (S_ISCHR(mode)) c = 'c';
1000 else if (S_ISLNK(mode)) c = 'l';
1001 else if (S_ISFIFO(mode)) c = 'p';
1002 else if (S_ISSOCK(mode)) c = 's';
1003 else c = '-';
1004 *buf = c;
1005}
1006
1007
1008
1009char *getdirname(char *name)
1010{
1011 char *s = xstrdup(name), *ss = strrchr(s, '/');
1012
1013 while (ss && *ss && *ss == '/' && s != ss) *ss-- = 0;
1014
1015 return s;
1016}
1017
1018
1019
1020char *getbasename(char *name)
1021{
1022 char *s = strrchr(name, '/');
1023
1024 if (s) return s+1;
1025
1026 return name;
1027}
1028
1029
1030char *fileunderdir(char *file, char *dir)
1031{
1032 char *s1 = xabspath(dir, 1), *s2 = xabspath(file, -1), *ss = s2;
1033 int rc = s1 && s2 && strstart(&ss, s1) && (!s1[1] || s2[strlen(s1)] == '/');
1034
1035 free(s1);
1036 if (!rc) free(s2);
1037
1038 return rc ? s2 : 0;
1039}
1040
1041
1042void names_to_pid(char **names, int (*callback)(pid_t pid, char *name),
1043 int scripts)
1044{
1045 DIR *dp;
1046 struct dirent *entry;
1047
1048 if (!(dp = opendir("/proc"))) perror_exit("no /proc");
1049
1050 while ((entry = readdir(dp))) {
1051 unsigned u = atoi(entry->d_name);
1052 char *cmd = 0, *comm = 0, **cur;
1053 off_t len;
1054
1055 if (!u) continue;
1056
1057
1058
1059 if (scripts) {
1060 sprintf(libbuf, "/proc/%u/comm", u);
1061 len = sizeof(libbuf);
1062 if (!(comm = readfileat(AT_FDCWD, libbuf, libbuf, &len)) || !len)
1063 continue;
1064 if (libbuf[len-1] == '\n') libbuf[--len] = 0;
1065 }
1066
1067 for (cur = names; *cur; cur++) {
1068 struct stat st1, st2;
1069 char *bb = getbasename(*cur);
1070 off_t len = strlen(bb);
1071
1072
1073
1074
1075 if (scripts && len<=14 && bb==*cur && !strcmp(comm, bb)) goto match;
1076
1077
1078 if (bb!=*cur && !stat(*cur, &st1)) {
1079 char buf[32];
1080
1081 sprintf(buf, "/proc/%u/exe", u);
1082 if (stat(buf, &st2)) continue;
1083 if (st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino) continue;
1084 goto match;
1085 }
1086
1087
1088 if (!cmd) {
1089 sprintf(cmd = libbuf+16, "/proc/%u/cmdline", u);
1090 len = sizeof(libbuf)-17;
1091 if (!(cmd = readfileat(AT_FDCWD, cmd, cmd, &len))) continue;
1092
1093
1094 cmd[len] = 0;
1095 }
1096 if (!strcmp(bb, getbasename(cmd))) goto match;
1097 if (scripts && !strcmp(bb, getbasename(cmd+strlen(cmd)+1))) goto match;
1098 continue;
1099match:
1100 if (callback(u, *cur)) break;
1101 }
1102 }
1103 closedir(dp);
1104}
1105
1106
1107int human_readable_long(char *buf, unsigned long long num, int dgt, int style)
1108{
1109 unsigned long long snap = 0;
1110 int len, unit, divisor = (style&HR_1000) ? 1000 : 1024;
1111
1112
1113
1114
1115 for (unit = 0; snprintf(0, 0, "%llu", num)>dgt; unit++)
1116 num = ((snap = num)+(divisor/2))/divisor;
1117 len = sprintf(buf, "%llu", num);
1118 if (unit && len == 1) {
1119
1120 num = snap/divisor;
1121 snap -= num*divisor;
1122 snap = ((snap*100)+50)/divisor;
1123 snap /= 10;
1124 len = sprintf(buf, "%llu.%llu", num, snap);
1125 }
1126 if (style & HR_SPACE) buf[len++] = ' ';
1127 if (unit) {
1128 unit = " kMGTPE"[unit];
1129
1130 if (!(style&HR_1000)) unit = toupper(unit);
1131 buf[len++] = unit;
1132 } else if (style & HR_B) buf[len++] = 'B';
1133 buf[len] = 0;
1134
1135 return len;
1136}
1137
1138
1139int human_readable(char *buf, unsigned long long num, int style)
1140{
1141 return human_readable_long(buf, num, 3, style);
1142}
1143
1144
1145
1146
1147int qstrcmp(const void *a, const void *b)
1148{
1149 return strcmp(*(char **)a, *(char **)b);
1150}
1151
1152
1153
1154
1155void create_uuid(char *uuid)
1156{
1157
1158 xgetrandom(uuid, 16, 0);
1159
1160
1161
1162 uuid[6] = (uuid[6] & 0x0F) | 0x40;
1163
1164
1165 uuid[8] = (uuid[8] & 0x3F) | 0x80;
1166}
1167
1168char *show_uuid(char *uuid)
1169{
1170 char *out = libbuf;
1171 int i;
1172
1173 for (i=0; i<16; i++) out+=sprintf(out, "-%02x"+!(0x550&(1<<i)), uuid[i]);
1174 *out = 0;
1175
1176 return libbuf;
1177}
1178
1179
1180char *next_printf(char *s, char **start)
1181{
1182 for (; *s; s++) {
1183 if (*s != '%') continue;
1184 if (*++s == '%') continue;
1185 if (start) *start = s-1;
1186 while (0 <= stridx("0'#-+ ", *s)) s++;
1187 while (isdigit(*s)) s++;
1188 if (*s == '.') s++;
1189 while (isdigit(*s)) s++;
1190
1191 return s;
1192 }
1193
1194 return 0;
1195}
1196
1197int dev_minor(int dev)
1198{
1199 return ((dev&0xfff00000)>>12)|(dev&0xff);
1200}
1201
1202int dev_major(int dev)
1203{
1204 return (dev&0xfff00)>>8;
1205}
1206
1207int dev_makedev(int major, int minor)
1208{
1209 return (minor&0xff)|((major&0xfff)<<8)|((minor&0xfff00)<<12);
1210}
1211
1212
1213struct passwd *bufgetpwuid(uid_t uid)
1214{
1215 struct pwuidbuf_list {
1216 struct pwuidbuf_list *next;
1217 struct passwd pw;
1218 } *list = 0;
1219 struct passwd *temp;
1220 static struct pwuidbuf_list *pwuidbuf;
1221 unsigned size = 256;
1222
1223
1224 for (list = pwuidbuf; list; list = list->next)
1225 if (list->pw.pw_uid == uid) return &(list->pw);
1226
1227 for (;;) {
1228 list = xrealloc(list, size *= 2);
1229 errno = getpwuid_r(uid, &list->pw, sizeof(*list)+(char *)list,
1230 size-sizeof(*list), &temp);
1231 if (errno != ERANGE) break;
1232 }
1233
1234 if (!temp) {
1235 free(list);
1236
1237 return 0;
1238 }
1239 list->next = pwuidbuf;
1240 pwuidbuf = list;
1241
1242 return &list->pw;
1243}
1244
1245
1246struct group *bufgetgrgid(gid_t gid)
1247{
1248 struct grgidbuf_list {
1249 struct grgidbuf_list *next;
1250 struct group gr;
1251 } *list = 0;
1252 struct group *temp;
1253 static struct grgidbuf_list *grgidbuf;
1254 unsigned size = 256;
1255
1256 for (list = grgidbuf; list; list = list->next)
1257 if (list->gr.gr_gid == gid) return &(list->gr);
1258
1259 for (;;) {
1260 list = xrealloc(list, size *= 2);
1261 errno = getgrgid_r(gid, &list->gr, sizeof(*list)+(char *)list,
1262 size-sizeof(*list), &temp);
1263 if (errno != ERANGE) break;
1264 }
1265 if (!temp) {
1266 free(list);
1267
1268 return 0;
1269 }
1270 list->next = grgidbuf;
1271 grgidbuf = list;
1272
1273 return &list->gr;
1274}
1275
1276
1277int readlinkat0(int dirfd, char *path, char *buf, int len)
1278{
1279 if (!len) return 0;
1280
1281 len = readlinkat(dirfd, path, buf, len-1);
1282 if (len<0) len = 0;
1283 buf[len] = 0;
1284
1285 return len;
1286}
1287
1288int readlink0(char *path, char *buf, int len)
1289{
1290 return readlinkat0(AT_FDCWD, path, buf, len);
1291}
1292
1293
1294int regexec0(regex_t *preg, char *string, long len, int nmatch,
1295 regmatch_t *pmatch, int eflags)
1296{
1297 regmatch_t backup;
1298
1299 if (!nmatch) pmatch = &backup;
1300 pmatch->rm_so = 0;
1301 pmatch->rm_eo = len;
1302 return regexec(preg, string, nmatch, pmatch, eflags|REG_STARTEND);
1303}
1304
1305
1306
1307char *getusername(uid_t uid)
1308{
1309 struct passwd *pw = bufgetpwuid(uid);
1310 static char unum[12];
1311
1312 sprintf(unum, "%u", (unsigned)uid);
1313 return pw ? pw->pw_name : unum;
1314}
1315
1316
1317
1318char *getgroupname(gid_t gid)
1319{
1320 struct group *gr = bufgetgrgid(gid);
1321 static char gnum[12];
1322
1323 sprintf(gnum, "%u", (unsigned)gid);
1324 return gr ? gr->gr_name : gnum;
1325}
1326
1327
1328
1329
1330
1331void do_lines(int fd, char delim, void (*call)(char **pline, long len))
1332{
1333 FILE *fp = fd ? xfdopen(fd, "r") : stdin;
1334
1335 for (;;) {
1336 char *line = 0;
1337 ssize_t len;
1338
1339 len = getdelim(&line, (void *)&len, delim, fp);
1340 if (len > 0) {
1341 call(&line, len);
1342 if (line == (void *)1) break;
1343 free(line);
1344 } else break;
1345 }
1346 call(0, 0);
1347
1348 if (fd) fclose(fp);
1349}
1350
1351
1352long long millitime(void)
1353{
1354 struct timespec ts;
1355
1356 clock_gettime(CLOCK_MONOTONIC, &ts);
1357 return ts.tv_sec*1000+ts.tv_nsec/1000000;
1358}
1359
1360
1361char *format_iso_time(char *buf, size_t len, struct timespec *ts)
1362{
1363 char *s = buf;
1364
1365 s += strftime(s, len, "%F %T", localtime(&(ts->tv_sec)));
1366 s += sprintf(s, ".%09ld ", ts->tv_nsec);
1367 s += strftime(s, len-strlen(buf), "%z", localtime(&(ts->tv_sec)));
1368
1369 return buf;
1370}
1371
1372
1373
1374void loggit(int priority, char *format, ...)
1375{
1376 int i, facility = LOG_DAEMON;
1377 va_list va;
1378
1379 for (i = 0; i<3; i++) if (isatty(i)) facility = LOG_AUTH;
1380 openlog(toys.which->name, LOG_PID, facility);
1381 va_start(va, format);
1382 vsyslog(priority, format, va);
1383 va_end(va);
1384 closelog();
1385}
1386
1387
1388unsigned tar_cksum(void *data)
1389{
1390 unsigned i, cksum = 8*' ';
1391
1392 for (i = 0; i<500; i += (i==147) ? 9 : 1) cksum += ((char *)data)[i];
1393
1394 return cksum;
1395}
1396
1397
1398int is_tar_header(void *pkt)
1399{
1400 char *p = pkt;
1401 int i = 0;
1402
1403 if (p[257] && memcmp("ustar", p+257, 5)) return 0;
1404 if (p[148] != '0' && p[148] != ' ') return 0;
1405 sscanf(p+148, "%8o", &i);
1406
1407 return i && tar_cksum(pkt) == i;
1408}
1409