source: branches/stable/mindi-busybox/libbb/xfuncs.c @ 821

Last change on this file since 821 was 821, checked in by bruno, 13 years ago

Addition of busybox 1.2.1 as a mindi-busybox new package
This should avoid delivering binary files in mindi not built there (Fedora and Debian are quite serious about that)

File size: 4.1 KB
Line 
1/* vi: set sw=4 ts=4: */
2/*
3 * Utility routines.
4 *
5 * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
6 *
7 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
8 */
9
10#include <sys/types.h>
11#include <sys/stat.h>
12#include <sys/wait.h>
13#include <stdio.h>
14#include <string.h>
15#include <stdlib.h>
16#include <unistd.h>
17#include <fcntl.h>
18#include "busybox.h"
19
20#ifndef DMALLOC
21#ifdef L_xmalloc
22void *xmalloc(size_t size)
23{
24    void *ptr = malloc(size);
25    if (ptr == NULL && size != 0)
26        bb_error_msg_and_die(bb_msg_memory_exhausted);
27    return ptr;
28}
29#endif
30
31#ifdef L_xrealloc
32void *xrealloc(void *ptr, size_t size)
33{
34    ptr = realloc(ptr, size);
35    if (ptr == NULL && size != 0)
36        bb_error_msg_and_die(bb_msg_memory_exhausted);
37    return ptr;
38}
39#endif
40
41#ifdef L_xzalloc
42void *xzalloc(size_t size)
43{
44    void *ptr = xmalloc(size);
45    memset(ptr, 0, size);
46    return ptr;
47}
48#endif
49
50#ifdef L_xcalloc
51void *xcalloc(size_t nmemb, size_t size)
52{
53    void *ptr = calloc(nmemb, size);
54    if (ptr == NULL && nmemb != 0 && size != 0)
55        bb_error_msg_and_die(bb_msg_memory_exhausted);
56    return ptr;
57}
58#endif
59#endif /* DMALLOC */
60
61#ifdef L_xstrdup
62char * bb_xstrdup (const char *s)
63{
64    char *t;
65
66    if (s == NULL)
67        return NULL;
68
69    t = strdup (s);
70
71    if (t == NULL)
72        bb_error_msg_and_die(bb_msg_memory_exhausted);
73
74    return t;
75}
76#endif
77
78#ifdef L_xstrndup
79char * bb_xstrndup (const char *s, int n)
80{
81    char *t;
82
83    if (ENABLE_DEBUG && s == NULL)
84        bb_error_msg_and_die("bb_xstrndup bug");
85
86    t = xmalloc(++n);
87
88    return safe_strncpy(t,s,n);
89}
90#endif
91
92#ifdef L_xfopen
93FILE *bb_xfopen(const char *path, const char *mode)
94{
95    FILE *fp;
96    if ((fp = fopen(path, mode)) == NULL)
97        bb_perror_msg_and_die("%s", path);
98    return fp;
99}
100#endif
101
102#ifdef L_xopen
103int bb_xopen(const char *pathname, int flags)
104{
105    return bb_xopen3(pathname, flags, 0777);
106}
107#endif
108
109#ifdef L_xopen3
110int bb_xopen3(const char *pathname, int flags, int mode)
111{
112    int ret;
113
114    ret = open(pathname, flags, mode);
115    if (ret < 0) {
116        bb_perror_msg_and_die("%s", pathname);
117    }
118    return ret;
119}
120#endif
121
122#ifdef L_xread
123ssize_t bb_xread(int fd, void *buf, size_t count)
124{
125    ssize_t size;
126
127    size = read(fd, buf, count);
128    if (size < 0) {
129        bb_perror_msg_and_die(bb_msg_read_error);
130    }
131    return(size);
132}
133#endif
134
135#ifdef L_xread_all
136void bb_xread_all(int fd, void *buf, size_t count)
137{
138    ssize_t size;
139
140    while (count) {
141        if ((size = bb_xread(fd, buf, count)) == 0) {   /* EOF */
142            bb_error_msg_and_die("Short read");
143        }
144        count -= size;
145        buf = ((char *) buf) + size;
146    }
147    return;
148}
149#endif
150
151#ifdef L_xread_char
152unsigned char bb_xread_char(int fd)
153{
154    char tmp;
155
156    bb_xread_all(fd, &tmp, 1);
157
158    return(tmp);
159}
160#endif
161
162#ifdef L_xferror
163void bb_xferror(FILE *fp, const char *fn)
164{
165    if (ferror(fp)) {
166        bb_error_msg_and_die("%s", fn);
167    }
168}
169#endif
170
171#ifdef L_xferror_stdout
172void bb_xferror_stdout(void)
173{
174    bb_xferror(stdout, bb_msg_standard_output);
175}
176#endif
177
178#ifdef L_xfflush_stdout
179void bb_xfflush_stdout(void)
180{
181    if (fflush(stdout)) {
182        bb_perror_msg_and_die(bb_msg_standard_output);
183    }
184}
185#endif
186
187#ifdef L_spawn
188// This does a fork/exec in one call, using vfork().
189pid_t bb_spawn(char **argv)
190{
191    static int failed;
192    pid_t pid;
193    void *app = find_applet_by_name(argv[0]);
194
195    // Be nice to nommu machines.
196    failed = 0;
197    pid = vfork();
198    if (pid < 0) return pid;
199    if (!pid) {
200        execvp(app ? CONFIG_BUSYBOX_EXEC_PATH : *argv, argv);
201
202        // We're sharing a stack with blocked parent, let parent know we failed
203        // and then exit to unblock parent (but don't run atexit() stuff, which
204        // would screw up parent.)
205
206        failed = -1;
207        _exit(0);
208    }
209    return failed ? failed : pid;
210}
211#endif
212
213#ifdef L_xspawn
214pid_t bb_xspawn(char **argv)
215{
216    pid_t pid = bb_spawn(argv);
217    if (pid < 0) bb_perror_msg_and_die("%s", *argv);
218    return pid;
219}
220#endif
221
222#ifdef L_wait4
223int wait4pid(int pid)
224{
225    int status;
226
227    if (pid == -1 || waitpid(pid, &status, 0) == -1) return -1;
228    if (WIFEXITED(status)) return WEXITSTATUS(status);
229    if (WIFSIGNALED(status)) return WTERMSIG(status);
230    return 0;
231}
232#endif 
233
234#ifdef L_setuid
235void xsetgid(gid_t gid)
236{
237    if (setgid(gid)) bb_error_msg_and_die("setgid");
238}
239
240void xsetuid(uid_t uid)
241{
242    if (setuid(uid)) bb_error_msg_and_die("setuid");
243}
244#endif
Note: See TracBrowser for help on using the repository browser.