blob: 84281105ce4c3c7e709886b88c1569dc52180059 [file] [log] [blame]
Eric Andersenaad1a882001-03-16 22:47:14 +00001/* vi: set sw=4 ts=4: */
2/*
3 * Utility routines.
4 *
Eric Andersenc7bda1c2004-03-15 08:29:22 +00005 * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
Rob Landleyd921b2e2006-08-03 15:41:12 +00006 * Copyright (C) 2006 Rob Landley
7 * Copyright (C) 2006 Denis Vlasenko
Eric Andersenaad1a882001-03-16 22:47:14 +00008 *
Rob Landleyfbdf1212006-09-20 22:06:01 +00009 * Licensed under GPL version 2, see file LICENSE in this tarball for details.
Eric Andersenaad1a882001-03-16 22:47:14 +000010 */
11
Rob Landley552b56d2006-05-04 21:22:27 +000012#include "busybox.h"
Eric Andersenaad1a882001-03-16 22:47:14 +000013
Rob Landley23b61be2006-08-04 20:20:03 +000014/* 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 Andersenaad1a882001-03-16 22:47:14 +000018#ifndef DMALLOC
Bernhard Reutner-Fischer73561cc2006-08-28 23:31:54 +000019/* 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 Landleyda9d1d02006-09-14 19:52:07 +000023// Die if we can't allocate size bytes of memory.
Rob Landleydfba7412006-03-06 20:47:33 +000024void *xmalloc(size_t size)
Eric Andersenaad1a882001-03-16 22:47:14 +000025{
26 void *ptr = malloc(size);
Matt Kraaia99b1942002-02-26 15:28:22 +000027 if (ptr == NULL && size != 0)
Manuel Novoa III cad53642003-03-19 09:13:01 +000028 bb_error_msg_and_die(bb_msg_memory_exhausted);
Eric Andersenaad1a882001-03-16 22:47:14 +000029 return ptr;
30}
31
Rob Landleyda9d1d02006-09-14 19:52:07 +000032// 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 Landleydfba7412006-03-06 20:47:33 +000035void *xrealloc(void *ptr, size_t size)
Eric Andersenaad1a882001-03-16 22:47:14 +000036{
Matt Kraaia99b1942002-02-26 15:28:22 +000037 ptr = realloc(ptr, size);
38 if (ptr == NULL && size != 0)
Manuel Novoa III cad53642003-03-19 09:13:01 +000039 bb_error_msg_and_die(bb_msg_memory_exhausted);
Eric Andersenaad1a882001-03-16 22:47:14 +000040 return ptr;
41}
Bernhard Reutner-Fischer73561cc2006-08-28 23:31:54 +000042#endif /* DMALLOC */
43
Rob Landleyda9d1d02006-09-14 19:52:07 +000044// Die if we can't allocate and zero size bytes of memory.
Rob Landley80b8ff02006-05-19 20:36:49 +000045void *xzalloc(size_t size)
46{
47 void *ptr = xmalloc(size);
48 memset(ptr, 0, size);
49 return ptr;
50}
Rob Landley80b8ff02006-05-19 20:36:49 +000051
Rob Landleyda9d1d02006-09-14 19:52:07 +000052// Die if we can't copy a string to freshly allocated memory.
Rob Landley23b61be2006-08-04 20:20:03 +000053char * xstrdup(const char *s)
Rob Landley31642d72006-03-14 21:45:38 +000054{
Eric Andersenaad1a882001-03-16 22:47:14 +000055 char *t;
56
57 if (s == NULL)
58 return NULL;
59
60 t = strdup (s);
61
62 if (t == NULL)
Manuel Novoa III cad53642003-03-19 09:13:01 +000063 bb_error_msg_and_die(bb_msg_memory_exhausted);
Eric Andersenaad1a882001-03-16 22:47:14 +000064
65 return t;
66}
Eric Andersenaad1a882001-03-16 22:47:14 +000067
Rob Landleyda9d1d02006-09-14 19:52:07 +000068// 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 Landley23b61be2006-08-04 20:20:03 +000070char * xstrndup(const char *s, int n)
Rob Landley31642d72006-03-14 21:45:38 +000071{
Eric Andersenaad1a882001-03-16 22:47:14 +000072 char *t;
73
Rob Landley8bbdb872006-06-30 16:36:56 +000074 if (ENABLE_DEBUG && s == NULL)
Rob Landleyd921b2e2006-08-03 15:41:12 +000075 bb_error_msg_and_die("xstrndup bug");
Eric Andersenaad1a882001-03-16 22:47:14 +000076
77 t = xmalloc(++n);
Eric Andersenc7bda1c2004-03-15 08:29:22 +000078
Eric Andersenaad1a882001-03-16 22:47:14 +000079 return safe_strncpy(t,s,n);
80}
81
Rob Landleyda9d1d02006-09-14 19:52:07 +000082// 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 Landleyd921b2e2006-08-03 15:41:12 +000084FILE *xfopen(const char *path, const char *mode)
Eric Andersenaad1a882001-03-16 22:47:14 +000085{
86 FILE *fp;
87 if ((fp = fopen(path, mode)) == NULL)
Manuel Novoa III cad53642003-03-19 09:13:01 +000088 bb_perror_msg_and_die("%s", path);
Eric Andersenaad1a882001-03-16 22:47:14 +000089 return fp;
90}
91
Rob Landleyda9d1d02006-09-14 19:52:07 +000092// Die if we can't open an existing file and return an fd.
Rob Landleyd921b2e2006-08-03 15:41:12 +000093int xopen(const char *pathname, int flags)
Glenn L McGrath7ca04f32002-09-25 02:47:48 +000094{
Denis Vlasenkod25a2642006-09-05 09:36:19 +000095 if (ENABLE_DEBUG && (flags & O_CREAT))
Denis Vlasenko6d655be2006-09-06 19:02:46 +000096 bb_error_msg_and_die("xopen() with O_CREAT");
Rob Landley23b61be2006-08-04 20:20:03 +000097
Rob Landleyd921b2e2006-08-03 15:41:12 +000098 return xopen3(pathname, flags, 0777);
Bernhard Reutner-Fischerc2cb0f32006-04-13 12:45:04 +000099}
Bernhard Reutner-Fischerc2cb0f32006-04-13 12:45:04 +0000100
Rob Landleyda9d1d02006-09-14 19:52:07 +0000101// Die if we can't open a new file and return an fd.
Rob Landleyd921b2e2006-08-03 15:41:12 +0000102int xopen3(const char *pathname, int flags, int mode)
Bernhard Reutner-Fischerc2cb0f32006-04-13 12:45:04 +0000103{
Glenn L McGrath7ca04f32002-09-25 02:47:48 +0000104 int ret;
Eric Andersenc7bda1c2004-03-15 08:29:22 +0000105
Bernhard Reutner-Fischerc2cb0f32006-04-13 12:45:04 +0000106 ret = open(pathname, flags, mode);
107 if (ret < 0) {
Manuel Novoa III cad53642003-03-19 09:13:01 +0000108 bb_perror_msg_and_die("%s", pathname);
Glenn L McGrath7ca04f32002-09-25 02:47:48 +0000109 }
110 return ret;
111}
112
Rob Landleyda9d1d02006-09-14 19:52:07 +0000113// Die with an error message if we can't read the entire buffer.
Rob Landley53437472006-07-16 08:14:35 +0000114void xread(int fd, void *buf, size_t count)
Glenn L McGrath7ca04f32002-09-25 02:47:48 +0000115{
Manuel Novoa III cad53642003-03-19 09:13:01 +0000116 while (count) {
Denis Vlasenko1db39b22006-10-11 20:59:02 +0000117 ssize_t size = safe_read(fd, buf, count);
118 if (size < 1)
119 bb_error_msg_and_die("short read");
Manuel Novoa III cad53642003-03-19 09:13:01 +0000120 count -= size;
Manuel Novoa III 948d4902004-03-08 05:44:30 +0000121 buf = ((char *) buf) + size;
Glenn L McGrath7ca04f32002-09-25 02:47:48 +0000122 }
Rob Landley53437472006-07-16 08:14:35 +0000123}
Rob Landley53437472006-07-16 08:14:35 +0000124
Rob Landleyda9d1d02006-09-14 19:52:07 +0000125// Die with an error message if we can't write the entire buffer.
Rob Landley53437472006-07-16 08:14:35 +0000126void xwrite(int fd, void *buf, size_t count)
127{
128 while (count) {
Denis Vlasenko1db39b22006-10-11 20:59:02 +0000129 ssize_t size = safe_write(fd, buf, count);
130 if (size < 1)
131 bb_error_msg_and_die("short write");
Rob Landley53437472006-07-16 08:14:35 +0000132 count -= size;
133 buf = ((char *) buf) + size;
134 }
135}
Rob Landley53437472006-07-16 08:14:35 +0000136
Rob Landleyda9d1d02006-09-14 19:52:07 +0000137// Die with an error message if we can't lseek to the right spot.
Rob Landley53437472006-07-16 08:14:35 +0000138void xlseek(int fd, off_t offset, int whence)
139{
Rob Landley2c55fca2006-08-04 05:24:58 +0000140 if (offset != lseek(fd, offset, whence)) bb_error_msg_and_die("lseek");
Glenn L McGrath7ca04f32002-09-25 02:47:48 +0000141}
142
Rob Landleyda9d1d02006-09-14 19:52:07 +0000143// Die with an error message if we can't read one character.
Rob Landley53437472006-07-16 08:14:35 +0000144unsigned char xread_char(int fd)
Glenn L McGrath7ca04f32002-09-25 02:47:48 +0000145{
146 char tmp;
Eric Andersenc7bda1c2004-03-15 08:29:22 +0000147
Rob Landley53437472006-07-16 08:14:35 +0000148 xread(fd, &tmp, 1);
Glenn L McGrath7ca04f32002-09-25 02:47:48 +0000149
Denis Vlasenko1db39b22006-10-11 20:59:02 +0000150 return tmp;
Glenn L McGrath7ca04f32002-09-25 02:47:48 +0000151}
152
Rob Landleyda9d1d02006-09-14 19:52:07 +0000153// Die with supplied error message if this FILE * has ferror set.
Rob Landleyd921b2e2006-08-03 15:41:12 +0000154void xferror(FILE *fp, const char *fn)
Manuel Novoa III cad53642003-03-19 09:13:01 +0000155{
156 if (ferror(fp)) {
157 bb_error_msg_and_die("%s", fn);
158 }
159}
Manuel Novoa III cad53642003-03-19 09:13:01 +0000160
Rob Landleyda9d1d02006-09-14 19:52:07 +0000161// Die with an error message if stdout has ferror set.
Rob Landleyd921b2e2006-08-03 15:41:12 +0000162void xferror_stdout(void)
Manuel Novoa III cad53642003-03-19 09:13:01 +0000163{
Rob Landleyd921b2e2006-08-03 15:41:12 +0000164 xferror(stdout, bb_msg_standard_output);
Manuel Novoa III cad53642003-03-19 09:13:01 +0000165}
Manuel Novoa III cad53642003-03-19 09:13:01 +0000166
Rob Landleyda9d1d02006-09-14 19:52:07 +0000167// Die with an error message if we have trouble flushing stdout.
Rob Landleyd921b2e2006-08-03 15:41:12 +0000168void xfflush_stdout(void)
Manuel Novoa III cad53642003-03-19 09:13:01 +0000169{
170 if (fflush(stdout)) {
171 bb_perror_msg_and_die(bb_msg_standard_output);
172 }
173}
Rob Landley399d2b52006-05-25 23:02:40 +0000174
Rob Landleyda9d1d02006-09-14 19:52:07 +0000175// 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 Landleyd921b2e2006-08-03 15:41:12 +0000177pid_t spawn(char **argv)
Rob Landley399d2b52006-05-25 23:02:40 +0000178{
179 static int failed;
180 pid_t pid;
Rob Landley519d7df2006-08-09 20:56:23 +0000181 void *app = ENABLE_FEATURE_SH_STANDALONE_SHELL ? find_applet_by_name(argv[0]) : 0;
Rob Landley399d2b52006-05-25 23:02:40 +0000182
Rob Landleyda9d1d02006-09-14 19:52:07 +0000183 // Be nice to nommu machines.
Rob Landley399d2b52006-05-25 23:02:40 +0000184 failed = 0;
185 pid = vfork();
186 if (pid < 0) return pid;
187 if (!pid) {
Rob Landleyc7ddefc2006-06-14 01:24:33 +0000188 execvp(app ? CONFIG_BUSYBOX_EXEC_PATH : *argv, argv);
Rob Landley399d2b52006-05-25 23:02:40 +0000189
Rob Landleyda9d1d02006-09-14 19:52:07 +0000190 // 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 Landley399d2b52006-05-25 23:02:40 +0000193
194 failed = -1;
195 _exit(0);
196 }
197 return failed ? failed : pid;
198}
Rob Landley399d2b52006-05-25 23:02:40 +0000199
Rob Landleyda9d1d02006-09-14 19:52:07 +0000200// Die with an error message if we can't spawn a child process.
Rob Landleyd921b2e2006-08-03 15:41:12 +0000201pid_t xspawn(char **argv)
Rob Landley399d2b52006-05-25 23:02:40 +0000202{
Rob Landleyd921b2e2006-08-03 15:41:12 +0000203 pid_t pid = spawn(argv);
Rob Landley399d2b52006-05-25 23:02:40 +0000204 if (pid < 0) bb_perror_msg_and_die("%s", *argv);
205 return pid;
206}
Rob Landleyc7ddefc2006-06-14 01:24:33 +0000207
Rob Landleyda9d1d02006-09-14 19:52:07 +0000208// Wait for the specified child PID to exit, returning child's error return.
Rob Landleyc7ddefc2006-06-14 01:24:33 +0000209int 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 Landley5b88a382006-07-10 07:41:34 +0000218
Denis Vlasenkofe544582006-10-03 15:57:40 +0000219void xsetenv(const char *key, const char *value)
220{
Denis Vlasenko1db39b22006-10-11 20:59:02 +0000221 if (setenv(key, value, 1))
Denis Vlasenkofe544582006-10-03 15:57:40 +0000222 bb_error_msg_and_die(bb_msg_memory_exhausted);
223}
Denis Vlasenkofe544582006-10-03 15:57:40 +0000224
Rob Landleyda9d1d02006-09-14 19:52:07 +0000225// 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 Landley22d39582006-07-11 00:44:36 +0000228void utoa_to_buf(unsigned n, char *buf, unsigned buflen)
Rob Landley5b88a382006-07-10 07:41:34 +0000229{
230 int i, out = 0;
Rob Landley22d39582006-07-11 00:44:36 +0000231 if (buflen) {
232 for (i=1000000000; i; i/=10) {
233 int res = n/i;
Rob Landley5b88a382006-07-10 07:41:34 +0000234
Rob Landley22d39582006-07-11 00:44:36 +0000235 if ((res || out || i == 1) && --buflen>0) {
236 out++;
237 n -= res*i;
238 *buf++ = '0' + res;
239 }
Rob Landley5b88a382006-07-10 07:41:34 +0000240 }
Rob Landley22d39582006-07-11 00:44:36 +0000241 *buf = 0;
Rob Landley5b88a382006-07-10 07:41:34 +0000242 }
Rob Landley5b88a382006-07-10 07:41:34 +0000243}
244
Rob Landleyda9d1d02006-09-14 19:52:07 +0000245// Convert signed integer to ascii, like utoa_to_buf()
Rob Landley22d39582006-07-11 00:44:36 +0000246void itoa_to_buf(int n, char *buf, unsigned buflen)
Rob Landley5b88a382006-07-10 07:41:34 +0000247{
Rob Landley22d39582006-07-11 00:44:36 +0000248 if (buflen && n<0) {
Rob Landley5b88a382006-07-10 07:41:34 +0000249 n = -n;
250 *buf++ = '-';
Rob Landley22d39582006-07-11 00:44:36 +0000251 buflen--;
Rob Landley5b88a382006-07-10 07:41:34 +0000252 }
253 utoa_to_buf((unsigned)n, buf, buflen);
254}
255
Rob Landleyda9d1d02006-09-14 19:52:07 +0000256// 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 Landley23b61be2006-08-04 20:20:03 +0000263static char local_buf[12];
264
Rob Landleyda9d1d02006-09-14 19:52:07 +0000265// Convert unsigned integer to ascii using a static buffer (returned).
Rob Landley23b61be2006-08-04 20:20:03 +0000266char *utoa(unsigned n)
267{
268 utoa_to_buf(n, local_buf, sizeof(local_buf));
269
270 return local_buf;
271}
272
Rob Landleyda9d1d02006-09-14 19:52:07 +0000273// Convert signed integer to ascii using a static buffer (returned).
Rob Landley5b88a382006-07-10 07:41:34 +0000274char *itoa(int n)
275{
276 itoa_to_buf(n, local_buf, sizeof(local_buf));
277
278 return local_buf;
279}
Rob Landleydf822f22006-07-15 23:00:46 +0000280
Rob Landleyda9d1d02006-09-14 19:52:07 +0000281// 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 Landleydf822f22006-07-15 23:00:46 +0000284void xsetgid(gid_t gid)
285{
286 if (setgid(gid)) bb_error_msg_and_die("setgid");
287}
288
Rob Landleyda9d1d02006-09-14 19:52:07 +0000289// Die with an error message if we cant' set uid. (See xsetgid() for why.)
Rob Landleydf822f22006-07-15 23:00:46 +0000290void xsetuid(uid_t uid)
291{
292 if (setuid(uid)) bb_error_msg_and_die("setuid");
293}
Rob Landley53437472006-07-16 08:14:35 +0000294
Rob Landleyda9d1d02006-09-14 19:52:07 +0000295// Return how long the file at fd is, if there's any way to determine it.
Rob Landley53437472006-07-16 08:14:35 +0000296off_t fdlength(int fd)
297{
298 off_t bottom = 0, top = 0, pos;
299 long size;
300
Rob Landleyda9d1d02006-09-14 19:52:07 +0000301 // If the ioctl works for this, return it.
Rob Landley53437472006-07-16 08:14:35 +0000302
303 if (ioctl(fd, BLKGETSIZE, &size) >= 0) return size*512;
304
Rob Landleyda9d1d02006-09-14 19:52:07 +0000305 // If not, do a binary search for the last location we can read. (Some
306 // block devices don't do BLKGETSIZE right.)
Rob Landley53437472006-07-16 08:14:35 +0000307
308 do {
309 char temp;
310
Denis Vlasenkod25a2642006-09-05 09:36:19 +0000311 pos = bottom + (top - bottom) / 2;
Rob Landley53437472006-07-16 08:14:35 +0000312
Rob Landleyda9d1d02006-09-14 19:52:07 +0000313 // If we can read from the current location, it's bigger.
Rob Landley53437472006-07-16 08:14:35 +0000314
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 Landleyda9d1d02006-09-14 19:52:07 +0000319 // If we can't, it's smaller.
Rob Landley53437472006-07-16 08:14:35 +0000320
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 Landleyd921b2e2006-08-03 15:41:12 +0000332
Rob Landleyda9d1d02006-09-14 19:52:07 +0000333// Die with an error message if we can't malloc() enough space and do an
334// sprintf() into that space.
Rob Landleyd921b2e2006-08-03 15:41:12 +0000335char *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 Vlasenko3538b9a2006-09-06 18:36:50 +0000357 if (r < 0) bb_error_msg_and_die(bb_msg_memory_exhausted);
Rob Landleyd921b2e2006-08-03 15:41:12 +0000358 return string_ptr;
359}
Rob Landleyd921b2e2006-08-03 15:41:12 +0000360
Rob Landleyda9d1d02006-09-14 19:52:07 +0000361// Die with an error message if we can't copy an entire FILE * to stdout, then
362// close that file.
Rob Landleyd921b2e2006-08-03 15:41:12 +0000363void xprint_and_close_file(FILE *file)
364{
365 // copyfd outputs error messages for us.
Denis Vlasenkoa9801652006-09-07 16:20:03 +0000366 if (bb_copyfd_eof(fileno(file), 1) == -1)
Denis Vlasenko40920822006-10-03 20:28:06 +0000367 exit(xfunc_error_retval);
Rob Landleyd921b2e2006-08-03 15:41:12 +0000368
369 fclose(file);
370}
Rob Landleyd921b2e2006-08-03 15:41:12 +0000371
Rob Landleyda9d1d02006-09-14 19:52:07 +0000372// Die if we can't chdir to a new path.
Rob Landleyd921b2e2006-08-03 15:41:12 +0000373void xchdir(const char *path)
374{
375 if (chdir(path))
376 bb_perror_msg_and_die("chdir(%s)", path);
377}
Rob Landleyd921b2e2006-08-03 15:41:12 +0000378
Rob Landleyda9d1d02006-09-14 19:52:07 +0000379// Print a warning message if opendir() fails, but don't die.
Rob Landleyd921b2e2006-08-03 15:41:12 +0000380DIR *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 Landleyd921b2e2006-08-03 15:41:12 +0000390
Rob Landleyda9d1d02006-09-14 19:52:07 +0000391// Die with an error message if opendir() fails.
Rob Landleyd921b2e2006-08-03 15:41:12 +0000392DIR *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 Landleyd921b2e2006-08-03 15:41:12 +0000400
Rob Landleyd921b2e2006-08-03 15:41:12 +0000401#ifndef BB_NOMMU
Rob Landleyda9d1d02006-09-14 19:52:07 +0000402// Die with an error message if we can't daemonize.
Rob Landleyd921b2e2006-08-03 15:41:12 +0000403void xdaemon(int nochdir, int noclose)
404{
Denis Vlasenko27af5a02006-09-03 12:21:59 +0000405 if (daemon(nochdir, noclose)) bb_perror_msg_and_die("daemon");
Rob Landleyd921b2e2006-08-03 15:41:12 +0000406}
407#endif
Rob Landleyd921b2e2006-08-03 15:41:12 +0000408
Rob Landleyda9d1d02006-09-14 19:52:07 +0000409// Die with an error message if we can't open a new socket.
Rob Landleyd921b2e2006-08-03 15:41:12 +0000410int 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 Landleyd921b2e2006-08-03 15:41:12 +0000418
Rob Landleyda9d1d02006-09-14 19:52:07 +0000419// Die with an error message if we can't bind a socket to an address.
Rob Landley23b61be2006-08-04 20:20:03 +0000420void 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 Landley23b61be2006-08-04 20:20:03 +0000424
Rob Landleyda9d1d02006-09-14 19:52:07 +0000425// Die with an error message if we can't listen for connections on a socket.
Rob Landleyd921b2e2006-08-03 15:41:12 +0000426void xlisten(int s, int backlog)
427{
428 if (listen(s, backlog)) bb_perror_msg_and_die("listen");
429}
Bernhard Reutner-Fischer57b56672006-09-11 09:18:09 +0000430
Rob Landleyda9d1d02006-09-14 19:52:07 +0000431// xstat() - a stat() which dies on failure with meaningful error message
Rob Landley20cc6d52006-09-12 21:42:17 +0000432void xstat(char *name, struct stat *stat_buf)
Bernhard Reutner-Fischer57b56672006-09-11 09:18:09 +0000433{
Denis Vlasenko9213a9e2006-09-17 16:28:10 +0000434 if (stat(name, stat_buf))
Denis Vlasenkob6332242006-10-03 19:57:50 +0000435 bb_perror_msg_and_die("can't stat '%s'", name);
Bernhard Reutner-Fischer57b56672006-09-11 09:18:09 +0000436}
Bernhard Reutner-Fischer57b56672006-09-11 09:18:09 +0000437
Rob Landleyfbdf1212006-09-20 22:06:01 +0000438/* 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. */
440int 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}