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