summaryrefslogtreecommitdiff
path: root/libbb/xfuncs_printf.c (plain)
blob: 2a20d5339a057c0114fff12bca7f490e5cc55dc9
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 Denys Vlasenko
8 *
9 * Licensed under GPLv2, see file LICENSE in this source tree.
10 */
11
12/* We need to have separate xfuncs.c and xfuncs_printf.c because
13 * with current linkers, even with section garbage collection,
14 * if *.o module references any of XXXprintf functions, you pull in
15 * entire printf machinery. Even if you do not use the function
16 * which uses XXXprintf.
17 *
18 * xfuncs.c contains functions (not necessarily xfuncs)
19 * which do not pull in printf, directly or indirectly.
20 * xfunc_printf.c contains those which do.
21 */
22
23#include "libbb.h"
24
25
26/* All the functions starting with "x" call bb_error_msg_and_die() if they
27 * fail, so callers never need to check for errors. If it returned, it
28 * succeeded. */
29
30#ifndef DMALLOC
31/* dmalloc provides variants of these that do abort() on failure.
32 * Since dmalloc's prototypes overwrite the impls here as they are
33 * included after these prototypes in libbb.h, all is well.
34 */
35// Warn if we can't allocate size bytes of memory.
36void* FAST_FUNC malloc_or_warn(size_t size)
37{
38 void *ptr = malloc(size);
39 if (ptr == NULL && size != 0)
40 bb_error_msg("%s", bb_msg_memory_exhausted);
41 return ptr;
42}
43
44// Die if we can't allocate size bytes of memory.
45void* FAST_FUNC xmalloc(size_t size)
46{
47 void *ptr = malloc(size);
48 if (ptr == NULL && size != 0)
49 bb_error_msg_and_die("%s", bb_msg_memory_exhausted);
50 return ptr;
51}
52
53// Die if we can't resize previously allocated memory. (This returns a pointer
54// to the new memory, which may or may not be the same as the old memory.
55// It'll copy the contents to a new chunk and free the old one if necessary.)
56void* FAST_FUNC xrealloc(void *ptr, size_t size)
57{
58 ptr = realloc(ptr, size);
59 if (ptr == NULL && size != 0)
60 bb_error_msg_and_die("%s", bb_msg_memory_exhausted);
61 return ptr;
62}
63#endif /* DMALLOC */
64
65// Die if we can't allocate and zero size bytes of memory.
66void* FAST_FUNC xzalloc(size_t size)
67{
68 void *ptr = xmalloc(size);
69 memset(ptr, 0, size);
70 return ptr;
71}
72
73// Die if we can't copy a string to freshly allocated memory.
74char* FAST_FUNC xstrdup(const char *s)
75{
76 char *t;
77
78 if (s == NULL)
79 return NULL;
80
81 t = strdup(s);
82
83 if (t == NULL)
84 bb_error_msg_and_die("%s", bb_msg_memory_exhausted);
85
86 return t;
87}
88
89// Die if we can't allocate n+1 bytes (space for the null terminator) and copy
90// the (possibly truncated to length n) string into it.
91char* FAST_FUNC xstrndup(const char *s, int n)
92{
93 int m;
94 char *t;
95
96 if (ENABLE_DEBUG && s == NULL)
97 bb_error_msg_and_die("xstrndup bug");
98
99 /* We can just xmalloc(n+1) and strncpy into it, */
100 /* but think about xstrndup("abc", 10000) wastage! */
101 m = n;
102 t = (char*) s;
103 while (m) {
104 if (!*t) break;
105 m--;
106 t++;
107 }
108 n -= m;
109 t = xmalloc(n + 1);
110 t[n] = '\0';
111
112 return memcpy(t, s, n);
113}
114
115void* FAST_FUNC xmemdup(const void *s, int n)
116{
117 return memcpy(xmalloc(n), s, n);
118}
119
120// Die if we can't open a file and return a FILE* to it.
121// Notice we haven't got xfread(), This is for use with fscanf() and friends.
122FILE* FAST_FUNC xfopen(const char *path, const char *mode)
123{
124 FILE *fp = fopen(path, mode);
125 if (fp == NULL)
126 bb_perror_msg_and_die("can't open '%s'", path);
127 return fp;
128}
129
130// Die if we can't open a file and return a fd.
131int FAST_FUNC xopen3(const char *pathname, int flags, int mode)
132{
133 int ret;
134
135 ret = open(pathname, flags, mode);
136 if (ret < 0) {
137 bb_perror_msg_and_die("can't open '%s'", pathname);
138 }
139 return ret;
140}
141
142// Die if we can't open a file and return a fd.
143int FAST_FUNC xopen(const char *pathname, int flags)
144{
145 return xopen3(pathname, flags, 0666);
146}
147
148// Warn if we can't open a file and return a fd.
149int FAST_FUNC open3_or_warn(const char *pathname, int flags, int mode)
150{
151 int ret;
152
153 ret = open(pathname, flags, mode);
154 if (ret < 0) {
155 bb_perror_msg("can't open '%s'", pathname);
156 }
157 return ret;
158}
159
160// Warn if we can't open a file and return a fd.
161int FAST_FUNC open_or_warn(const char *pathname, int flags)
162{
163 return open3_or_warn(pathname, flags, 0666);
164}
165
166/* Die if we can't open an existing file readonly with O_NONBLOCK
167 * and return the fd.
168 * Note that for ioctl O_RDONLY is sufficient.
169 */
170int FAST_FUNC xopen_nonblocking(const char *pathname)
171{
172 return xopen(pathname, O_RDONLY | O_NONBLOCK);
173}
174
175int FAST_FUNC xopen_as_uid_gid(const char *pathname, int flags, uid_t u, gid_t g)
176{
177 int fd;
178 uid_t old_euid = geteuid();
179 gid_t old_egid = getegid();
180
181 xsetegid(g);
182 xseteuid(u);
183
184 fd = xopen(pathname, flags);
185
186 xseteuid(old_euid);
187 xsetegid(old_egid);
188
189 return fd;
190}
191
192void FAST_FUNC xunlink(const char *pathname)
193{
194 if (unlink(pathname))
195 bb_perror_msg_and_die("can't remove file '%s'", pathname);
196}
197
198void FAST_FUNC xrename(const char *oldpath, const char *newpath)
199{
200 if (rename(oldpath, newpath))
201 bb_perror_msg_and_die("can't move '%s' to '%s'", oldpath, newpath);
202}
203
204int FAST_FUNC rename_or_warn(const char *oldpath, const char *newpath)
205{
206 int n = rename(oldpath, newpath);
207 if (n)
208 bb_perror_msg("can't move '%s' to '%s'", oldpath, newpath);
209 return n;
210}
211
212void FAST_FUNC xpipe(int filedes[2])
213{
214 if (pipe(filedes))
215 bb_perror_msg_and_die("can't create pipe");
216}
217
218void FAST_FUNC xdup2(int from, int to)
219{
220 if (dup2(from, to) != to)
221 bb_perror_msg_and_die("can't duplicate file descriptor");
222}
223
224// "Renumber" opened fd
225void FAST_FUNC xmove_fd(int from, int to)
226{
227 if (from == to)
228 return;
229 xdup2(from, to);
230 close(from);
231}
232
233// Die with an error message if we can't write the entire buffer.
234void FAST_FUNC xwrite(int fd, const void *buf, size_t count)
235{
236 if (count) {
237 ssize_t size = full_write(fd, buf, count);
238 if ((size_t)size != count) {
239 /*
240 * Two cases: write error immediately;
241 * or some writes succeeded, then we hit an error.
242 * In either case, errno is set.
243 */
244 bb_perror_msg_and_die(
245 size >= 0 ? "short write" : "write error"
246 );
247 }
248 }
249}
250void FAST_FUNC xwrite_str(int fd, const char *str)
251{
252 xwrite(fd, str, strlen(str));
253}
254
255void FAST_FUNC xclose(int fd)
256{
257 if (close(fd))
258 bb_perror_msg_and_die("close failed");
259}
260
261// Die with an error message if we can't lseek to the right spot.
262uoff_t FAST_FUNC xlseek(int fd, uoff_t offset, int whence)
263{
264 uoff_t off = lseek(fd, offset, whence);
265 if (off == (uoff_t)-1) {
266 if (whence == SEEK_SET)
267 bb_perror_msg_and_die("lseek(%"OFF_FMT"u)", offset);
268 bb_perror_msg_and_die("lseek");
269 }
270 return off;
271}
272
273int FAST_FUNC xmkstemp(char *template)
274{
275 int fd = mkstemp(template);
276 if (fd < 0)
277 bb_perror_msg_and_die("can't create temp file '%s'", template);
278 return fd;
279}
280
281// Die with supplied filename if this FILE* has ferror set.
282void FAST_FUNC die_if_ferror(FILE *fp, const char *fn)
283{
284 if (ferror(fp)) {
285 /* ferror doesn't set useful errno */
286 bb_error_msg_and_die("%s: I/O error", fn);
287 }
288}
289
290// Die with an error message if stdout has ferror set.
291void FAST_FUNC die_if_ferror_stdout(void)
292{
293 die_if_ferror(stdout, bb_msg_standard_output);
294}
295
296int FAST_FUNC fflush_all(void)
297{
298 return fflush(NULL);
299}
300
301
302int FAST_FUNC bb_putchar(int ch)
303{
304 return putchar(ch);
305}
306
307/* Die with an error message if we can't copy an entire FILE* to stdout,
308 * then close that file. */
309void FAST_FUNC xprint_and_close_file(FILE *file)
310{
311 fflush_all();
312 // copyfd outputs error messages for us.
313 if (bb_copyfd_eof(fileno(file), STDOUT_FILENO) == -1)
314 xfunc_die();
315
316 fclose(file);
317}
318
319// Die with an error message if we can't malloc() enough space and do an
320// sprintf() into that space.
321char* FAST_FUNC xasprintf(const char *format, ...)
322{
323 va_list p;
324 int r;
325 char *string_ptr;
326
327 va_start(p, format);
328 r = vasprintf(&string_ptr, format, p);
329 va_end(p);
330
331 if (r < 0)
332 bb_error_msg_and_die("%s", bb_msg_memory_exhausted);
333 return string_ptr;
334}
335
336void FAST_FUNC xsetenv(const char *key, const char *value)
337{
338#ifdef __BIONIC__
339 /* on login, can be NULL, and should not be for bionic */
340 if (environ == NULL)
341 bb_error_msg_and_die("environment is not initialized");
342#endif
343 if (setenv(key, value, 1))
344 bb_error_msg_and_die("%s", bb_msg_memory_exhausted);
345}
346
347/* Handles "VAR=VAL" strings, even those which are part of environ
348 * _right now_
349 */
350void FAST_FUNC bb_unsetenv(const char *var)
351{
352 char *tp = strchr(var, '=');
353
354 if (!tp) {
355 unsetenv(var);
356 return;
357 }
358
359 /* In case var was putenv'ed, we can't replace '='
360 * with NUL and unsetenv(var) - it won't work,
361 * env is modified by the replacement, unsetenv
362 * sees "VAR" instead of "VAR=VAL" and does not remove it!
363 * horror :( */
364 tp = xstrndup(var, tp - var);
365 unsetenv(tp);
366 free(tp);
367}
368
369void FAST_FUNC bb_unsetenv_and_free(char *var)
370{
371 bb_unsetenv(var);
372 free(var);
373}
374
375// Die with an error message if we can't set gid. (Because resource limits may
376// limit this user to a given number of processes, and if that fills up the
377// setgid() will fail and we'll _still_be_root_, which is bad.)
378void FAST_FUNC xsetgid(gid_t gid)
379{
380 if (setgid(gid)) bb_perror_msg_and_die("setgid");
381}
382
383// Die with an error message if we can't set uid. (See xsetgid() for why.)
384void FAST_FUNC xsetuid(uid_t uid)
385{
386 if (setuid(uid)) bb_perror_msg_and_die("setuid");
387}
388
389void FAST_FUNC xsetegid(gid_t egid)
390{
391 if (setegid(egid)) bb_perror_msg_and_die("setegid");
392}
393
394void FAST_FUNC xseteuid(uid_t euid)
395{
396 if (seteuid(euid)) bb_perror_msg_and_die("seteuid");
397}
398
399// Die if we can't chdir to a new path.
400void FAST_FUNC xchdir(const char *path)
401{
402 if (chdir(path))
403 bb_perror_msg_and_die("can't change directory to '%s'", path);
404}
405
406void FAST_FUNC xfchdir(int fd)
407{
408 if (fchdir(fd))
409 bb_perror_msg_and_die("fchdir");
410}
411
412void FAST_FUNC xchroot(const char *path)
413{
414 if (chroot(path))
415 bb_perror_msg_and_die("can't change root directory to '%s'", path);
416 xchdir("/");
417}
418
419// Print a warning message if opendir() fails, but don't die.
420DIR* FAST_FUNC warn_opendir(const char *path)
421{
422 DIR *dp;
423
424 dp = opendir(path);
425 if (!dp)
426 bb_perror_msg("can't open '%s'", path);
427 return dp;
428}
429
430// Die with an error message if opendir() fails.
431DIR* FAST_FUNC xopendir(const char *path)
432{
433 DIR *dp;
434
435 dp = opendir(path);
436 if (!dp)
437 bb_perror_msg_and_die("can't open '%s'", path);
438 return dp;
439}
440
441// Die with an error message if we can't open a new socket.
442int FAST_FUNC xsocket(int domain, int type, int protocol)
443{
444 int r = socket(domain, type, protocol);
445
446 if (r < 0) {
447 /* Hijack vaguely related config option */
448#if ENABLE_VERBOSE_RESOLUTION_ERRORS
449 const char *s = "INET";
450# ifdef AF_PACKET
451 if (domain == AF_PACKET) s = "PACKET";
452# endif
453# ifdef AF_NETLINK
454 if (domain == AF_NETLINK) s = "NETLINK";
455# endif
456IF_FEATURE_IPV6(if (domain == AF_INET6) s = "INET6";)
457 bb_perror_msg_and_die("socket(AF_%s,%d,%d)", s, type, protocol);
458#else
459 bb_perror_msg_and_die("socket");
460#endif
461 }
462
463 return r;
464}
465
466// Die with an error message if we can't bind a socket to an address.
467void FAST_FUNC xbind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen)
468{
469 if (bind(sockfd, my_addr, addrlen)) bb_perror_msg_and_die("bind");
470}
471
472// Die with an error message if we can't listen for connections on a socket.
473void FAST_FUNC xlisten(int s, int backlog)
474{
475 if (listen(s, backlog)) bb_perror_msg_and_die("listen");
476}
477
478/* Die with an error message if sendto failed.
479 * Return bytes sent otherwise */
480ssize_t FAST_FUNC xsendto(int s, const void *buf, size_t len, const struct sockaddr *to,
481 socklen_t tolen)
482{
483 ssize_t ret = sendto(s, buf, len, 0, to, tolen);
484 if (ret < 0) {
485 if (ENABLE_FEATURE_CLEAN_UP)
486 close(s);
487 bb_perror_msg_and_die("sendto");
488 }
489 return ret;
490}
491
492// xstat() - a stat() which dies on failure with meaningful error message
493void FAST_FUNC xstat(const char *name, struct stat *stat_buf)
494{
495 if (stat(name, stat_buf))
496 bb_perror_msg_and_die("can't stat '%s'", name);
497}
498
499void FAST_FUNC xfstat(int fd, struct stat *stat_buf, const char *errmsg)
500{
501 /* errmsg is usually a file name, but not always:
502 * xfstat may be called in a spot where file name is no longer
503 * available, and caller may give e.g. "can't stat input file" string.
504 */
505 if (fstat(fd, stat_buf))
506 bb_simple_perror_msg_and_die(errmsg);
507}
508
509// selinux_or_die() - die if SELinux is disabled.
510void FAST_FUNC selinux_or_die(void)
511{
512#if ENABLE_SELINUX
513 int rc = is_selinux_enabled();
514 if (rc == 0) {
515 bb_error_msg_and_die("SELinux is disabled");
516 } else if (rc < 0) {
517 bb_error_msg_and_die("is_selinux_enabled() failed");
518 }
519#else
520 bb_error_msg_and_die("SELinux support is disabled");
521#endif
522}
523
524int FAST_FUNC ioctl_or_perror_and_die(int fd, unsigned request, void *argp, const char *fmt,...)
525{
526 int ret;
527 va_list p;
528
529 ret = ioctl(fd, request, argp);
530 if (ret < 0) {
531 va_start(p, fmt);
532 bb_verror_msg(fmt, p, strerror(errno));
533 /* xfunc_die can actually longjmp, so be nice */
534 va_end(p);
535 xfunc_die();
536 }
537 return ret;
538}
539
540int FAST_FUNC ioctl_or_perror(int fd, unsigned request, void *argp, const char *fmt,...)
541{
542 va_list p;
543 int ret = ioctl(fd, request, argp);
544
545 if (ret < 0) {
546 va_start(p, fmt);
547 bb_verror_msg(fmt, p, strerror(errno));
548 va_end(p);
549 }
550 return ret;
551}
552
553#if ENABLE_IOCTL_HEX2STR_ERROR
554int FAST_FUNC bb_ioctl_or_warn(int fd, unsigned request, void *argp, const char *ioctl_name)
555{
556 int ret;
557
558 ret = ioctl(fd, request, argp);
559 if (ret < 0)
560 bb_simple_perror_msg(ioctl_name);
561 return ret;
562}
563int FAST_FUNC bb_xioctl(int fd, unsigned request, void *argp, const char *ioctl_name)
564{
565 int ret;
566
567 ret = ioctl(fd, request, argp);
568 if (ret < 0)
569 bb_simple_perror_msg_and_die(ioctl_name);
570 return ret;
571}
572#else
573int FAST_FUNC bb_ioctl_or_warn(int fd, unsigned request, void *argp)
574{
575 int ret;
576
577 ret = ioctl(fd, request, argp);
578 if (ret < 0)
579 bb_perror_msg("ioctl %#x failed", request);
580 return ret;
581}
582int FAST_FUNC bb_xioctl(int fd, unsigned request, void *argp)
583{
584 int ret;
585
586 ret = ioctl(fd, request, argp);
587 if (ret < 0)
588 bb_perror_msg_and_die("ioctl %#x failed", request);
589 return ret;
590}
591#endif
592
593char* FAST_FUNC xmalloc_ttyname(int fd)
594{
595 char buf[128];
596 int r = ttyname_r(fd, buf, sizeof(buf) - 1);
597 if (r)
598 return NULL;
599 return xstrdup(buf);
600}
601
602void FAST_FUNC generate_uuid(uint8_t *buf)
603{
604 /* http://www.ietf.org/rfc/rfc4122.txt
605 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
606 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
607 * | time_low |
608 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
609 * | time_mid | time_hi_and_version |
610 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
611 * |clk_seq_and_variant | node (0-1) |
612 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
613 * | node (2-5) |
614 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
615 * IOW, uuid has this layout:
616 * uint32_t time_low (big endian)
617 * uint16_t time_mid (big endian)
618 * uint16_t time_hi_and_version (big endian)
619 * version is a 4-bit field:
620 * 1 Time-based
621 * 2 DCE Security, with embedded POSIX UIDs
622 * 3 Name-based (MD5)
623 * 4 Randomly generated
624 * 5 Name-based (SHA-1)
625 * uint16_t clk_seq_and_variant (big endian)
626 * variant is a 3-bit field:
627 * 0xx Reserved, NCS backward compatibility
628 * 10x The variant specified in rfc4122
629 * 110 Reserved, Microsoft backward compatibility
630 * 111 Reserved for future definition
631 * uint8_t node[6]
632 *
633 * For version 4, these bits are set/cleared:
634 * time_hi_and_version & 0x0fff | 0x4000
635 * clk_seq_and_variant & 0x3fff | 0x8000
636 */
637 pid_t pid;
638 int i;
639
640 i = open("/dev/urandom", O_RDONLY);
641 if (i >= 0) {
642 read(i, buf, 16);
643 close(i);
644 }
645 /* Paranoia. /dev/urandom may be missing.
646 * rand() is guaranteed to generate at least [0, 2^15) range,
647 * but lowest bits in some libc are not so "random". */
648 srand(monotonic_us()); /* pulls in printf */
649 pid = getpid();
650 while (1) {
651 for (i = 0; i < 16; i++)
652 buf[i] ^= rand() >> 5;
653 if (pid == 0)
654 break;
655 srand(pid);
656 pid = 0;
657 }
658
659 /* version = 4 */
660 buf[4 + 2 ] = (buf[4 + 2 ] & 0x0f) | 0x40;
661 /* variant = 10x */
662 buf[4 + 2 + 2] = (buf[4 + 2 + 2] & 0x3f) | 0x80;
663}
664
665#if BB_MMU
666pid_t FAST_FUNC xfork(void)
667{
668 pid_t pid;
669 pid = fork();
670 if (pid < 0) /* wtf? */
671 bb_perror_msg_and_die("%s", "vfork"+1);
672 return pid;
673}
674#endif
675
676void FAST_FUNC xvfork_parent_waits_and_exits(void)
677{
678 pid_t pid;
679
680 fflush_all();
681 pid = xvfork();
682 if (pid > 0) {
683 /* Parent */
684 int exit_status = wait_for_exitstatus(pid);
685 if (WIFSIGNALED(exit_status))
686 kill_myself_with_sig(WTERMSIG(exit_status));
687 _exit(WEXITSTATUS(exit_status));
688 }
689 /* Child continues */
690}
691
generated by cgit at 2024-05-15 11:21:15 (GMT)