|| defined (BB_LS) \
|| defined (BB_RM) \
|| defined (BB_TAR)
-/* same conditions as recursiveAction */
+/* same conditions as recursive_action */
#define bb_need_name_too_long
#endif
#define bb_need_memory_exhausted
exit(EXIT_FAILURE);
}
-extern void errorMsg(const char *s, ...)
+static void verror_msg(const char *s, va_list p)
{
- va_list p;
-
- va_start(p, s);
fflush(stdout);
fprintf(stderr, "%s: ", applet_name);
vfprintf(stderr, s, p);
- va_end(p);
fflush(stderr);
}
-extern void fatalError(const char *s, ...)
+extern void error_msg(const char *s, ...)
{
va_list p;
va_start(p, s);
+ verror_msg(s, p);
+ va_end(p);
+}
+
+extern void error_msg_and_die(const char *s, ...)
+{
+ va_list p;
+
+ va_start(p, s);
+ verror_msg(s, p);
+ va_end(p);
+ exit(EXIT_FAILURE);
+}
+
+static void vperror_msg(const char *s, va_list p)
+{
fflush(stdout);
fprintf(stderr, "%s: ", applet_name);
- vfprintf(stderr, s, p);
- va_end(p);
+ if (s && *s) {
+ vfprintf(stderr, s, p);
+ fputs(": ", stderr);
+ }
+ fprintf(stderr, "%s\n", strerror(errno));
fflush(stderr);
+}
+
+extern void perror_msg(const char *s, ...)
+{
+ va_list p;
+
+ va_start(p, s);
+ vperror_msg(s, p);
+ va_end(p);
+}
+
+extern void perror_msg_and_die(const char *s, ...)
+{
+ va_list p;
+
+ va_start(p, s);
+ vperror_msg(s, p);
+ va_end(p);
exit(EXIT_FAILURE);
}
perror("cannot get system information");
return (0);
}
- sscanf(name.version, "%d.%d.%d", &major, &minor, &patch);
+ major = atoi(strtok(name.release, "."));
+ minor = atoi(strtok(NULL, "."));
+ patch = atoi(strtok(NULL, "."));
return major * 65536 + minor * 256 + patch;
}
#endif /* BB_INIT */
* Return TRUE if a fileName is a directory.
* Nonexistant files return FALSE.
*/
-int isDirectory(const char *fileName, const int followLinks, struct stat *statBuf)
+int is_directory(const char *fileName, const int followLinks, struct stat *statBuf)
{
int status;
int didMalloc = 0;
#if defined (BB_AR) || defined BB_CP_MV
/*
- * Copy readSize bytes between two file descriptors
+ * Copy chunksize bytes between two file descriptors
*/
-int copySubFile(int srcFd, int dstFd, size_t remaining)
+int copy_file_chunk(int srcfd, int dstfd, size_t chunksize)
{
size_t size;
- char buffer[BUFSIZ];
+ char buffer[BUFSIZ]; /* BUFSIZ is declared in stdio.h */
- while (remaining > 0) {
- if (remaining > BUFSIZ)
+ while (chunksize > 0) {
+ if (chunksize > BUFSIZ)
size = BUFSIZ;
else
- size = remaining;
- if (fullWrite(dstFd, buffer, fullRead(srcFd, buffer, size)) < size)
+ size = chunksize;
+ if (full_write(dstfd, buffer, full_read(srcfd, buffer, size)) < size)
return(FALSE);
- remaining -= size;
+ chunksize -= size;
}
return (TRUE);
}
* -Erik Andersen
*/
int
-copyFile(const char *srcName, const char *destName,
+copy_file(const char *srcName, const char *destName,
int setModes, int followLinks, int forceFlag)
{
int rfd;
if ((srcStatBuf.st_dev == dstStatBuf.st_dev) &&
(srcStatBuf.st_ino == dstStatBuf.st_ino)) {
- errorMsg("Copying file \"%s\" to itself\n", srcName);
+ error_msg("Copying file \"%s\" to itself\n", srcName);
return FALSE;
}
return FALSE;
}
- if (copySubFile(rfd, wfd, srcStatBuf.st_size)==FALSE)
+ if (copy_file_chunk(rfd, wfd, srcStatBuf.st_size)==FALSE)
goto error_exit;
close(rfd);
S_IROTH, S_IWOTH, S_IXOTH
};
-#define MODE1 "rwxrwxrwx"
-#define MODE0 "---------"
-#define SMODE1 "..s..s..t"
-#define SMODE0 "..S..S..T"
+static const char MODE1[] = "rwxrwxrwx";
+static const char MODE0[] = "---------";
+static const char SMODE1[] = "..s..s..t";
+static const char SMODE0[] = "..S..S..T";
/*
* Return the standard ls-like mode string from a file mode.
* This is static and so is overwritten on each call.
*/
-const char *modeString(int mode)
+const char *mode_string(int mode)
{
static char buf[12];
* Return the standard ls-like time string from a time_t
* This is static and so is overwritten on each call.
*/
-const char *timeString(time_t timeVal)
+const char *time_string(time_t timeVal)
{
time_t now;
char *str;
* This does multiple writes as necessary.
* Returns the amount written, or -1 on an error.
*/
-int fullWrite(int fd, const char *buf, int len)
+int full_write(int fd, const char *buf, int len)
{
int cc;
int total;
* Returns the amount read, or -1 on an error.
* A short read is returned on an end of file.
*/
-int fullRead(int fd, char *buf, int len)
+int full_read(int fd, char *buf, int len)
{
int cc;
int total;
* location, and do something (something specified
* by the fileAction and dirAction function pointers).
*
- * Unfortunatly, while nftw(3) could replace this and reduce
+ * Unfortunately, while nftw(3) could replace this and reduce
* code size a bit, nftw() wasn't supported before GNU libc 2.1,
* and so isn't sufficiently portable to take over since glibc2.1
* is so stinking huge.
*/
-int recursiveAction(const char *fileName,
+int recursive_action(const char *fileName,
int recurse, int followLinks, int depthFirst,
int (*fileAction) (const char *fileName,
struct stat * statbuf,
"status=%d followLinks=%d TRUE=%d\n",
status, followLinks, TRUE);
#endif
- perror(fileName);
+ perror_msg("%s", fileName);
return FALSE;
}
dir = opendir(fileName);
if (!dir) {
- perror(fileName);
+ perror_msg("%s", fileName);
return FALSE;
}
if (dirAction != NULL && depthFirst == FALSE) {
status = dirAction(fileName, &statbuf, userData);
if (status == FALSE) {
- perror(fileName);
+ perror_msg("%s", fileName);
return FALSE;
}
}
continue;
}
if (strlen(fileName) + strlen(next->d_name) + 1 > BUFSIZ) {
- errorMsg(name_too_long);
+ error_msg(name_too_long);
return FALSE;
}
memset(nextFile, 0, sizeof(nextFile));
sprintf(nextFile, "%s/%s", fileName, next->d_name);
status =
- recursiveAction(nextFile, TRUE, followLinks, depthFirst,
+ recursive_action(nextFile, TRUE, followLinks, depthFirst,
fileAction, dirAction, userData);
if (status == FALSE) {
closedir(dir);
}
status = closedir(dir);
if (status < 0) {
- perror(fileName);
+ perror_msg("%s", fileName);
return FALSE;
}
if (dirAction != NULL && depthFirst == TRUE) {
status = dirAction(fileName, &statbuf, userData);
if (status == FALSE) {
- perror(fileName);
+ perror_msg("%s", fileName);
return FALSE;
}
}
* while all previous ones get default protections. Errors are not reported
* here, as failures to restore files can be reported later.
*/
-extern int createPath(const char *name, int mode)
+extern int create_path(const char *name, int mode)
{
char *cp;
char *cpOld;
if (is_a_console(fd))
return fd;
- errorMsg("Couldnt get a file descriptor referring to the console\n");
+ error_msg("Couldnt get a file descriptor referring to the console\n");
return -1; /* total failure */
}
* Given any other file (or directory), find the mount table entry for its
* filesystem.
*/
-extern struct mntent *findMountPoint(const char *name, const char *table)
+extern struct mntent *find_mount_point(const char *name, const char *table)
{
struct stat s;
dev_t mountDevice;
* Read a number with a possible multiplier.
* Returns -1 if the number format is illegal.
*/
-extern long getNum(const char *cp)
+extern long atoi_w_units(const char *cp)
{
long value;
- if (!isDecimal(*cp))
+ if (!is_decimal(*cp))
return -1;
value = 0;
- while (isDecimal(*cp))
+ while (is_decimal(*cp))
value = value * 10 + *cp++ - '0';
switch (*cp++) {
#endif
#if defined BB_FEATURE_USE_DEVPS_PATCH
-/* findPidByName()
+/* find_pid_by_name()
*
* This finds the pid of the specified process,
* by using the /dev/ps device driver.
*
* Returns a list of all matching PIDs
*/
-extern pid_t* findPidByName( char* pidName)
+extern pid_t* find_pid_by_name( char* pidName)
{
int fd, i, j;
char device[] = "/dev/ps";
/* open device */
fd = open(device, O_RDONLY);
if (fd < 0)
- fatalError( "open failed for `%s': %s\n", device, strerror (errno));
+ error_msg_and_die( "open failed for `%s': %s\n", device, strerror (errno));
/* Find out how many processes there are */
if (ioctl (fd, DEVPS_GET_NUM_PIDS, &num_pids)<0)
- fatalError( "\nDEVPS_GET_PID_LIST: %s\n", strerror (errno));
+ error_msg_and_die( "\nDEVPS_GET_PID_LIST: %s\n", strerror (errno));
/* Allocate some memory -- grab a few extras just in case
* some new processes start up while we wait. The kernel will
/* Now grab the pid list */
if (ioctl (fd, DEVPS_GET_PID_LIST, pid_array)<0)
- fatalError( "\nDEVPS_GET_PID_LIST: %s\n", strerror (errno));
+ error_msg_and_die( "\nDEVPS_GET_PID_LIST: %s\n", strerror (errno));
/* Now search for a match */
for (i=1, j=0; i<pid_array[0] ; i++) {
info.pid = pid_array[i];
if (ioctl (fd, DEVPS_GET_PID_INFO, &info)<0)
- fatalError( "\nDEVPS_GET_PID_INFO: %s\n", strerror (errno));
+ error_msg_and_die( "\nDEVPS_GET_PID_INFO: %s\n", strerror (errno));
/* Make sure we only match on the process name */
p=info.command_line+1;
/* close device */
if (close (fd) != 0)
- fatalError( "close failed for `%s': %s\n",device, strerror (errno));
+ error_msg_and_die( "close failed for `%s': %s\n",device, strerror (errno));
return pidList;
}
#error Sorry, I depend on the /proc filesystem right now.
#endif
-/* findPidByName()
+/* find_pid_by_name()
*
* This finds the pid of the specified process.
* Currently, it's implemented by rummaging through
*
* Returns a list of all matching PIDs
*/
-extern pid_t* findPidByName( char* pidName)
+extern pid_t* find_pid_by_name( char* pidName)
{
DIR *dir;
struct dirent *next;
dir = opendir("/proc");
if (!dir)
- fatalError( "Cannot open /proc: %s\n", strerror (errno));
+ error_msg_and_die( "Cannot open /proc: %s\n", strerror (errno));
while ((next = readdir(dir)) != NULL) {
FILE *status;
void *ptr = malloc(size);
if (!ptr)
- fatalError(memory_exhausted);
+ error_msg_and_die(memory_exhausted);
return ptr;
}
{
void *ptr = realloc(old, size);
if (!ptr)
- fatalError(memory_exhausted);
+ error_msg_and_die(memory_exhausted);
return ptr;
}
{
void *ptr = calloc(nmemb, size);
if (!ptr)
- fatalError(memory_exhausted);
+ error_msg_and_die(memory_exhausted);
return ptr;
}
#endif
-#if defined BB_FEATURE_NFSMOUNT || defined BB_SH || defined BB_LS
+#if defined BB_FEATURE_NFSMOUNT || defined BB_LS || defined BB_SH || defined BB_WGET
# ifndef DMALLOC
extern char * xstrdup (const char *s) {
char *t;
t = strdup (s);
if (t == NULL)
- fatalError(memory_exhausted);
+ error_msg_and_die(memory_exhausted);
return t;
}
char *t;
if (s == NULL)
- fatalError("xstrndup bug");
+ error_msg_and_die("xstrndup bug");
t = xmalloc(n+1);
strncpy(t,s,n);
char fileName[BUFSIZ];
if (stat("/", &rootStat) != 0) {
- errorMsg("could not stat '/'\n");
+ error_msg("could not stat '/'\n");
return( FALSE);
}
dir = opendir("/dev");
if (!dir) {
- errorMsg("could not open '/dev'\n");
+ error_msg("could not open '/dev'\n");
return( FALSE);
}
}
#endif /* BB_CAT */
-#if defined BB_ECHO || defined BB_TR
+#if defined BB_ECHO || defined BB_SH || defined BB_TR
char process_escape_sequence(char **ptr)
{
char c;
case 'n':
c = '\n';
break;
+ case 'r':
+ c = '\r';
+ break;
case 't':
c = '\t';
break;
int errmsgsz = regerror(ret, preg, NULL, 0);
char *errmsg = xmalloc(errmsgsz);
regerror(ret, preg, errmsg, errmsgsz);
- fatalError("xregcomp: %s\n", errmsg);
+ error_msg_and_die("xregcomp: %s\n", errmsg);
}
}
#endif
{
FILE *fp;
if ((fp = fopen(path, mode)) == NULL) {
- errorMsg("%s: %s\n", path, strerror(errno));
+ error_msg("%s: %s\n", path, strerror(errno));
errno = 0;
}
return fp;
}
#endif
-#if defined BB_HOSTNAME || defined BB_LOADACM || defined BB_MORE || defined BB_SED || defined BB_SH || defined BB_UNIQ || defined BB_WC
+#if defined BB_HOSTNAME || defined BB_LOADACM || defined BB_MORE \
+ || defined BB_SED || defined BB_SH || defined BB_UNIQ \
+ || defined BB_WC || defined BB_CMP
FILE *xfopen(const char *path, const char *mode)
{
FILE *fp;
if ((fp = fopen(path, mode)) == NULL)
- fatalError("%s: %s\n", path, strerror(errno));
+ error_msg_and_die("%s: %s\n", path, strerror(errno));
return fp;
}
#endif
+int applet_name_compare(const void *x, const void *y)
+{
+ const struct BB_applet *applet1 = x;
+ const struct BB_applet *applet2 = y;
+
+ return strcmp(applet1->name, applet2->name);
+}
+
/* END CODE */
/*
Local Variables: