missing piece of prev commit: ndelay_off
[oweals/busybox.git] / libbb / xfuncs.c
1 /* vi: set sw=4 ts=4: */
2 /*
3  * Utility routines.
4  *
5  * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
6  * Copyright (C) 2006 Rob Landley
7  * Copyright (C) 2006 Denis Vlasenko
8  *
9  * Licensed under GPL version 2, see file LICENSE in this tarball for details.
10  */
11
12 #include "busybox.h"
13
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
18 #ifndef DMALLOC
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  */
23 // Die if we can't allocate size bytes of memory.
24 void *xmalloc(size_t size)
25 {
26         void *ptr = malloc(size);
27         if (ptr == NULL && size != 0)
28                 bb_error_msg_and_die(bb_msg_memory_exhausted);
29         return ptr;
30 }
31
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.)
35 void *xrealloc(void *ptr, size_t size)
36 {
37         ptr = realloc(ptr, size);
38         if (ptr == NULL && size != 0)
39                 bb_error_msg_and_die(bb_msg_memory_exhausted);
40         return ptr;
41 }
42 #endif /* DMALLOC */
43
44 // Die if we can't allocate and zero size bytes of memory.
45 void *xzalloc(size_t size)
46 {
47         void *ptr = xmalloc(size);
48         memset(ptr, 0, size);
49         return ptr;
50 }
51
52 // Die if we can't copy a string to freshly allocated memory.
53 char * xstrdup(const char *s)
54 {
55         char *t;
56
57         if (s == NULL)
58                 return NULL;
59
60         t = strdup(s);
61
62         if (t == NULL)
63                 bb_error_msg_and_die(bb_msg_memory_exhausted);
64
65         return t;
66 }
67
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.
70 char * xstrndup(const char *s, int n)
71 {
72         int m;
73         char *t;
74
75         if (ENABLE_DEBUG && s == NULL)
76                 bb_error_msg_and_die("xstrndup bug");
77
78         /* We can just xmalloc(n+1) and strncpy into it, */
79         /* but think about xstrndup("abc", 10000) wastage! */
80         m = n;
81         t = (char*) s;
82         while (m) {
83                 if (!*t) break;
84                 m--; t++;
85         }
86         n = n - m;
87         t = xmalloc(n + 1);
88         t[n] = '\0';
89
90         return memcpy(t,s,n);
91 }
92
93 // Die if we can't open a file and return a FILE * to it.
94 // Notice we haven't got xfread(), This is for use with fscanf() and friends.
95 FILE *xfopen(const char *path, const char *mode)
96 {
97         FILE *fp = fopen(path, mode);
98         if (fp == NULL)
99                 bb_perror_msg_and_die("%s", path);
100         return fp;
101 }
102
103 // Die if we can't open an existing file and return an fd.
104 int xopen(const char *pathname, int flags)
105 {
106         //if (ENABLE_DEBUG && (flags & O_CREAT))
107         //      bb_error_msg_and_die("xopen() with O_CREAT");
108
109         return xopen3(pathname, flags, 0666);
110 }
111
112 // Die if we can't open a new file and return an fd.
113 int xopen3(const char *pathname, int flags, int mode)
114 {
115         int ret;
116
117         ret = open(pathname, flags, mode);
118         if (ret < 0) {
119                 bb_perror_msg_and_die("%s", pathname);
120         }
121         return ret;
122 }
123
124 // Turn on nonblocking I/O on a fd
125 int ndelay_on(int fd)
126 {
127         return fcntl(fd,F_SETFL,fcntl(fd,F_GETFL,0) | O_NONBLOCK);
128 }
129
130 int ndelay_off(int fd)
131 {
132         return fcntl(fd,F_SETFL,fcntl(fd,F_GETFL,0) & ~O_NONBLOCK);
133 }
134
135 // Die with an error message if we can't write the entire buffer.
136 void xwrite(int fd, const void *buf, size_t count)
137 {
138         if (count) {
139                 ssize_t size = full_write(fd, buf, count);
140                 if (size != count)
141                         bb_error_msg_and_die("short write");
142         }
143 }
144
145 // Die with an error message if we can't lseek to the right spot.
146 off_t xlseek(int fd, off_t offset, int whence)
147 {
148         off_t off = lseek(fd, offset, whence);
149         if (off == (off_t)-1) {
150                 if (whence == SEEK_SET)
151                         bb_perror_msg_and_die("lseek(%"OFF_FMT"u)", offset);
152                 bb_perror_msg_and_die("lseek");
153         }
154         return off;
155 }
156
157 // Die with supplied filename if this FILE * has ferror set.
158 void die_if_ferror(FILE *fp, const char *fn)
159 {
160         if (ferror(fp)) {
161                 bb_error_msg_and_die("%s: I/O error", fn);
162         }
163 }
164
165 // Die with an error message if stdout has ferror set.
166 void die_if_ferror_stdout(void)
167 {
168         die_if_ferror(stdout, bb_msg_standard_output);
169 }
170
171 // Die with an error message if we have trouble flushing stdout.
172 void xfflush_stdout(void)
173 {
174         if (fflush(stdout)) {
175                 bb_perror_msg_and_die(bb_msg_standard_output);
176         }
177 }
178
179 // This does a fork/exec in one call, using vfork().  Return PID of new child,
180 // -1 for failure.  Runs argv[0], searching path if that has no / in it.
181 pid_t spawn(char **argv)
182 {
183         /* Why static? */
184         static int failed;
185         pid_t pid;
186         void *app = ENABLE_FEATURE_SH_STANDALONE_SHELL ? find_applet_by_name(argv[0]) : 0;
187
188         // Be nice to nommu machines.
189         failed = 0;
190         pid = vfork();
191         if (pid < 0) return pid;
192         if (!pid) {
193                 execvp(app ? CONFIG_BUSYBOX_EXEC_PATH : *argv, argv);
194
195                 // We're sharing a stack with blocked parent, let parent know we failed
196                 // and then exit to unblock parent (but don't run atexit() stuff, which
197                 // would screw up parent.)
198
199                 failed = errno;
200                 _exit(0);
201         }
202         if (failed) {
203                 errno = failed;
204                 return -1;
205         }
206         return pid;
207 }
208
209 // Die with an error message if we can't spawn a child process.
210 pid_t xspawn(char **argv)
211 {
212         pid_t pid = spawn(argv);
213         if (pid < 0) bb_perror_msg_and_die("%s", *argv);
214         return pid;
215 }
216
217 // Wait for the specified child PID to exit, returning child's error return.
218 int wait4pid(int pid)
219 {
220         int status;
221
222         if (pid == -1 || waitpid(pid, &status, 0) == -1) return -1;
223         if (WIFEXITED(status)) return WEXITSTATUS(status);
224         if (WIFSIGNALED(status)) return WTERMSIG(status);
225         return 0;
226 }
227
228 void xsetenv(const char *key, const char *value)
229 {
230         if (setenv(key, value, 1))
231                 bb_error_msg_and_die(bb_msg_memory_exhausted);
232 }
233
234 // Converts unsigned long long value into compact 4-char
235 // representation. Examples: "1234", "1.2k", " 27M", "123T"
236 // Fifth char is always '\0'
237 void smart_ulltoa5(unsigned long long ul, char buf[5])
238 {
239         char *fmt;
240         char c;
241         unsigned v,idx = 0;
242         ul *= 10;
243         if (ul > 9999*10) { // do not scale if 9999 or less
244                 while (ul >= 10000) {
245                         ul /= 1024;
246                         idx++;
247                 }
248         }
249         v = ul; // ullong divisions are expensive, avoid them
250
251         fmt = " 123456789";
252         if (!idx) {             // 9999 or less: use 1234 format
253                 c = buf[0] = " 123456789"[v/10000];
254                 if (c!=' ') fmt = "0123456789";
255                 c = buf[1] = fmt[v/1000%10];
256                 if (c!=' ') fmt = "0123456789";
257                 buf[2] = fmt[v/100%10];
258                 buf[3] = "0123456789"[v/10%10];
259         } else {
260                 if (v>=10*10) { // scaled value is >=10: use 123M format
261                         c = buf[0] = " 123456789"[v/1000];
262                         if (c!=' ') fmt = "0123456789";
263                         buf[1] = fmt[v/100%10];
264                         buf[2] = "0123456789"[v/10%10];
265                 } else {        // scaled value is <10: use 1.2M format
266                         buf[0] = "0123456789"[v/10];
267                         buf[1] = '.';
268                         buf[2] = "0123456789"[v%10];
269                 }
270                 // see http://en.wikipedia.org/wiki/Tera
271                 buf[3] = " kMGTPEZY"[idx];
272         }
273         buf[4] = '\0';
274 }
275
276 // Convert unsigned integer to ascii, writing into supplied buffer.  A
277 // truncated result is always null terminated (unless buflen is 0), and
278 // contains the first few digits of the result ala strncpy.
279 void BUG_sizeof_unsigned_not_4(void);
280 void utoa_to_buf(unsigned n, char *buf, unsigned buflen)
281 {
282         unsigned i, out, res;
283         if (sizeof(unsigned) != 4)
284                 BUG_sizeof_unsigned_not_4();
285         if (buflen) {
286                 out = 0;
287                 for (i = 1000000000; i; i /= 10) {
288                         res = n / i;
289                         if (res || out || i == 1) {
290                                 if (!--buflen) break;
291                                 out++;
292                                 n -= res*i;
293                                 *buf++ = '0' + res;
294                         }
295                 }
296                 *buf = '\0';
297         }
298 }
299
300 // Convert signed integer to ascii, like utoa_to_buf()
301 void itoa_to_buf(int n, char *buf, unsigned buflen)
302 {
303         if (buflen && n<0) {
304                 n = -n;
305                 *buf++ = '-';
306                 buflen--;
307         }
308         utoa_to_buf((unsigned)n, buf, buflen);
309 }
310
311 // The following two functions use a static buffer, so calling either one a
312 // second time will overwrite previous results.
313 //
314 // The largest 32 bit integer is -2 billion plus null terminator, or 12 bytes.
315 // Int should always be 32 bits on any remotely Unix-like system, see
316 // http://www.unix.org/whitepapers/64bit.html for the reasons why.
317
318 static char local_buf[12];
319
320 // Convert unsigned integer to ascii using a static buffer (returned).
321 char *utoa(unsigned n)
322 {
323         utoa_to_buf(n, local_buf, sizeof(local_buf));
324
325         return local_buf;
326 }
327
328 // Convert signed integer to ascii using a static buffer (returned).
329 char *itoa(int n)
330 {
331         itoa_to_buf(n, local_buf, sizeof(local_buf));
332
333         return local_buf;
334 }
335
336 // Die with an error message if we can't set gid.  (Because resource limits may
337 // limit this user to a given number of processes, and if that fills up the
338 // setgid() will fail and we'll _still_be_root_, which is bad.)
339 void xsetgid(gid_t gid)
340 {
341         if (setgid(gid)) bb_error_msg_and_die("setgid");
342 }
343
344 // Die with an error message if we can't set uid.  (See xsetgid() for why.)
345 void xsetuid(uid_t uid)
346 {
347         if (setuid(uid)) bb_error_msg_and_die("setuid");
348 }
349
350 // Return how long the file at fd is, if there's any way to determine it.
351 off_t fdlength(int fd)
352 {
353         off_t bottom = 0, top = 0, pos;
354         long size;
355
356         // If the ioctl works for this, return it.
357
358         if (ioctl(fd, BLKGETSIZE, &size) >= 0) return size*512;
359
360         // FIXME: explain why lseek(SEEK_END) is not used here!
361
362         // If not, do a binary search for the last location we can read.  (Some
363         // block devices don't do BLKGETSIZE right.)
364
365         do {
366                 char temp;
367
368                 pos = bottom + (top - bottom) / 2;
369
370                 // If we can read from the current location, it's bigger.
371
372                 if (lseek(fd, pos, SEEK_SET)>=0 && safe_read(fd, &temp, 1)==1) {
373                         if (bottom == top) bottom = top = (top+1) * 2;
374                         else bottom = pos;
375
376                 // If we can't, it's smaller.
377
378                 } else {
379                         if (bottom == top) {
380                                 if (!top) return 0;
381                                 bottom = top/2;
382                         }
383                         else top = pos;
384                 }
385         } while (bottom + 1 != top);
386
387         return pos + 1;
388 }
389
390 // Die with an error message if we can't malloc() enough space and do an
391 // sprintf() into that space.
392 char *xasprintf(const char *format, ...)
393 {
394         va_list p;
395         int r;
396         char *string_ptr;
397
398 #if 1
399         // GNU extension
400         va_start(p, format);
401         r = vasprintf(&string_ptr, format, p);
402         va_end(p);
403 #else
404         // Bloat for systems that haven't got the GNU extension.
405         va_start(p, format);
406         r = vsnprintf(NULL, 0, format, p);
407         va_end(p);
408         string_ptr = xmalloc(r+1);
409         va_start(p, format);
410         r = vsnprintf(string_ptr, r+1, format, p);
411         va_end(p);
412 #endif
413
414         if (r < 0) bb_error_msg_and_die(bb_msg_memory_exhausted);
415         return string_ptr;
416 }
417
418 #if 0 /* If we will ever meet a libc which hasn't [f]dprintf... */
419 int fdprintf(int fd, const char *format, ...)
420 {
421         va_list p;
422         int r;
423         char *string_ptr;
424
425 #if 1
426         // GNU extension
427         va_start(p, format);
428         r = vasprintf(&string_ptr, format, p);
429         va_end(p);
430 #else
431         // Bloat for systems that haven't got the GNU extension.
432         va_start(p, format);
433         r = vsnprintf(NULL, 0, format, p);
434         va_end(p);
435         string_ptr = xmalloc(r+1);
436         va_start(p, format);
437         r = vsnprintf(string_ptr, r+1, format, p);
438         va_end(p);
439 #endif
440
441         if (r >= 0) {
442                 full_write(fd, string_ptr, r);
443                 free(string_ptr);
444         }
445         return r;
446 }
447 #endif
448
449 // Die with an error message if we can't copy an entire FILE * to stdout, then
450 // close that file.
451 void xprint_and_close_file(FILE *file)
452 {
453         fflush(stdout);
454         // copyfd outputs error messages for us.
455         if (bb_copyfd_eof(fileno(file), 1) == -1)
456                 exit(xfunc_error_retval);
457
458         fclose(file);
459 }
460
461 // Die if we can't chdir to a new path.
462 void xchdir(const char *path)
463 {
464         if (chdir(path))
465                 bb_perror_msg_and_die("chdir(%s)", path);
466 }
467
468 // Print a warning message if opendir() fails, but don't die.
469 DIR *warn_opendir(const char *path)
470 {
471         DIR *dp;
472
473         if ((dp = opendir(path)) == NULL) {
474                 bb_perror_msg("cannot open '%s'", path);
475                 return NULL;
476         }
477         return dp;
478 }
479
480 // Die with an error message if opendir() fails.
481 DIR *xopendir(const char *path)
482 {
483         DIR *dp;
484
485         if ((dp = opendir(path)) == NULL)
486                 bb_perror_msg_and_die("cannot open '%s'", path);
487         return dp;
488 }
489
490 #ifndef BB_NOMMU
491 // Die with an error message if we can't daemonize.
492 void xdaemon(int nochdir, int noclose)
493 {
494         if (daemon(nochdir, noclose))
495                 bb_perror_msg_and_die("daemon");
496 }
497 #endif
498
499 // Die with an error message if we can't open a new socket.
500 int xsocket(int domain, int type, int protocol)
501 {
502         int r = socket(domain, type, protocol);
503
504         if (r < 0) bb_perror_msg_and_die("socket");
505
506         return r;
507 }
508
509 // Die with an error message if we can't bind a socket to an address.
510 void xbind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen)
511 {
512         if (bind(sockfd, my_addr, addrlen)) bb_perror_msg_and_die("bind");
513 }
514
515 // Die with an error message if we can't listen for connections on a socket.
516 void xlisten(int s, int backlog)
517 {
518         if (listen(s, backlog)) bb_perror_msg_and_die("listen");
519 }
520
521 // xstat() - a stat() which dies on failure with meaningful error message
522 void xstat(char *name, struct stat *stat_buf)
523 {
524         if (stat(name, stat_buf))
525                 bb_perror_msg_and_die("can't stat '%s'", name);
526 }
527
528 /* It is perfectly ok to pass in a NULL for either width or for
529  * height, in which case that value will not be set.  */
530 int get_terminal_width_height(int fd, int *width, int *height)
531 {
532         struct winsize win = { 0, 0, 0, 0 };
533         int ret = ioctl(fd, TIOCGWINSZ, &win);
534
535         if (height) {
536                 if (!win.ws_row) {
537                         char *s = getenv("LINES");
538                         if (s) win.ws_row = atoi(s);
539                 }
540                 if (win.ws_row <= 1 || win.ws_row >= 30000)
541                         win.ws_row = 24;
542                 *height = (int) win.ws_row;
543         }
544
545         if (width) {
546                 if (!win.ws_col) {
547                         char *s = getenv("COLUMNS");
548                         if (s) win.ws_col = atoi(s);
549                 }
550                 if (win.ws_col <= 1 || win.ws_col >= 30000)
551                         win.ws_col = 80;
552                 *width = (int) win.ws_col;
553         }
554
555         return ret;
556 }