Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 1 | /* vi: set sw=4 ts=4: */ |
| 2 | /* |
| 3 | * Utility routines. |
| 4 | * |
Eric Andersen | c7bda1c | 2004-03-15 08:29:22 +0000 | [diff] [blame] | 5 | * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org> |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 6 | * Copyright (C) 2006 Rob Landley |
| 7 | * Copyright (C) 2006 Denis Vlasenko |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 8 | * |
Rob Landley | fbdf121 | 2006-09-20 22:06:01 +0000 | [diff] [blame] | 9 | * Licensed under GPL version 2, see file LICENSE in this tarball for details. |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 10 | */ |
| 11 | |
Rob Landley | 552b56d | 2006-05-04 21:22:27 +0000 | [diff] [blame] | 12 | #include "busybox.h" |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 13 | |
Rob Landley | 23b61be | 2006-08-04 20:20:03 +0000 | [diff] [blame] | 14 | /* All the functions starting with "x" call bb_error_msg_and_die() if they |
| 15 | * fail, so callers never need to check for errors. If it returned, it |
| 16 | * succeeded. */ |
| 17 | |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 18 | #ifndef DMALLOC |
Bernhard Reutner-Fischer | 73561cc | 2006-08-28 23:31:54 +0000 | [diff] [blame] | 19 | /* dmalloc provides variants of these that do abort() on failure. |
| 20 | * Since dmalloc's prototypes overwrite the impls here as they are |
| 21 | * included after these prototypes in libbb.h, all is well. |
| 22 | */ |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 23 | // Die if we can't allocate size bytes of memory. |
Rob Landley | dfba741 | 2006-03-06 20:47:33 +0000 | [diff] [blame] | 24 | void *xmalloc(size_t size) |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 25 | { |
| 26 | void *ptr = malloc(size); |
Matt Kraai | a99b194 | 2002-02-26 15:28:22 +0000 | [diff] [blame] | 27 | if (ptr == NULL && size != 0) |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 28 | bb_error_msg_and_die(bb_msg_memory_exhausted); |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 29 | return ptr; |
| 30 | } |
| 31 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 32 | // Die if we can't resize previously allocated memory. (This returns a pointer |
| 33 | // to the new memory, which may or may not be the same as the old memory. |
| 34 | // It'll copy the contents to a new chunk and free the old one if necessary.) |
Rob Landley | dfba741 | 2006-03-06 20:47:33 +0000 | [diff] [blame] | 35 | void *xrealloc(void *ptr, size_t size) |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 36 | { |
Matt Kraai | a99b194 | 2002-02-26 15:28:22 +0000 | [diff] [blame] | 37 | ptr = realloc(ptr, size); |
| 38 | if (ptr == NULL && size != 0) |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 39 | bb_error_msg_and_die(bb_msg_memory_exhausted); |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 40 | return ptr; |
| 41 | } |
Bernhard Reutner-Fischer | 73561cc | 2006-08-28 23:31:54 +0000 | [diff] [blame] | 42 | #endif /* DMALLOC */ |
| 43 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 44 | // Die if we can't allocate and zero size bytes of memory. |
Rob Landley | 80b8ff0 | 2006-05-19 20:36:49 +0000 | [diff] [blame] | 45 | void *xzalloc(size_t size) |
| 46 | { |
| 47 | void *ptr = xmalloc(size); |
| 48 | memset(ptr, 0, size); |
| 49 | return ptr; |
| 50 | } |
Rob Landley | 80b8ff0 | 2006-05-19 20:36:49 +0000 | [diff] [blame] | 51 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 52 | // Die if we can't copy a string to freshly allocated memory. |
Rob Landley | 23b61be | 2006-08-04 20:20:03 +0000 | [diff] [blame] | 53 | char * xstrdup(const char *s) |
Rob Landley | 31642d7 | 2006-03-14 21:45:38 +0000 | [diff] [blame] | 54 | { |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 55 | char *t; |
| 56 | |
| 57 | if (s == NULL) |
| 58 | return NULL; |
| 59 | |
| 60 | t = strdup (s); |
| 61 | |
| 62 | if (t == NULL) |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 63 | bb_error_msg_and_die(bb_msg_memory_exhausted); |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 64 | |
| 65 | return t; |
| 66 | } |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 67 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 68 | // Die if we can't allocate n+1 bytes (space for the null terminator) and copy |
| 69 | // the (possibly truncated to length n) string into it. |
Rob Landley | 23b61be | 2006-08-04 20:20:03 +0000 | [diff] [blame] | 70 | char * xstrndup(const char *s, int n) |
Rob Landley | 31642d7 | 2006-03-14 21:45:38 +0000 | [diff] [blame] | 71 | { |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 72 | char *t; |
| 73 | |
Rob Landley | 8bbdb87 | 2006-06-30 16:36:56 +0000 | [diff] [blame] | 74 | if (ENABLE_DEBUG && s == NULL) |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 75 | bb_error_msg_and_die("xstrndup bug"); |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 76 | |
| 77 | t = xmalloc(++n); |
Eric Andersen | c7bda1c | 2004-03-15 08:29:22 +0000 | [diff] [blame] | 78 | |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 79 | return safe_strncpy(t,s,n); |
| 80 | } |
| 81 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 82 | // Die if we can't open a file and return a FILE * to it. |
| 83 | // Notice we haven't got xfread(), This is for use with fscanf() and friends. |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 84 | FILE *xfopen(const char *path, const char *mode) |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 85 | { |
| 86 | FILE *fp; |
| 87 | if ((fp = fopen(path, mode)) == NULL) |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 88 | bb_perror_msg_and_die("%s", path); |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 89 | return fp; |
| 90 | } |
| 91 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 92 | // Die if we can't open an existing file and return an fd. |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 93 | int xopen(const char *pathname, int flags) |
Glenn L McGrath | 7ca04f3 | 2002-09-25 02:47:48 +0000 | [diff] [blame] | 94 | { |
Denis Vlasenko | d25a264 | 2006-09-05 09:36:19 +0000 | [diff] [blame] | 95 | if (ENABLE_DEBUG && (flags & O_CREAT)) |
Denis Vlasenko | 6d655be | 2006-09-06 19:02:46 +0000 | [diff] [blame] | 96 | bb_error_msg_and_die("xopen() with O_CREAT"); |
Rob Landley | 23b61be | 2006-08-04 20:20:03 +0000 | [diff] [blame] | 97 | |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 98 | return xopen3(pathname, flags, 0777); |
Bernhard Reutner-Fischer | c2cb0f3 | 2006-04-13 12:45:04 +0000 | [diff] [blame] | 99 | } |
Bernhard Reutner-Fischer | c2cb0f3 | 2006-04-13 12:45:04 +0000 | [diff] [blame] | 100 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 101 | // Die if we can't open a new file and return an fd. |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 102 | int xopen3(const char *pathname, int flags, int mode) |
Bernhard Reutner-Fischer | c2cb0f3 | 2006-04-13 12:45:04 +0000 | [diff] [blame] | 103 | { |
Glenn L McGrath | 7ca04f3 | 2002-09-25 02:47:48 +0000 | [diff] [blame] | 104 | int ret; |
Eric Andersen | c7bda1c | 2004-03-15 08:29:22 +0000 | [diff] [blame] | 105 | |
Bernhard Reutner-Fischer | c2cb0f3 | 2006-04-13 12:45:04 +0000 | [diff] [blame] | 106 | ret = open(pathname, flags, mode); |
| 107 | if (ret < 0) { |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 108 | bb_perror_msg_and_die("%s", pathname); |
Glenn L McGrath | 7ca04f3 | 2002-09-25 02:47:48 +0000 | [diff] [blame] | 109 | } |
| 110 | return ret; |
| 111 | } |
| 112 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 113 | // Die with an error message if we can't read the entire buffer. |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 114 | void xread(int fd, void *buf, size_t count) |
Glenn L McGrath | 7ca04f3 | 2002-09-25 02:47:48 +0000 | [diff] [blame] | 115 | { |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 116 | while (count) { |
Denis Vlasenko | 1db39b2 | 2006-10-11 20:59:02 +0000 | [diff] [blame^] | 117 | ssize_t size = safe_read(fd, buf, count); |
| 118 | if (size < 1) |
| 119 | bb_error_msg_and_die("short read"); |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 120 | count -= size; |
Manuel Novoa III | 948d490 | 2004-03-08 05:44:30 +0000 | [diff] [blame] | 121 | buf = ((char *) buf) + size; |
Glenn L McGrath | 7ca04f3 | 2002-09-25 02:47:48 +0000 | [diff] [blame] | 122 | } |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 123 | } |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 124 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 125 | // Die with an error message if we can't write the entire buffer. |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 126 | void xwrite(int fd, void *buf, size_t count) |
| 127 | { |
| 128 | while (count) { |
Denis Vlasenko | 1db39b2 | 2006-10-11 20:59:02 +0000 | [diff] [blame^] | 129 | ssize_t size = safe_write(fd, buf, count); |
| 130 | if (size < 1) |
| 131 | bb_error_msg_and_die("short write"); |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 132 | count -= size; |
| 133 | buf = ((char *) buf) + size; |
| 134 | } |
| 135 | } |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 136 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 137 | // Die with an error message if we can't lseek to the right spot. |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 138 | void xlseek(int fd, off_t offset, int whence) |
| 139 | { |
Rob Landley | 2c55fca | 2006-08-04 05:24:58 +0000 | [diff] [blame] | 140 | if (offset != lseek(fd, offset, whence)) bb_error_msg_and_die("lseek"); |
Glenn L McGrath | 7ca04f3 | 2002-09-25 02:47:48 +0000 | [diff] [blame] | 141 | } |
| 142 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 143 | // Die with an error message if we can't read one character. |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 144 | unsigned char xread_char(int fd) |
Glenn L McGrath | 7ca04f3 | 2002-09-25 02:47:48 +0000 | [diff] [blame] | 145 | { |
| 146 | char tmp; |
Eric Andersen | c7bda1c | 2004-03-15 08:29:22 +0000 | [diff] [blame] | 147 | |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 148 | xread(fd, &tmp, 1); |
Glenn L McGrath | 7ca04f3 | 2002-09-25 02:47:48 +0000 | [diff] [blame] | 149 | |
Denis Vlasenko | 1db39b2 | 2006-10-11 20:59:02 +0000 | [diff] [blame^] | 150 | return tmp; |
Glenn L McGrath | 7ca04f3 | 2002-09-25 02:47:48 +0000 | [diff] [blame] | 151 | } |
| 152 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 153 | // Die with supplied error message if this FILE * has ferror set. |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 154 | void xferror(FILE *fp, const char *fn) |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 155 | { |
| 156 | if (ferror(fp)) { |
| 157 | bb_error_msg_and_die("%s", fn); |
| 158 | } |
| 159 | } |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 160 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 161 | // Die with an error message if stdout has ferror set. |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 162 | void xferror_stdout(void) |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 163 | { |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 164 | xferror(stdout, bb_msg_standard_output); |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 165 | } |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 166 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 167 | // Die with an error message if we have trouble flushing stdout. |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 168 | void xfflush_stdout(void) |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 169 | { |
| 170 | if (fflush(stdout)) { |
| 171 | bb_perror_msg_and_die(bb_msg_standard_output); |
| 172 | } |
| 173 | } |
Rob Landley | 399d2b5 | 2006-05-25 23:02:40 +0000 | [diff] [blame] | 174 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 175 | // This does a fork/exec in one call, using vfork(). Return PID of new child, |
| 176 | // -1 for failure. Runs argv[0], searching path if that has no / in it. |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 177 | pid_t spawn(char **argv) |
Rob Landley | 399d2b5 | 2006-05-25 23:02:40 +0000 | [diff] [blame] | 178 | { |
| 179 | static int failed; |
| 180 | pid_t pid; |
Rob Landley | 519d7df | 2006-08-09 20:56:23 +0000 | [diff] [blame] | 181 | void *app = ENABLE_FEATURE_SH_STANDALONE_SHELL ? find_applet_by_name(argv[0]) : 0; |
Rob Landley | 399d2b5 | 2006-05-25 23:02:40 +0000 | [diff] [blame] | 182 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 183 | // Be nice to nommu machines. |
Rob Landley | 399d2b5 | 2006-05-25 23:02:40 +0000 | [diff] [blame] | 184 | failed = 0; |
| 185 | pid = vfork(); |
| 186 | if (pid < 0) return pid; |
| 187 | if (!pid) { |
Rob Landley | c7ddefc | 2006-06-14 01:24:33 +0000 | [diff] [blame] | 188 | execvp(app ? CONFIG_BUSYBOX_EXEC_PATH : *argv, argv); |
Rob Landley | 399d2b5 | 2006-05-25 23:02:40 +0000 | [diff] [blame] | 189 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 190 | // We're sharing a stack with blocked parent, let parent know we failed |
| 191 | // and then exit to unblock parent (but don't run atexit() stuff, which |
| 192 | // would screw up parent.) |
Rob Landley | 399d2b5 | 2006-05-25 23:02:40 +0000 | [diff] [blame] | 193 | |
| 194 | failed = -1; |
| 195 | _exit(0); |
| 196 | } |
| 197 | return failed ? failed : pid; |
| 198 | } |
Rob Landley | 399d2b5 | 2006-05-25 23:02:40 +0000 | [diff] [blame] | 199 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 200 | // Die with an error message if we can't spawn a child process. |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 201 | pid_t xspawn(char **argv) |
Rob Landley | 399d2b5 | 2006-05-25 23:02:40 +0000 | [diff] [blame] | 202 | { |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 203 | pid_t pid = spawn(argv); |
Rob Landley | 399d2b5 | 2006-05-25 23:02:40 +0000 | [diff] [blame] | 204 | if (pid < 0) bb_perror_msg_and_die("%s", *argv); |
| 205 | return pid; |
| 206 | } |
Rob Landley | c7ddefc | 2006-06-14 01:24:33 +0000 | [diff] [blame] | 207 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 208 | // Wait for the specified child PID to exit, returning child's error return. |
Rob Landley | c7ddefc | 2006-06-14 01:24:33 +0000 | [diff] [blame] | 209 | int wait4pid(int pid) |
| 210 | { |
| 211 | int status; |
| 212 | |
| 213 | if (pid == -1 || waitpid(pid, &status, 0) == -1) return -1; |
| 214 | if (WIFEXITED(status)) return WEXITSTATUS(status); |
| 215 | if (WIFSIGNALED(status)) return WTERMSIG(status); |
| 216 | return 0; |
| 217 | } |
Rob Landley | 5b88a38 | 2006-07-10 07:41:34 +0000 | [diff] [blame] | 218 | |
Denis Vlasenko | fe54458 | 2006-10-03 15:57:40 +0000 | [diff] [blame] | 219 | void xsetenv(const char *key, const char *value) |
| 220 | { |
Denis Vlasenko | 1db39b2 | 2006-10-11 20:59:02 +0000 | [diff] [blame^] | 221 | if (setenv(key, value, 1)) |
Denis Vlasenko | fe54458 | 2006-10-03 15:57:40 +0000 | [diff] [blame] | 222 | bb_error_msg_and_die(bb_msg_memory_exhausted); |
| 223 | } |
Denis Vlasenko | fe54458 | 2006-10-03 15:57:40 +0000 | [diff] [blame] | 224 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 225 | // Convert unsigned integer to ascii, writing into supplied buffer. A |
| 226 | // truncated result is always null terminated (unless buflen is 0), and |
| 227 | // contains the first few digits of the result ala strncpy. |
Rob Landley | 22d3958 | 2006-07-11 00:44:36 +0000 | [diff] [blame] | 228 | void utoa_to_buf(unsigned n, char *buf, unsigned buflen) |
Rob Landley | 5b88a38 | 2006-07-10 07:41:34 +0000 | [diff] [blame] | 229 | { |
| 230 | int i, out = 0; |
Rob Landley | 22d3958 | 2006-07-11 00:44:36 +0000 | [diff] [blame] | 231 | if (buflen) { |
| 232 | for (i=1000000000; i; i/=10) { |
| 233 | int res = n/i; |
Rob Landley | 5b88a38 | 2006-07-10 07:41:34 +0000 | [diff] [blame] | 234 | |
Rob Landley | 22d3958 | 2006-07-11 00:44:36 +0000 | [diff] [blame] | 235 | if ((res || out || i == 1) && --buflen>0) { |
| 236 | out++; |
| 237 | n -= res*i; |
| 238 | *buf++ = '0' + res; |
| 239 | } |
Rob Landley | 5b88a38 | 2006-07-10 07:41:34 +0000 | [diff] [blame] | 240 | } |
Rob Landley | 22d3958 | 2006-07-11 00:44:36 +0000 | [diff] [blame] | 241 | *buf = 0; |
Rob Landley | 5b88a38 | 2006-07-10 07:41:34 +0000 | [diff] [blame] | 242 | } |
Rob Landley | 5b88a38 | 2006-07-10 07:41:34 +0000 | [diff] [blame] | 243 | } |
| 244 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 245 | // Convert signed integer to ascii, like utoa_to_buf() |
Rob Landley | 22d3958 | 2006-07-11 00:44:36 +0000 | [diff] [blame] | 246 | void itoa_to_buf(int n, char *buf, unsigned buflen) |
Rob Landley | 5b88a38 | 2006-07-10 07:41:34 +0000 | [diff] [blame] | 247 | { |
Rob Landley | 22d3958 | 2006-07-11 00:44:36 +0000 | [diff] [blame] | 248 | if (buflen && n<0) { |
Rob Landley | 5b88a38 | 2006-07-10 07:41:34 +0000 | [diff] [blame] | 249 | n = -n; |
| 250 | *buf++ = '-'; |
Rob Landley | 22d3958 | 2006-07-11 00:44:36 +0000 | [diff] [blame] | 251 | buflen--; |
Rob Landley | 5b88a38 | 2006-07-10 07:41:34 +0000 | [diff] [blame] | 252 | } |
| 253 | utoa_to_buf((unsigned)n, buf, buflen); |
| 254 | } |
| 255 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 256 | // The following two functions use a static buffer, so calling either one a |
| 257 | // second time will overwrite previous results. |
| 258 | // |
| 259 | // The largest 32 bit integer is -2 billion plus null terminator, or 12 bytes. |
| 260 | // Int should always be 32 bits on any remotely Unix-like system, see |
| 261 | // http://www.unix.org/whitepapers/64bit.html for the reasons why. |
| 262 | |
Rob Landley | 23b61be | 2006-08-04 20:20:03 +0000 | [diff] [blame] | 263 | static char local_buf[12]; |
| 264 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 265 | // Convert unsigned integer to ascii using a static buffer (returned). |
Rob Landley | 23b61be | 2006-08-04 20:20:03 +0000 | [diff] [blame] | 266 | char *utoa(unsigned n) |
| 267 | { |
| 268 | utoa_to_buf(n, local_buf, sizeof(local_buf)); |
| 269 | |
| 270 | return local_buf; |
| 271 | } |
| 272 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 273 | // Convert signed integer to ascii using a static buffer (returned). |
Rob Landley | 5b88a38 | 2006-07-10 07:41:34 +0000 | [diff] [blame] | 274 | char *itoa(int n) |
| 275 | { |
| 276 | itoa_to_buf(n, local_buf, sizeof(local_buf)); |
| 277 | |
| 278 | return local_buf; |
| 279 | } |
Rob Landley | df822f2 | 2006-07-15 23:00:46 +0000 | [diff] [blame] | 280 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 281 | // Die with an error message if we can't set gid. (Because resource limits may |
| 282 | // limit this user to a given number of processes, and if that fills up the |
| 283 | // setgid() will fail and we'll _still_be_root_, which is bad.) |
Rob Landley | df822f2 | 2006-07-15 23:00:46 +0000 | [diff] [blame] | 284 | void xsetgid(gid_t gid) |
| 285 | { |
| 286 | if (setgid(gid)) bb_error_msg_and_die("setgid"); |
| 287 | } |
| 288 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 289 | // Die with an error message if we cant' set uid. (See xsetgid() for why.) |
Rob Landley | df822f2 | 2006-07-15 23:00:46 +0000 | [diff] [blame] | 290 | void xsetuid(uid_t uid) |
| 291 | { |
| 292 | if (setuid(uid)) bb_error_msg_and_die("setuid"); |
| 293 | } |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 294 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 295 | // Return how long the file at fd is, if there's any way to determine it. |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 296 | off_t fdlength(int fd) |
| 297 | { |
| 298 | off_t bottom = 0, top = 0, pos; |
| 299 | long size; |
| 300 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 301 | // If the ioctl works for this, return it. |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 302 | |
| 303 | if (ioctl(fd, BLKGETSIZE, &size) >= 0) return size*512; |
| 304 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 305 | // If not, do a binary search for the last location we can read. (Some |
| 306 | // block devices don't do BLKGETSIZE right.) |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 307 | |
| 308 | do { |
| 309 | char temp; |
| 310 | |
Denis Vlasenko | d25a264 | 2006-09-05 09:36:19 +0000 | [diff] [blame] | 311 | pos = bottom + (top - bottom) / 2; |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 312 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 313 | // If we can read from the current location, it's bigger. |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 314 | |
| 315 | if (lseek(fd, pos, 0)>=0 && safe_read(fd, &temp, 1)==1) { |
| 316 | if (bottom == top) bottom = top = (top+1) * 2; |
| 317 | else bottom = pos; |
| 318 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 319 | // If we can't, it's smaller. |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 320 | |
| 321 | } else { |
| 322 | if (bottom == top) { |
| 323 | if (!top) return 0; |
| 324 | bottom = top/2; |
| 325 | } |
| 326 | else top = pos; |
| 327 | } |
| 328 | } while (bottom + 1 != top); |
| 329 | |
| 330 | return pos + 1; |
| 331 | } |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 332 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 333 | // Die with an error message if we can't malloc() enough space and do an |
| 334 | // sprintf() into that space. |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 335 | char *xasprintf(const char *format, ...) |
| 336 | { |
| 337 | va_list p; |
| 338 | int r; |
| 339 | char *string_ptr; |
| 340 | |
| 341 | #if 1 |
| 342 | // GNU extension |
| 343 | va_start(p, format); |
| 344 | r = vasprintf(&string_ptr, format, p); |
| 345 | va_end(p); |
| 346 | #else |
| 347 | // Bloat for systems that haven't got the GNU extension. |
| 348 | va_start(p, format); |
| 349 | r = vsnprintf(NULL, 0, format, p); |
| 350 | va_end(p); |
| 351 | string_ptr = xmalloc(r+1); |
| 352 | va_start(p, format); |
| 353 | r = vsnprintf(string_ptr, r+1, format, p); |
| 354 | va_end(p); |
| 355 | #endif |
| 356 | |
Denis Vlasenko | 3538b9a | 2006-09-06 18:36:50 +0000 | [diff] [blame] | 357 | if (r < 0) bb_error_msg_and_die(bb_msg_memory_exhausted); |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 358 | return string_ptr; |
| 359 | } |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 360 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 361 | // Die with an error message if we can't copy an entire FILE * to stdout, then |
| 362 | // close that file. |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 363 | void xprint_and_close_file(FILE *file) |
| 364 | { |
| 365 | // copyfd outputs error messages for us. |
Denis Vlasenko | a980165 | 2006-09-07 16:20:03 +0000 | [diff] [blame] | 366 | if (bb_copyfd_eof(fileno(file), 1) == -1) |
Denis Vlasenko | 4092082 | 2006-10-03 20:28:06 +0000 | [diff] [blame] | 367 | exit(xfunc_error_retval); |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 368 | |
| 369 | fclose(file); |
| 370 | } |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 371 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 372 | // Die if we can't chdir to a new path. |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 373 | void xchdir(const char *path) |
| 374 | { |
| 375 | if (chdir(path)) |
| 376 | bb_perror_msg_and_die("chdir(%s)", path); |
| 377 | } |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 378 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 379 | // Print a warning message if opendir() fails, but don't die. |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 380 | DIR *warn_opendir(const char *path) |
| 381 | { |
| 382 | DIR *dp; |
| 383 | |
| 384 | if ((dp = opendir(path)) == NULL) { |
| 385 | bb_perror_msg("unable to open `%s'", path); |
| 386 | return NULL; |
| 387 | } |
| 388 | return dp; |
| 389 | } |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 390 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 391 | // Die with an error message if opendir() fails. |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 392 | DIR *xopendir(const char *path) |
| 393 | { |
| 394 | DIR *dp; |
| 395 | |
| 396 | if ((dp = opendir(path)) == NULL) |
| 397 | bb_perror_msg_and_die("unable to open `%s'", path); |
| 398 | return dp; |
| 399 | } |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 400 | |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 401 | #ifndef BB_NOMMU |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 402 | // Die with an error message if we can't daemonize. |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 403 | void xdaemon(int nochdir, int noclose) |
| 404 | { |
Denis Vlasenko | 27af5a0 | 2006-09-03 12:21:59 +0000 | [diff] [blame] | 405 | if (daemon(nochdir, noclose)) bb_perror_msg_and_die("daemon"); |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 406 | } |
| 407 | #endif |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 408 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 409 | // Die with an error message if we can't open a new socket. |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 410 | int xsocket(int domain, int type, int protocol) |
| 411 | { |
| 412 | int r = socket(domain, type, protocol); |
| 413 | |
| 414 | if (r < 0) bb_perror_msg_and_die("socket"); |
| 415 | |
| 416 | return r; |
| 417 | } |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 418 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 419 | // Die with an error message if we can't bind a socket to an address. |
Rob Landley | 23b61be | 2006-08-04 20:20:03 +0000 | [diff] [blame] | 420 | void xbind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen) |
| 421 | { |
| 422 | if (bind(sockfd, my_addr, addrlen)) bb_perror_msg_and_die("bind"); |
| 423 | } |
Rob Landley | 23b61be | 2006-08-04 20:20:03 +0000 | [diff] [blame] | 424 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 425 | // Die with an error message if we can't listen for connections on a socket. |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 426 | void xlisten(int s, int backlog) |
| 427 | { |
| 428 | if (listen(s, backlog)) bb_perror_msg_and_die("listen"); |
| 429 | } |
Bernhard Reutner-Fischer | 57b5667 | 2006-09-11 09:18:09 +0000 | [diff] [blame] | 430 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 431 | // xstat() - a stat() which dies on failure with meaningful error message |
Rob Landley | 20cc6d5 | 2006-09-12 21:42:17 +0000 | [diff] [blame] | 432 | void xstat(char *name, struct stat *stat_buf) |
Bernhard Reutner-Fischer | 57b5667 | 2006-09-11 09:18:09 +0000 | [diff] [blame] | 433 | { |
Denis Vlasenko | 9213a9e | 2006-09-17 16:28:10 +0000 | [diff] [blame] | 434 | if (stat(name, stat_buf)) |
Denis Vlasenko | b633224 | 2006-10-03 19:57:50 +0000 | [diff] [blame] | 435 | bb_perror_msg_and_die("can't stat '%s'", name); |
Bernhard Reutner-Fischer | 57b5667 | 2006-09-11 09:18:09 +0000 | [diff] [blame] | 436 | } |
Bernhard Reutner-Fischer | 57b5667 | 2006-09-11 09:18:09 +0000 | [diff] [blame] | 437 | |
Rob Landley | fbdf121 | 2006-09-20 22:06:01 +0000 | [diff] [blame] | 438 | /* It is perfectly ok to pass in a NULL for either width or for |
| 439 | * * height, in which case that value will not be set. */ |
| 440 | int get_terminal_width_height(int fd, int *width, int *height) |
| 441 | { |
| 442 | struct winsize win = { 0, 0, 0, 0 }; |
| 443 | int ret = ioctl(fd, TIOCGWINSZ, &win); |
| 444 | if (!win.ws_row) { |
| 445 | char *s = getenv("LINES"); |
| 446 | if (s) win.ws_row = atoi(s); |
| 447 | } |
| 448 | if (win.ws_row <= 1) win.ws_row = 24; |
| 449 | if (!win.ws_col) { |
| 450 | char *s = getenv("COLUMNS"); |
| 451 | if (s) win.ws_col = atoi(s); |
| 452 | } |
| 453 | if (win.ws_col <= 1) win.ws_col = 80; |
| 454 | if (height) *height = (int) win.ws_row; |
| 455 | if (width) *width = (int) win.ws_col; |
| 456 | |
| 457 | return ret; |
| 458 | } |