Mercurial > hg > toybox
annotate lib/xwrap.c @ 1702:8ce8c5365f8b draft 0.5.2
stat -f didn't work on 32 bit systems because type sizes wrong (fix from Elliott Hughes).
| author | Rob Landley <rob@landley.net> |
|---|---|
| date | Wed, 25 Feb 2015 00:45:50 -0600 |
| parents | ae981311e232 |
| children | 58d9f1b61f0a |
| rev | line source |
|---|---|
| 951 | 1 /* xwrap.c - wrappers around existing library functions. |
| 2 * | |
| 3 * Functions with the x prefix are wrappers that either succeed or kill the | |
| 4 * program with an error message, but never return failure. They usually have | |
| 5 * the same arguments and return value as the function they wrap. | |
| 6 * | |
| 7 * Copyright 2006 Rob Landley <rob@landley.net> | |
| 8 */ | |
| 9 | |
| 10 #include "toys.h" | |
| 11 | |
|
1599
cd97856ca52c
Implement xstrncat() and fix xstrndup().
Rob Landley <rob@landley.net>
parents:
1583
diff
changeset
|
12 // strcpy and strncat with size checking. Size is the total space in "dest", |
|
cd97856ca52c
Implement xstrncat() and fix xstrndup().
Rob Landley <rob@landley.net>
parents:
1583
diff
changeset
|
13 // including null terminator. Exit if there's not enough space for the string |
|
cd97856ca52c
Implement xstrncat() and fix xstrndup().
Rob Landley <rob@landley.net>
parents:
1583
diff
changeset
|
14 // (including space for the null terminator), because silently truncating is |
|
cd97856ca52c
Implement xstrncat() and fix xstrndup().
Rob Landley <rob@landley.net>
parents:
1583
diff
changeset
|
15 // still broken behavior. (And leaving the string unterminated is INSANE.) |
| 951 | 16 void xstrncpy(char *dest, char *src, size_t size) |
| 17 { | |
|
1105
1bca28705a87
Give xstrncpy() a more informative error message.
Rob Landley <rob@landley.net>
parents:
1053
diff
changeset
|
18 if (strlen(src)+1 > size) error_exit("'%s' > %ld bytes", src, (long)size); |
| 951 | 19 strcpy(dest, src); |
| 20 } | |
| 21 | |
|
1599
cd97856ca52c
Implement xstrncat() and fix xstrndup().
Rob Landley <rob@landley.net>
parents:
1583
diff
changeset
|
22 void xstrncat(char *dest, char *src, size_t size) |
|
cd97856ca52c
Implement xstrncat() and fix xstrndup().
Rob Landley <rob@landley.net>
parents:
1583
diff
changeset
|
23 { |
|
cd97856ca52c
Implement xstrncat() and fix xstrndup().
Rob Landley <rob@landley.net>
parents:
1583
diff
changeset
|
24 long len = strlen(src); |
|
cd97856ca52c
Implement xstrncat() and fix xstrndup().
Rob Landley <rob@landley.net>
parents:
1583
diff
changeset
|
25 |
|
cd97856ca52c
Implement xstrncat() and fix xstrndup().
Rob Landley <rob@landley.net>
parents:
1583
diff
changeset
|
26 if (len+strlen(dest)+1 > size) |
|
cd97856ca52c
Implement xstrncat() and fix xstrndup().
Rob Landley <rob@landley.net>
parents:
1583
diff
changeset
|
27 error_exit("'%s%s' > %ld bytes", src, (long)size); |
|
cd97856ca52c
Implement xstrncat() and fix xstrndup().
Rob Landley <rob@landley.net>
parents:
1583
diff
changeset
|
28 strcpy(dest+len, src); |
|
cd97856ca52c
Implement xstrncat() and fix xstrndup().
Rob Landley <rob@landley.net>
parents:
1583
diff
changeset
|
29 } |
|
cd97856ca52c
Implement xstrncat() and fix xstrndup().
Rob Landley <rob@landley.net>
parents:
1583
diff
changeset
|
30 |
| 951 | 31 void xexit(void) |
| 32 { | |
|
1644
492bd41f8b9a
Move fflush() checking to xexit() and have exit paths in main() call that.
Rob Landley <rob@landley.net>
parents:
1600
diff
changeset
|
33 if (fflush(NULL) || ferror(stdout)) |
|
492bd41f8b9a
Move fflush() checking to xexit() and have exit paths in main() call that.
Rob Landley <rob@landley.net>
parents:
1600
diff
changeset
|
34 if (!toys.exitval) perror_msg("write"); |
| 951 | 35 if (toys.rebound) longjmp(*toys.rebound, 1); |
| 36 else exit(toys.exitval); | |
| 37 } | |
| 38 | |
| 39 // Die unless we can allocate memory. | |
| 40 void *xmalloc(size_t size) | |
| 41 { | |
| 42 void *ret = malloc(size); | |
| 43 if (!ret) error_exit("xmalloc"); | |
| 44 | |
| 45 return ret; | |
| 46 } | |
| 47 | |
| 48 // Die unless we can allocate prezeroed memory. | |
| 49 void *xzalloc(size_t size) | |
| 50 { | |
| 51 void *ret = xmalloc(size); | |
| 52 memset(ret, 0, size); | |
| 53 return ret; | |
| 54 } | |
| 55 | |
| 56 // Die unless we can change the size of an existing allocation, possibly | |
| 57 // moving it. (Notice different arguments from libc function.) | |
| 58 void *xrealloc(void *ptr, size_t size) | |
| 59 { | |
| 60 ptr = realloc(ptr, size); | |
| 61 if (!ptr) error_exit("xrealloc"); | |
| 62 | |
| 63 return ptr; | |
| 64 } | |
| 65 | |
| 66 // Die unless we can allocate a copy of this many bytes of string. | |
| 67 char *xstrndup(char *s, size_t n) | |
| 68 { | |
|
1599
cd97856ca52c
Implement xstrncat() and fix xstrndup().
Rob Landley <rob@landley.net>
parents:
1583
diff
changeset
|
69 char *ret = strndup(s, ++n); |
|
cd97856ca52c
Implement xstrncat() and fix xstrndup().
Rob Landley <rob@landley.net>
parents:
1583
diff
changeset
|
70 |
|
cd97856ca52c
Implement xstrncat() and fix xstrndup().
Rob Landley <rob@landley.net>
parents:
1583
diff
changeset
|
71 if (!ret) error_exit("xstrndup"); |
|
cd97856ca52c
Implement xstrncat() and fix xstrndup().
Rob Landley <rob@landley.net>
parents:
1583
diff
changeset
|
72 ret[--n] = 0; |
| 951 | 73 |
| 74 return ret; | |
| 75 } | |
| 76 | |
| 77 // Die unless we can allocate a copy of this string. | |
| 78 char *xstrdup(char *s) | |
| 79 { | |
| 80 return xstrndup(s, strlen(s)); | |
| 81 } | |
| 82 | |
| 83 // Die unless we can allocate enough space to sprintf() into. | |
|
1183
0752b2d58909
Rename xmsprintf() to just xmprintf().
Rob Landley <rob@landley.net>
parents:
1170
diff
changeset
|
84 char *xmprintf(char *format, ...) |
| 951 | 85 { |
| 86 va_list va, va2; | |
| 87 int len; | |
| 88 char *ret; | |
| 89 | |
| 90 va_start(va, format); | |
| 91 va_copy(va2, va); | |
| 92 | |
| 93 // How long is it? | |
| 94 len = vsnprintf(0, 0, format, va); | |
| 95 len++; | |
| 96 va_end(va); | |
| 97 | |
| 98 // Allocate and do the sprintf() | |
| 99 ret = xmalloc(len); | |
| 100 vsnprintf(ret, len, format, va2); | |
| 101 va_end(va2); | |
| 102 | |
| 103 return ret; | |
| 104 } | |
| 105 | |
| 106 void xprintf(char *format, ...) | |
| 107 { | |
| 108 va_list va; | |
| 109 va_start(va, format); | |
| 110 | |
| 111 vprintf(format, va); | |
|
1529
e127aa575ff2
More static analysis fixes from Ashwini Sharma.
Rob Landley <rob@landley.net>
parents:
1528
diff
changeset
|
112 va_end(va); |
|
1318
955169e818d0
Isaac Dunham suggested xprintf() should call fflush() instead of ferror(), and posix-2008 doesn't say if fflush() covers ferror() (or can return success when the stream's error state is set), so call both.
Rob Landley <rob@landley.net>
parents:
1235
diff
changeset
|
113 if (fflush(stdout) || ferror(stdout)) perror_exit("write"); |
| 951 | 114 } |
| 115 | |
| 116 void xputs(char *s) | |
| 117 { | |
|
1318
955169e818d0
Isaac Dunham suggested xprintf() should call fflush() instead of ferror(), and posix-2008 doesn't say if fflush() covers ferror() (or can return success when the stream's error state is set), so call both.
Rob Landley <rob@landley.net>
parents:
1235
diff
changeset
|
118 if (EOF == puts(s) || fflush(stdout) || ferror(stdout)) perror_exit("write"); |
| 951 | 119 } |
| 120 | |
| 121 void xputc(char c) | |
| 122 { | |
|
1318
955169e818d0
Isaac Dunham suggested xprintf() should call fflush() instead of ferror(), and posix-2008 doesn't say if fflush() covers ferror() (or can return success when the stream's error state is set), so call both.
Rob Landley <rob@landley.net>
parents:
1235
diff
changeset
|
123 if (EOF == fputc(c, stdout) || fflush(stdout) || ferror(stdout)) |
|
955169e818d0
Isaac Dunham suggested xprintf() should call fflush() instead of ferror(), and posix-2008 doesn't say if fflush() covers ferror() (or can return success when the stream's error state is set), so call both.
Rob Landley <rob@landley.net>
parents:
1235
diff
changeset
|
124 perror_exit("write"); |
| 951 | 125 } |
| 126 | |
| 127 void xflush(void) | |
| 128 { | |
|
1318
955169e818d0
Isaac Dunham suggested xprintf() should call fflush() instead of ferror(), and posix-2008 doesn't say if fflush() covers ferror() (or can return success when the stream's error state is set), so call both.
Rob Landley <rob@landley.net>
parents:
1235
diff
changeset
|
129 if (fflush(stdout) || ferror(stdout)) perror_exit("write");; |
| 951 | 130 } |
| 131 | |
| 132 // Die unless we can exec argv[] (or run builtin command). Note that anything | |
| 133 // with a path isn't a builtin, so /bin/sh won't match the builtin sh. | |
| 134 void xexec(char **argv) | |
| 135 { | |
|
1528
ec07449e8e4a
Add TOYBOX_NORECURSE so xexec() won't make internal function calls.
Rob Landley <rob@landley.net>
parents:
1473
diff
changeset
|
136 if (CFG_TOYBOX && !CFG_TOYBOX_NORECURSE) toy_exec(argv); |
| 951 | 137 execvp(argv[0], argv); |
| 138 | |
| 139 perror_exit("exec %s", argv[0]); | |
| 140 } | |
| 141 | |
|
1334
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
142 // Spawn child process, capturing stdin/stdout. |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
143 // argv[]: command to exec. If null, child returns to original program. |
|
1472
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
144 // pipes[2]: stdin, stdout of new process. If -1 will not have pipe allocated. |
|
1334
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
145 // return: pid of child process |
|
1472
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
146 pid_t xpopen_both(char **argv, int *pipes) |
|
1334
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
147 { |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
148 int cestnepasun[4], pid; |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
149 |
|
1472
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
150 // Make the pipes? Not this won't set either pipe to 0 because if fds are |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
151 // allocated in order and if fd0 was free it would go to cestnepasun[0] |
|
1334
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
152 if (pipes) { |
|
1472
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
153 for (pid = 0; pid < 2; pid++) { |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
154 if (pipes[pid] == -1) continue; |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
155 if (pipe(cestnepasun+(2*pid))) perror_exit("pipe"); |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
156 pipes[pid] = cestnepasun[pid+1]; |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
157 } |
|
1334
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
158 } |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
159 |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
160 // Child process |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
161 if (!(pid = xfork())) { |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
162 // Dance of the stdin/stdout redirection. |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
163 if (pipes) { |
|
1472
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
164 // if we had no stdin/out, pipe handles could overlap, so test for it |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
165 // and free up potentially overlapping pipe handles before reuse |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
166 if (pipes[1] != -1) close(cestnepasun[2]); |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
167 if (pipes[0] != -1) { |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
168 close(cestnepasun[1]); |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
169 if (cestnepasun[0]) { |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
170 dup2(cestnepasun[0], 0); |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
171 close(cestnepasun[0]); |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
172 } |
|
1334
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
173 } |
|
1472
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
174 if (pipes[1] != -1) { |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
175 dup2(cestnepasun[3], 1); |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
176 dup2(cestnepasun[3], 2); |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
177 if (cestnepasun[3] > 2 || !cestnepasun[3]) close(cestnepasun[3]); |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
178 } |
|
1334
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
179 } |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
180 if (argv) { |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
181 if (CFG_TOYBOX) toy_exec(argv); |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
182 execvp(argv[0], argv); |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
183 _exit(127); |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
184 } |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
185 return 0; |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
186 |
|
1472
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
187 } |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
188 |
|
1334
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
189 // Parent process |
|
1472
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
190 if (pipes) { |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
191 if (pipes[0] != -1) close(cestnepasun[0]); |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
192 if (pipes[1] != -1) close(cestnepasun[3]); |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
193 } |
|
1334
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
194 |
|
1472
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
195 return pid; |
|
1334
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
196 } |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
197 |
|
1472
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
198 int xpclose_both(pid_t pid, int *pipes) |
|
1334
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
199 { |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
200 int rc = 127; |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
201 |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
202 if (pipes) { |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
203 close(pipes[0]); |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
204 close(pipes[1]); |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
205 } |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
206 waitpid(pid, &rc, 0); |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
207 |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
208 return WIFEXITED(rc) ? WEXITSTATUS(rc) : WTERMSIG(rc) + 127; |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
209 } |
|
9fd2bcedbeb5
mount: start on option parsing, implement loopback and bind mount autodetection.
Rob Landley <rob@landley.net>
parents:
1327
diff
changeset
|
210 |
|
1472
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
211 // Wrapper to xpopen with a pipe for just one of stdin/stdout |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
212 pid_t xpopen(char **argv, int *pipe, int stdout) |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
213 { |
|
1473
bff076394df5
Second attempt at one way xpopen().
Rob Landley <rob@landley.net>
parents:
1472
diff
changeset
|
214 int pipes[2], pid; |
|
1472
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
215 |
|
1473
bff076394df5
Second attempt at one way xpopen().
Rob Landley <rob@landley.net>
parents:
1472
diff
changeset
|
216 pipes[!stdout] = -1; |
|
bff076394df5
Second attempt at one way xpopen().
Rob Landley <rob@landley.net>
parents:
1472
diff
changeset
|
217 pipes[!!stdout] = 0; |
|
bff076394df5
Second attempt at one way xpopen().
Rob Landley <rob@landley.net>
parents:
1472
diff
changeset
|
218 pid = xpopen_both(argv, pipes); |
|
bff076394df5
Second attempt at one way xpopen().
Rob Landley <rob@landley.net>
parents:
1472
diff
changeset
|
219 *pipe = pid ? pipes[!!stdout] : -1; |
|
1472
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
220 |
|
1473
bff076394df5
Second attempt at one way xpopen().
Rob Landley <rob@landley.net>
parents:
1472
diff
changeset
|
221 return pid; |
|
1472
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
222 } |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
223 |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
224 int xpclose(pid_t pid, int pipe) |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
225 { |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
226 close(pipe); |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
227 |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
228 return xpclose_both(pid, 0); |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
229 } |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
230 |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
231 // Call xpopen and wait for it to finish, keeping existing stdin/stdout. |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
232 int xrun(char **argv) |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
233 { |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
234 return xpclose_both(xpopen_both(argv, 0), 0); |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
235 } |
|
2f9bc9495144
Split xpopen() into xpopen_both(), xpopen(), and xrun() depending on whether we want to redirect both, one, or neither of stdin/stdout.
Rob Landley <rob@landley.net>
parents:
1420
diff
changeset
|
236 |
| 951 | 237 void xaccess(char *path, int flags) |
| 238 { | |
| 239 if (access(path, flags)) perror_exit("Can't access '%s'", path); | |
| 240 } | |
| 241 | |
| 242 // Die unless we can delete a file. (File must exist to be deleted.) | |
| 243 void xunlink(char *path) | |
| 244 { | |
| 245 if (unlink(path)) perror_exit("unlink '%s'", path); | |
| 246 } | |
| 247 | |
| 248 // Die unless we can open/create a file, returning file descriptor. | |
| 249 int xcreate(char *path, int flags, int mode) | |
| 250 { | |
|
1403
411cf82cdf77
Default xcreate/xopen to O_CLOEXEC. (Pass O_CLOEXEC in the flags to switch it back off.)
Rob Landley <rob@landley.net>
parents:
1400
diff
changeset
|
251 int fd = open(path, flags^O_CLOEXEC, mode); |
| 951 | 252 if (fd == -1) perror_exit("%s", path); |
| 253 return fd; | |
| 254 } | |
| 255 | |
| 256 // Die unless we can open a file, returning file descriptor. | |
| 257 int xopen(char *path, int flags) | |
| 258 { | |
| 259 return xcreate(path, flags, 0); | |
| 260 } | |
| 261 | |
| 262 void xclose(int fd) | |
| 263 { | |
| 264 if (close(fd)) perror_exit("xclose"); | |
| 265 } | |
| 266 | |
| 267 int xdup(int fd) | |
| 268 { | |
| 269 if (fd != -1) { | |
| 270 fd = dup(fd); | |
| 271 if (fd == -1) perror_exit("xdup"); | |
| 272 } | |
| 273 return fd; | |
| 274 } | |
| 275 | |
|
991
252caf3d2b88
Forgot to check in xfdopen(). My bad.
Rob Landley <rob@landley.net>
parents:
956
diff
changeset
|
276 FILE *xfdopen(int fd, char *mode) |
|
252caf3d2b88
Forgot to check in xfdopen(). My bad.
Rob Landley <rob@landley.net>
parents:
956
diff
changeset
|
277 { |
|
252caf3d2b88
Forgot to check in xfdopen(). My bad.
Rob Landley <rob@landley.net>
parents:
956
diff
changeset
|
278 FILE *f = fdopen(fd, mode); |
|
252caf3d2b88
Forgot to check in xfdopen(). My bad.
Rob Landley <rob@landley.net>
parents:
956
diff
changeset
|
279 |
|
252caf3d2b88
Forgot to check in xfdopen(). My bad.
Rob Landley <rob@landley.net>
parents:
956
diff
changeset
|
280 if (!f) perror_exit("xfdopen"); |
|
252caf3d2b88
Forgot to check in xfdopen(). My bad.
Rob Landley <rob@landley.net>
parents:
956
diff
changeset
|
281 |
|
252caf3d2b88
Forgot to check in xfdopen(). My bad.
Rob Landley <rob@landley.net>
parents:
956
diff
changeset
|
282 return f; |
|
252caf3d2b88
Forgot to check in xfdopen(). My bad.
Rob Landley <rob@landley.net>
parents:
956
diff
changeset
|
283 } |
|
252caf3d2b88
Forgot to check in xfdopen(). My bad.
Rob Landley <rob@landley.net>
parents:
956
diff
changeset
|
284 |
| 951 | 285 // Die unless we can open/create a file, returning FILE *. |
| 286 FILE *xfopen(char *path, char *mode) | |
| 287 { | |
| 288 FILE *f = fopen(path, mode); | |
| 289 if (!f) perror_exit("No file %s", path); | |
| 290 return f; | |
| 291 } | |
| 292 | |
| 293 // Die if there's an error other than EOF. | |
| 294 size_t xread(int fd, void *buf, size_t len) | |
| 295 { | |
| 296 ssize_t ret = read(fd, buf, len); | |
| 297 if (ret < 0) perror_exit("xread"); | |
| 298 | |
| 299 return ret; | |
| 300 } | |
| 301 | |
| 302 void xreadall(int fd, void *buf, size_t len) | |
| 303 { | |
| 304 if (len != readall(fd, buf, len)) perror_exit("xreadall"); | |
| 305 } | |
| 306 | |
| 307 // There's no xwriteall(), just xwrite(). When we read, there may or may not | |
| 308 // be more data waiting. When we write, there is data and it had better go | |
| 309 // somewhere. | |
| 310 | |
| 311 void xwrite(int fd, void *buf, size_t len) | |
| 312 { | |
| 313 if (len != writeall(fd, buf, len)) perror_exit("xwrite"); | |
| 314 } | |
| 315 | |
| 316 // Die if lseek fails, probably due to being called on a pipe. | |
| 317 | |
| 318 off_t xlseek(int fd, off_t offset, int whence) | |
| 319 { | |
| 320 offset = lseek(fd, offset, whence); | |
| 321 if (offset<0) perror_exit("lseek"); | |
| 322 | |
| 323 return offset; | |
| 324 } | |
| 325 | |
| 326 char *xgetcwd(void) | |
| 327 { | |
| 328 char *buf = getcwd(NULL, 0); | |
| 329 if (!buf) perror_exit("xgetcwd"); | |
| 330 | |
| 331 return buf; | |
| 332 } | |
| 333 | |
| 334 void xstat(char *path, struct stat *st) | |
| 335 { | |
| 336 if(stat(path, st)) perror_exit("Can't stat %s", path); | |
| 337 } | |
| 338 | |
| 339 // Cannonicalize path, even to file with one or more missing components at end. | |
| 340 // if exact, require last path component to exist | |
| 1666 | 341 char *xabspath(char *path, int exact) |
| 951 | 342 { |
| 343 struct string_list *todo, *done = 0; | |
| 344 int try = 9999, dirfd = open("/", 0);; | |
| 345 char buf[4096], *ret; | |
| 346 | |
| 347 // If this isn't an absolute path, start with cwd. | |
| 348 if (*path != '/') { | |
| 349 char *temp = xgetcwd(); | |
| 350 | |
| 351 splitpath(path, splitpath(temp, &todo)); | |
| 352 free(temp); | |
| 353 } else splitpath(path, &todo); | |
| 354 | |
| 355 // Iterate through path components | |
| 356 while (todo) { | |
| 357 struct string_list *new = llist_pop(&todo), **tail; | |
| 358 ssize_t len; | |
| 359 | |
| 360 if (!try--) { | |
| 361 errno = ELOOP; | |
| 362 goto error; | |
| 363 } | |
| 364 | |
| 365 // Removable path componenents. | |
| 366 if (!strcmp(new->str, ".") || !strcmp(new->str, "..")) { | |
| 367 int x = new->str[1]; | |
| 368 | |
| 369 free(new); | |
| 370 if (x) { | |
| 371 if (done) free(llist_pop(&done)); | |
| 372 len = 0; | |
| 373 } else continue; | |
| 374 | |
| 375 // Is this a symlink? | |
| 376 } else len=readlinkat(dirfd, new->str, buf, 4096); | |
| 377 | |
| 378 if (len>4095) goto error; | |
| 379 if (len<1) { | |
| 380 int fd; | |
| 381 char *s = ".."; | |
| 382 | |
| 383 // For .. just move dirfd | |
| 384 if (len) { | |
| 385 // Not a symlink: add to linked list, move dirfd, fail if error | |
| 386 if ((exact || todo) && errno != EINVAL) goto error; | |
| 387 new->next = done; | |
| 388 done = new; | |
| 389 if (errno == EINVAL && !todo) break; | |
| 390 s = new->str; | |
| 391 } | |
| 392 fd = openat(dirfd, s, 0); | |
| 393 if (fd == -1 && (exact || todo || errno != ENOENT)) goto error; | |
| 394 close(dirfd); | |
| 395 dirfd = fd; | |
| 396 continue; | |
| 397 } | |
| 398 | |
| 399 // If this symlink is to an absolute path, discard existing resolved path | |
| 400 buf[len] = 0; | |
| 401 if (*buf == '/') { | |
| 402 llist_traverse(done, free); | |
| 403 done=0; | |
| 404 close(dirfd); | |
| 405 dirfd = open("/", 0); | |
| 406 } | |
| 407 free(new); | |
| 408 | |
| 409 // prepend components of new path. Note symlink to "/" will leave new NULL | |
| 410 tail = splitpath(buf, &new); | |
| 411 | |
| 412 // symlink to "/" will return null and leave tail alone | |
| 413 if (new) { | |
| 414 *tail = todo; | |
| 415 todo = new; | |
| 416 } | |
| 417 } | |
| 418 close(dirfd); | |
| 419 | |
| 420 // At this point done has the path, in reverse order. Reverse list while | |
| 421 // calculating buffer length. | |
| 422 | |
| 423 try = 2; | |
| 424 while (done) { | |
| 425 struct string_list *temp = llist_pop(&done);; | |
| 426 | |
| 427 if (todo) try++; | |
| 428 try += strlen(temp->str); | |
| 429 temp->next = todo; | |
| 430 todo = temp; | |
| 431 } | |
| 432 | |
| 433 // Assemble return buffer | |
| 434 | |
| 435 ret = xmalloc(try); | |
| 436 *ret = '/'; | |
| 437 ret [try = 1] = 0; | |
| 438 while (todo) { | |
| 439 if (try>1) ret[try++] = '/'; | |
| 440 try = stpcpy(ret+try, todo->str) - ret; | |
| 441 free(llist_pop(&todo)); | |
| 442 } | |
| 443 | |
| 444 return ret; | |
| 445 | |
| 446 error: | |
| 447 close(dirfd); | |
| 448 llist_traverse(todo, free); | |
| 449 llist_traverse(done, free); | |
| 450 | |
| 451 return NULL; | |
| 452 } | |
| 453 | |
| 454 void xchdir(char *path) | |
| 455 { | |
| 456 if (chdir(path)) error_exit("chdir '%s'", path); | |
| 457 } | |
| 458 | |
|
1156
faf7117c4489
Fix some issues raised (albeit indirectly) by Isaac Dunham.
Rob Landley <rob@landley.net>
parents:
1130
diff
changeset
|
459 void xchroot(char *path) |
|
faf7117c4489
Fix some issues raised (albeit indirectly) by Isaac Dunham.
Rob Landley <rob@landley.net>
parents:
1130
diff
changeset
|
460 { |
|
faf7117c4489
Fix some issues raised (albeit indirectly) by Isaac Dunham.
Rob Landley <rob@landley.net>
parents:
1130
diff
changeset
|
461 if (chroot(path)) error_exit("chroot '%s'", path); |
|
faf7117c4489
Fix some issues raised (albeit indirectly) by Isaac Dunham.
Rob Landley <rob@landley.net>
parents:
1130
diff
changeset
|
462 xchdir("/"); |
|
faf7117c4489
Fix some issues raised (albeit indirectly) by Isaac Dunham.
Rob Landley <rob@landley.net>
parents:
1130
diff
changeset
|
463 } |
|
faf7117c4489
Fix some issues raised (albeit indirectly) by Isaac Dunham.
Rob Landley <rob@landley.net>
parents:
1130
diff
changeset
|
464 |
|
1129
c644f85444d0
Move xgetpwuid() and xgetgrgid() into xwrap.c
Rob Landley <rob@landley.net>
parents:
1105
diff
changeset
|
465 struct passwd *xgetpwuid(uid_t uid) |
|
c644f85444d0
Move xgetpwuid() and xgetgrgid() into xwrap.c
Rob Landley <rob@landley.net>
parents:
1105
diff
changeset
|
466 { |
|
c644f85444d0
Move xgetpwuid() and xgetgrgid() into xwrap.c
Rob Landley <rob@landley.net>
parents:
1105
diff
changeset
|
467 struct passwd *pwd = getpwuid(uid); |
|
1130
6df194c6de88
Add xgetpwnam() to lib/xwrap.c.
Rob Landley <rob@landley.net>
parents:
1129
diff
changeset
|
468 if (!pwd) error_exit("bad uid %ld", (long)uid); |
|
1129
c644f85444d0
Move xgetpwuid() and xgetgrgid() into xwrap.c
Rob Landley <rob@landley.net>
parents:
1105
diff
changeset
|
469 return pwd; |
|
c644f85444d0
Move xgetpwuid() and xgetgrgid() into xwrap.c
Rob Landley <rob@landley.net>
parents:
1105
diff
changeset
|
470 } |
|
c644f85444d0
Move xgetpwuid() and xgetgrgid() into xwrap.c
Rob Landley <rob@landley.net>
parents:
1105
diff
changeset
|
471 |
|
c644f85444d0
Move xgetpwuid() and xgetgrgid() into xwrap.c
Rob Landley <rob@landley.net>
parents:
1105
diff
changeset
|
472 struct group *xgetgrgid(gid_t gid) |
|
c644f85444d0
Move xgetpwuid() and xgetgrgid() into xwrap.c
Rob Landley <rob@landley.net>
parents:
1105
diff
changeset
|
473 { |
|
c644f85444d0
Move xgetpwuid() and xgetgrgid() into xwrap.c
Rob Landley <rob@landley.net>
parents:
1105
diff
changeset
|
474 struct group *group = getgrgid(gid); |
|
1400
31cb9ba1815c
Improve gid/uid error messages.
Rob Landley <rob@landley.net>
parents:
1334
diff
changeset
|
475 |
|
31cb9ba1815c
Improve gid/uid error messages.
Rob Landley <rob@landley.net>
parents:
1334
diff
changeset
|
476 if (!group) perror_exit("gid %ld", (long)gid); |
|
1129
c644f85444d0
Move xgetpwuid() and xgetgrgid() into xwrap.c
Rob Landley <rob@landley.net>
parents:
1105
diff
changeset
|
477 return group; |
|
c644f85444d0
Move xgetpwuid() and xgetgrgid() into xwrap.c
Rob Landley <rob@landley.net>
parents:
1105
diff
changeset
|
478 } |
|
c644f85444d0
Move xgetpwuid() and xgetgrgid() into xwrap.c
Rob Landley <rob@landley.net>
parents:
1105
diff
changeset
|
479 |
|
1130
6df194c6de88
Add xgetpwnam() to lib/xwrap.c.
Rob Landley <rob@landley.net>
parents:
1129
diff
changeset
|
480 struct passwd *xgetpwnam(char *name) |
|
6df194c6de88
Add xgetpwnam() to lib/xwrap.c.
Rob Landley <rob@landley.net>
parents:
1129
diff
changeset
|
481 { |
|
6df194c6de88
Add xgetpwnam() to lib/xwrap.c.
Rob Landley <rob@landley.net>
parents:
1129
diff
changeset
|
482 struct passwd *up = getpwnam(name); |
|
1400
31cb9ba1815c
Improve gid/uid error messages.
Rob Landley <rob@landley.net>
parents:
1334
diff
changeset
|
483 |
|
31cb9ba1815c
Improve gid/uid error messages.
Rob Landley <rob@landley.net>
parents:
1334
diff
changeset
|
484 if (!up) perror_exit("user '%s'", name); |
|
1130
6df194c6de88
Add xgetpwnam() to lib/xwrap.c.
Rob Landley <rob@landley.net>
parents:
1129
diff
changeset
|
485 return up; |
|
6df194c6de88
Add xgetpwnam() to lib/xwrap.c.
Rob Landley <rob@landley.net>
parents:
1129
diff
changeset
|
486 } |
|
6df194c6de88
Add xgetpwnam() to lib/xwrap.c.
Rob Landley <rob@landley.net>
parents:
1129
diff
changeset
|
487 |
|
1420
9d760c092c41
Implement exec -user, -group, and -newer. Enable find in defconfig.
Rob Landley <rob@landley.net>
parents:
1408
diff
changeset
|
488 struct group *xgetgrnam(char *name) |
|
9d760c092c41
Implement exec -user, -group, and -newer. Enable find in defconfig.
Rob Landley <rob@landley.net>
parents:
1408
diff
changeset
|
489 { |
|
9d760c092c41
Implement exec -user, -group, and -newer. Enable find in defconfig.
Rob Landley <rob@landley.net>
parents:
1408
diff
changeset
|
490 struct group *gr = getgrnam(name); |
|
9d760c092c41
Implement exec -user, -group, and -newer. Enable find in defconfig.
Rob Landley <rob@landley.net>
parents:
1408
diff
changeset
|
491 |
|
9d760c092c41
Implement exec -user, -group, and -newer. Enable find in defconfig.
Rob Landley <rob@landley.net>
parents:
1408
diff
changeset
|
492 if (!gr) perror_exit("group '%s'", name); |
|
9d760c092c41
Implement exec -user, -group, and -newer. Enable find in defconfig.
Rob Landley <rob@landley.net>
parents:
1408
diff
changeset
|
493 return gr; |
|
9d760c092c41
Implement exec -user, -group, and -newer. Enable find in defconfig.
Rob Landley <rob@landley.net>
parents:
1408
diff
changeset
|
494 } |
|
9d760c092c41
Implement exec -user, -group, and -newer. Enable find in defconfig.
Rob Landley <rob@landley.net>
parents:
1408
diff
changeset
|
495 |
|
1156
faf7117c4489
Fix some issues raised (albeit indirectly) by Isaac Dunham.
Rob Landley <rob@landley.net>
parents:
1130
diff
changeset
|
496 // setuid() can fail (for example, too many processes belonging to that user), |
|
faf7117c4489
Fix some issues raised (albeit indirectly) by Isaac Dunham.
Rob Landley <rob@landley.net>
parents:
1130
diff
changeset
|
497 // which opens a security hole if the process continues as the original user. |
|
faf7117c4489
Fix some issues raised (albeit indirectly) by Isaac Dunham.
Rob Landley <rob@landley.net>
parents:
1130
diff
changeset
|
498 |
|
faf7117c4489
Fix some issues raised (albeit indirectly) by Isaac Dunham.
Rob Landley <rob@landley.net>
parents:
1130
diff
changeset
|
499 void xsetuser(struct passwd *pwd) |
|
faf7117c4489
Fix some issues raised (albeit indirectly) by Isaac Dunham.
Rob Landley <rob@landley.net>
parents:
1130
diff
changeset
|
500 { |
|
faf7117c4489
Fix some issues raised (albeit indirectly) by Isaac Dunham.
Rob Landley <rob@landley.net>
parents:
1130
diff
changeset
|
501 if (initgroups(pwd->pw_name, pwd->pw_gid) || setgid(pwd->pw_uid) |
|
faf7117c4489
Fix some issues raised (albeit indirectly) by Isaac Dunham.
Rob Landley <rob@landley.net>
parents:
1130
diff
changeset
|
502 || setuid(pwd->pw_uid)) perror_exit("xsetuser '%s'", pwd->pw_name); |
|
faf7117c4489
Fix some issues raised (albeit indirectly) by Isaac Dunham.
Rob Landley <rob@landley.net>
parents:
1130
diff
changeset
|
503 } |
|
faf7117c4489
Fix some issues raised (albeit indirectly) by Isaac Dunham.
Rob Landley <rob@landley.net>
parents:
1130
diff
changeset
|
504 |
| 951 | 505 // This can return null (meaning file not found). It just won't return null |
| 506 // for memory allocation reasons. | |
| 507 char *xreadlink(char *name) | |
| 508 { | |
| 509 int len, size = 0; | |
| 510 char *buf = 0; | |
| 511 | |
| 512 // Grow by 64 byte chunks until it's big enough. | |
| 513 for(;;) { | |
| 514 size +=64; | |
| 515 buf = xrealloc(buf, size); | |
| 516 len = readlink(name, buf, size); | |
| 517 | |
| 518 if (len<0) { | |
| 519 free(buf); | |
| 520 return 0; | |
| 521 } | |
| 522 if (len<size) { | |
| 523 buf[len]=0; | |
| 524 return buf; | |
| 525 } | |
| 526 } | |
| 527 } | |
| 528 | |
|
1170
8afe1fde9314
Pass through all the readfile() arguments from xreadfile().
Rob Landley <rob@landley.net>
parents:
1156
diff
changeset
|
529 char *xreadfile(char *name, char *buf, off_t len) |
| 951 | 530 { |
|
1170
8afe1fde9314
Pass through all the readfile() arguments from xreadfile().
Rob Landley <rob@landley.net>
parents:
1156
diff
changeset
|
531 if (!(buf = readfile(name, buf, len))) perror_exit("Bad '%s'", name); |
|
8afe1fde9314
Pass through all the readfile() arguments from xreadfile().
Rob Landley <rob@landley.net>
parents:
1156
diff
changeset
|
532 |
| 951 | 533 return buf; |
| 534 } | |
| 535 | |
| 536 int xioctl(int fd, int request, void *data) | |
| 537 { | |
| 538 int rc; | |
| 539 | |
| 540 errno = 0; | |
| 541 rc = ioctl(fd, request, data); | |
| 542 if (rc == -1 && errno) perror_exit("ioctl %x", request); | |
| 543 | |
| 544 return rc; | |
| 545 } | |
| 546 | |
| 547 // Open a /var/run/NAME.pid file, dying if we can't write it or if it currently | |
| 548 // exists and is this executable. | |
| 549 void xpidfile(char *name) | |
| 550 { | |
| 551 char pidfile[256], spid[32]; | |
| 552 int i, fd; | |
| 553 pid_t pid; | |
| 554 | |
| 555 sprintf(pidfile, "/var/run/%s.pid", name); | |
| 556 // Try three times to open the sucker. | |
| 557 for (i=0; i<3; i++) { | |
| 1028 | 558 fd = open(pidfile, O_CREAT|O_EXCL|O_WRONLY, 0644); |
| 951 | 559 if (fd != -1) break; |
| 560 | |
| 561 // If it already existed, read it. Loop for race condition. | |
| 562 fd = open(pidfile, O_RDONLY); | |
| 563 if (fd == -1) continue; | |
| 564 | |
| 565 // Is the old program still there? | |
| 566 spid[xread(fd, spid, sizeof(spid)-1)] = 0; | |
| 567 close(fd); | |
| 568 pid = atoi(spid); | |
|
1053
501fd74c028e
Fix for xpidfile spotted by Felix Janda.
Rob Landley <rob@landley.net>
parents:
1043
diff
changeset
|
569 if (pid < 1 || (kill(pid, 0) && errno == ESRCH)) unlink(pidfile); |
| 951 | 570 |
| 571 // An else with more sanity checking might be nice here. | |
| 572 } | |
| 573 | |
| 574 if (i == 3) error_exit("xpidfile %s", name); | |
| 575 | |
| 576 xwrite(fd, spid, sprintf(spid, "%ld\n", (long)getpid())); | |
| 577 close(fd); | |
| 578 } | |
| 579 | |
| 580 // Copy the rest of in to out and close both files. | |
| 581 | |
| 582 void xsendfile(int in, int out) | |
| 583 { | |
| 584 long len; | |
| 585 | |
| 586 if (in<0) return; | |
| 587 for (;;) { | |
| 1583 | 588 len = xread(in, libbuf, sizeof(libbuf)); |
| 951 | 589 if (len<1) break; |
| 1583 | 590 xwrite(out, libbuf, len); |
| 951 | 591 } |
| 592 } | |
|
952
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
593 |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
594 // parse fractional seconds with optional s/m/h/d suffix |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
595 long xparsetime(char *arg, long units, long *fraction) |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
596 { |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
597 double d; |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
598 long l; |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
599 |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
600 if (CFG_TOYBOX_FLOAT) d = strtod(arg, &arg); |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
601 else l = strtoul(arg, &arg, 10); |
| 1666 | 602 |
|
952
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
603 // Parse suffix |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
604 if (*arg) { |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
605 int ismhd[]={1,60,3600,86400}, i = stridx("smhd", *arg); |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
606 |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
607 if (i == -1) error_exit("Unknown suffix '%c'", *arg); |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
608 if (CFG_TOYBOX_FLOAT) d *= ismhd[i]; |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
609 else l *= ismhd[i]; |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
610 } |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
611 |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
612 if (CFG_TOYBOX_FLOAT) { |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
613 l = (long)d; |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
614 if (fraction) *fraction = units*(d-l); |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
615 } else if (fraction) *fraction = 0; |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
616 |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
617 return l; |
|
ce0519f6457c
Add timeout, factoring out common code from sleep.
Rob Landley <rob@landley.net>
parents:
951
diff
changeset
|
618 } |
|
1235
63db77909fc8
Group headers by standard (POSIX or LSB) or function (internationalization, networking). Move headers standards ignore (but which have been there >15 years) to lib/portability.h. Fold xregcomp into lib since it's posix.
Rob Landley <rob@landley.net>
parents:
1219
diff
changeset
|
619 |
|
63db77909fc8
Group headers by standard (POSIX or LSB) or function (internationalization, networking). Move headers standards ignore (but which have been there >15 years) to lib/portability.h. Fold xregcomp into lib since it's posix.
Rob Landley <rob@landley.net>
parents:
1219
diff
changeset
|
620 // Compile a regular expression into a regex_t |
|
63db77909fc8
Group headers by standard (POSIX or LSB) or function (internationalization, networking). Move headers standards ignore (but which have been there >15 years) to lib/portability.h. Fold xregcomp into lib since it's posix.
Rob Landley <rob@landley.net>
parents:
1219
diff
changeset
|
621 void xregcomp(regex_t *preg, char *regex, int cflags) |
|
63db77909fc8
Group headers by standard (POSIX or LSB) or function (internationalization, networking). Move headers standards ignore (but which have been there >15 years) to lib/portability.h. Fold xregcomp into lib since it's posix.
Rob Landley <rob@landley.net>
parents:
1219
diff
changeset
|
622 { |
|
63db77909fc8
Group headers by standard (POSIX or LSB) or function (internationalization, networking). Move headers standards ignore (but which have been there >15 years) to lib/portability.h. Fold xregcomp into lib since it's posix.
Rob Landley <rob@landley.net>
parents:
1219
diff
changeset
|
623 int rc = regcomp(preg, regex, cflags); |
|
63db77909fc8
Group headers by standard (POSIX or LSB) or function (internationalization, networking). Move headers standards ignore (but which have been there >15 years) to lib/portability.h. Fold xregcomp into lib since it's posix.
Rob Landley <rob@landley.net>
parents:
1219
diff
changeset
|
624 |
|
63db77909fc8
Group headers by standard (POSIX or LSB) or function (internationalization, networking). Move headers standards ignore (but which have been there >15 years) to lib/portability.h. Fold xregcomp into lib since it's posix.
Rob Landley <rob@landley.net>
parents:
1219
diff
changeset
|
625 if (rc) { |
|
63db77909fc8
Group headers by standard (POSIX or LSB) or function (internationalization, networking). Move headers standards ignore (but which have been there >15 years) to lib/portability.h. Fold xregcomp into lib since it's posix.
Rob Landley <rob@landley.net>
parents:
1219
diff
changeset
|
626 regerror(rc, preg, libbuf, sizeof(libbuf)); |
|
63db77909fc8
Group headers by standard (POSIX or LSB) or function (internationalization, networking). Move headers standards ignore (but which have been there >15 years) to lib/portability.h. Fold xregcomp into lib since it's posix.
Rob Landley <rob@landley.net>
parents:
1219
diff
changeset
|
627 error_exit("xregcomp: %s", libbuf); |
|
63db77909fc8
Group headers by standard (POSIX or LSB) or function (internationalization, networking). Move headers standards ignore (but which have been there >15 years) to lib/portability.h. Fold xregcomp into lib since it's posix.
Rob Landley <rob@landley.net>
parents:
1219
diff
changeset
|
628 } |
|
63db77909fc8
Group headers by standard (POSIX or LSB) or function (internationalization, networking). Move headers standards ignore (but which have been there >15 years) to lib/portability.h. Fold xregcomp into lib since it's posix.
Rob Landley <rob@landley.net>
parents:
1219
diff
changeset
|
629 } |
|
1688
ae981311e232
Cleanup/refactoring pass on hwclock.
Rob Landley <rob@landley.net>
parents:
1678
diff
changeset
|
630 |
|
ae981311e232
Cleanup/refactoring pass on hwclock.
Rob Landley <rob@landley.net>
parents:
1678
diff
changeset
|
631 char *xtzset(char *new) |
|
ae981311e232
Cleanup/refactoring pass on hwclock.
Rob Landley <rob@landley.net>
parents:
1678
diff
changeset
|
632 { |
|
ae981311e232
Cleanup/refactoring pass on hwclock.
Rob Landley <rob@landley.net>
parents:
1678
diff
changeset
|
633 char *tz = getenv("TZ"); |
|
ae981311e232
Cleanup/refactoring pass on hwclock.
Rob Landley <rob@landley.net>
parents:
1678
diff
changeset
|
634 |
|
ae981311e232
Cleanup/refactoring pass on hwclock.
Rob Landley <rob@landley.net>
parents:
1678
diff
changeset
|
635 if (tz) tz = xstrdup(tz); |
|
ae981311e232
Cleanup/refactoring pass on hwclock.
Rob Landley <rob@landley.net>
parents:
1678
diff
changeset
|
636 if (setenv("TZ", new, 1)) perror_exit("setenv"); |
|
ae981311e232
Cleanup/refactoring pass on hwclock.
Rob Landley <rob@landley.net>
parents:
1678
diff
changeset
|
637 tzset(); |
|
ae981311e232
Cleanup/refactoring pass on hwclock.
Rob Landley <rob@landley.net>
parents:
1678
diff
changeset
|
638 |
|
ae981311e232
Cleanup/refactoring pass on hwclock.
Rob Landley <rob@landley.net>
parents:
1678
diff
changeset
|
639 return tz; |
|
ae981311e232
Cleanup/refactoring pass on hwclock.
Rob Landley <rob@landley.net>
parents:
1678
diff
changeset
|
640 } |