blob: 02479d9773fa0bce6e421d6e32963dfc614e2699 [file] [log] [blame]
Erik Andersene49d5ec2000-02-08 19:58:47 +00001/* vi: set sw=4 ts=4: */
Eric Andersencc8ed391999-10-05 16:24:54 +00002/*
3 * Utility routines.
4 *
Eric Andersenc4996011999-10-20 22:08:37 +00005 * Copyright (C) tons of folks. Tracking down who wrote what
6 * isn't something I'm going to worry about... If you wrote something
7 * here, please feel free to acknowledge your work.
Eric Andersencc8ed391999-10-05 16:24:54 +00008 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 *
23 * Based in part on code from sash, Copyright (c) 1999 by David I. Bell
24 * Permission has been granted to redistribute this code under the GPL.
25 *
26 */
27
Eric Andersen3570a342000-09-25 21:45:58 +000028#include "busybox.h"
Erik Andersenfac10d72000-02-07 05:29:42 +000029#if defined (BB_CHMOD_CHOWN_CHGRP) \
30 || defined (BB_CP_MV) \
31 || defined (BB_FIND) \
Pavel Roskin21ddb382000-07-17 19:31:54 +000032 || defined (BB_INSMOD) \
Erik Andersenfac10d72000-02-07 05:29:42 +000033 || defined (BB_LS) \
Pavel Roskin21ddb382000-07-17 19:31:54 +000034 || defined (BB_RM) \
35 || defined (BB_TAR)
Mark Whitleyf57c9442000-12-07 19:56:48 +000036/* same conditions as recursive_action */
Erik Andersenfac10d72000-02-07 05:29:42 +000037#define bb_need_name_too_long
38#endif
Eric Andersen9f16d612000-06-12 23:11:16 +000039#define bb_need_memory_exhausted
Pavel Roskin9c5fcc32000-07-17 23:45:12 +000040#define bb_need_full_version
Erik Andersenfac10d72000-02-07 05:29:42 +000041#define BB_DECLARE_EXTERN
42#include "messages.c"
43
Eric Andersen2b69c401999-10-05 22:58:32 +000044#include <stdio.h>
45#include <string.h>
46#include <errno.h>
47#include <fcntl.h>
Eric Andersen2b69c401999-10-05 22:58:32 +000048#include <dirent.h>
49#include <time.h>
50#include <utime.h>
Eric Andersenf811e071999-10-09 00:25:00 +000051#include <unistd.h>
Eric Andersence8f3b91999-10-20 07:03:36 +000052#include <ctype.h>
Eric Andersenbd22ed82000-07-08 18:55:24 +000053#include <sys/ioctl.h>
Erik Andersend07ee462000-02-21 21:26:32 +000054#include <sys/utsname.h> /* for uname(2) */
Eric Andersencc8ed391999-10-05 16:24:54 +000055
Erik Andersen246cc6d2000-03-07 07:41:42 +000056/* Busybox mount uses either /proc/filesystems or /dev/mtab to get the
57 * list of available filesystems used for the -t auto option */
Erik Andersen269bba22000-03-08 14:50:47 +000058#if defined BB_FEATURE_USE_PROCFS && defined BB_FEATURE_USE_DEVPS_PATCH
Erik Andersen246cc6d2000-03-07 07:41:42 +000059//#error Sorry, but busybox can't use both /proc and /dev/ps at the same time -- Pick one and try again.
60#error "Sorry, but busybox can't use both /proc and /dev/ps at the same time -- Pick one and try again."
61#endif
62
Erik Andersen5cbdd712000-01-26 20:06:48 +000063
Eric Andersend0246fb1999-11-04 21:18:07 +000064#if defined BB_MOUNT || defined BB_UMOUNT || defined BB_DF
Eric Andersenfdd51032000-08-02 18:48:26 +000065# if defined BB_MTAB
Eric Andersen0ecb54a1999-12-05 23:24:55 +000066const char mtab_file[] = "/etc/mtab";
Eric Andersenfdd51032000-08-02 18:48:26 +000067# else
68# if defined BB_FEATURE_USE_PROCFS
69const char mtab_file[] = "/proc/mounts";
Eric Andersen0ecb54a1999-12-05 23:24:55 +000070# else
Erik Andersen269bba22000-03-08 14:50:47 +000071# if defined BB_FEATURE_USE_DEVPS_PATCH
Erik Andersen246cc6d2000-03-07 07:41:42 +000072const char mtab_file[] = "/dev/mtab";
73# else
Erik Andersen269bba22000-03-08 14:50:47 +000074# error With (BB_MOUNT||BB_UMOUNT||BB_DF) defined, you must define either BB_MTAB or ( BB_FEATURE_USE_PROCFS | BB_FEATURE_USE_DEVPS_PATCH)
Eric Andersen0ecb54a1999-12-05 23:24:55 +000075# endif
76# endif
Erik Andersen246cc6d2000-03-07 07:41:42 +000077# endif
Eric Andersend0246fb1999-11-04 21:18:07 +000078#endif
79
Eric Andersend73dc5b1999-11-10 23:13:02 +000080extern void usage(const char *usage)
Eric Andersenb0e9a701999-10-18 22:28:26 +000081{
Pavel Roskin9c5fcc32000-07-17 23:45:12 +000082 fprintf(stderr, "%s\n\n", full_version);
Erik Andersene49d5ec2000-02-08 19:58:47 +000083 fprintf(stderr, "Usage: %s\n", usage);
Matt Kraaie0bcce02000-09-27 02:29:39 +000084 exit(EXIT_FAILURE);
Eric Andersenb0e9a701999-10-18 22:28:26 +000085}
86
Mark Whitleyf57c9442000-12-07 19:56:48 +000087static void verror_msg(const char *s, va_list p)
Mark Whitleycf61fe12000-12-05 19:27:13 +000088{
89 fflush(stdout);
90 fprintf(stderr, "%s: ", applet_name);
91 vfprintf(stderr, s, p);
92 fflush(stderr);
93}
94
Mark Whitleyf57c9442000-12-07 19:56:48 +000095extern void error_msg(const char *s, ...)
Erik Andersen9ffdaa62000-02-11 21:55:04 +000096{
97 va_list p;
98
99 va_start(p, s);
Mark Whitleyf57c9442000-12-07 19:56:48 +0000100 verror_msg(s, p);
Erik Andersen9ffdaa62000-02-11 21:55:04 +0000101 va_end(p);
102}
103
Mark Whitleyf57c9442000-12-07 19:56:48 +0000104extern void error_msg_and_die(const char *s, ...)
Erik Andersen9ffdaa62000-02-11 21:55:04 +0000105{
106 va_list p;
107
108 va_start(p, s);
Mark Whitleyf57c9442000-12-07 19:56:48 +0000109 verror_msg(s, p);
Mark Whitleycf61fe12000-12-05 19:27:13 +0000110 va_end(p);
111 exit(EXIT_FAILURE);
112}
113
Mark Whitleyf57c9442000-12-07 19:56:48 +0000114static void vperror_msg(const char *s, va_list p)
Mark Whitleycf61fe12000-12-05 19:27:13 +0000115{
Erik Andersen9ffdaa62000-02-11 21:55:04 +0000116 fflush(stdout);
Matt Kraaibe84cd42000-07-12 17:02:35 +0000117 fprintf(stderr, "%s: ", applet_name);
Mark Whitleycf61fe12000-12-05 19:27:13 +0000118 if (s && *s) {
119 vfprintf(stderr, s, p);
120 fputs(": ", stderr);
121 }
122 fprintf(stderr, "%s\n", strerror(errno));
Erik Andersen3522eb12000-03-12 23:49:18 +0000123 fflush(stderr);
Erik Andersen9ffdaa62000-02-11 21:55:04 +0000124}
Eric Andersenb0e9a701999-10-18 22:28:26 +0000125
Mark Whitleyf57c9442000-12-07 19:56:48 +0000126extern void perror_msg(const char *s, ...)
Matt Kraaief5529b2000-10-25 17:00:36 +0000127{
128 va_list p;
129
130 va_start(p, s);
Mark Whitleyf57c9442000-12-07 19:56:48 +0000131 vperror_msg(s, p);
Matt Kraaief5529b2000-10-25 17:00:36 +0000132 va_end(p);
Matt Kraaief5529b2000-10-25 17:00:36 +0000133}
134
Mark Whitleyf57c9442000-12-07 19:56:48 +0000135extern void perror_msg_and_die(const char *s, ...)
Matt Kraai324a7782000-10-25 15:10:08 +0000136{
137 va_list p;
138
139 va_start(p, s);
Mark Whitleyf57c9442000-12-07 19:56:48 +0000140 vperror_msg(s, p);
Matt Kraai324a7782000-10-25 15:10:08 +0000141 va_end(p);
Matt Kraai324a7782000-10-25 15:10:08 +0000142 exit(EXIT_FAILURE);
143}
144
Eric Andersena2d61e72000-12-12 16:55:56 +0000145#if defined BB_INIT || defined BB_MKSWAP || defined BB_MOUNT
Eric Andersend23f9ba1999-10-20 19:18:15 +0000146/* Returns kernel version encoded as major*65536 + minor*256 + patch,
147 * so, for example, to check if the kernel is greater than 2.2.11:
Erik Andersen298854f2000-03-23 01:09:18 +0000148 * if (get_kernel_revision() <= 2*65536+2*256+11) { <stuff> }
Eric Andersend23f9ba1999-10-20 19:18:15 +0000149 */
Erik Andersen1ad302a2000-03-24 00:54:46 +0000150extern int get_kernel_revision(void)
Eric Andersend23f9ba1999-10-20 19:18:15 +0000151{
Erik Andersend07ee462000-02-21 21:26:32 +0000152 struct utsname name;
Erik Andersene49d5ec2000-02-08 19:58:47 +0000153 int major = 0, minor = 0, patch = 0;
Eric Andersend23f9ba1999-10-20 19:18:15 +0000154
Erik Andersend07ee462000-02-21 21:26:32 +0000155 if (uname(&name) == -1) {
156 perror("cannot get system information");
Erik Andersene49d5ec2000-02-08 19:58:47 +0000157 return (0);
158 }
Eric Andersenef936da2000-10-30 17:22:04 +0000159 major = atoi(strtok(name.release, "."));
160 minor = atoi(strtok(NULL, "."));
161 patch = atoi(strtok(NULL, "."));
Erik Andersene49d5ec2000-02-08 19:58:47 +0000162 return major * 65536 + minor * 256 + patch;
Eric Andersend23f9ba1999-10-20 19:18:15 +0000163}
Erik Andersen23dea9b2000-05-13 00:28:25 +0000164#endif /* BB_INIT */
Eric Andersend23f9ba1999-10-20 19:18:15 +0000165
Eric Andersen10dc9d42000-06-26 10:45:52 +0000166
167
168#if defined BB_FREE || defined BB_INIT || defined BB_UNAME || defined BB_UPTIME
Eric Andersen10dc9d42000-06-26 10:45:52 +0000169_syscall1(int, sysinfo, struct sysinfo *, info);
170#endif /* BB_INIT */
171
Eric Andersena57ba4d2000-07-08 19:20:49 +0000172#if defined BB_MOUNT || defined BB_UMOUNT
Eric Andersena57ba4d2000-07-08 19:20:49 +0000173
174#ifndef __NR_umount2
175#define __NR_umount2 52
176#endif
177
178/* Include our own version of <sys/mount.h>, since libc5 doesn't
179 * know about umount2 */
180extern _syscall1(int, umount, const char *, special_file);
181extern _syscall2(int, umount2, const char *, special_file, int, flags);
182extern _syscall5(int, mount, const char *, special_file, const char *, dir,
183 const char *, fstype, unsigned long int, rwflag, const void *, data);
184#endif
185
Eric Andersenc86e5e62000-08-21 19:38:49 +0000186#if defined BB_INSMOD || defined BB_LSMOD
187#ifndef __NR_query_module
188#define __NR_query_module 167
189#endif
190_syscall5(int, query_module, const char *, name, int, which,
191 void *, buf, size_t, bufsize, size_t*, ret);
192#endif
Eric Andersen10dc9d42000-06-26 10:45:52 +0000193
194
Erik Andersen23dea9b2000-05-13 00:28:25 +0000195#if defined (BB_CP_MV) || defined (BB_DU)
Eric Andersend23f9ba1999-10-20 19:18:15 +0000196
Erik Andersen029011b2000-03-04 21:19:32 +0000197#define HASH_SIZE 311 /* Should be prime */
198#define hash_inode(i) ((i) % HASH_SIZE)
199
200static ino_dev_hashtable_bucket_t *ino_dev_hashtable[HASH_SIZE];
201
202/*
203 * Return 1 if statbuf->st_ino && statbuf->st_dev are recorded in
204 * `ino_dev_hashtable', else return 0
205 *
206 * If NAME is a non-NULL pointer to a character pointer, and there is
207 * a match, then set *NAME to the value of the name slot in that
208 * bucket.
209 */
210int is_in_ino_dev_hashtable(const struct stat *statbuf, char **name)
211{
212 ino_dev_hashtable_bucket_t *bucket;
213
214 bucket = ino_dev_hashtable[hash_inode(statbuf->st_ino)];
215 while (bucket != NULL) {
216 if ((bucket->ino == statbuf->st_ino) &&
217 (bucket->dev == statbuf->st_dev))
218 {
219 if (name) *name = bucket->name;
220 return 1;
221 }
222 bucket = bucket->next;
223 }
224 return 0;
225}
226
227/* Add statbuf to statbuf hash table */
228void add_to_ino_dev_hashtable(const struct stat *statbuf, const char *name)
229{
230 int i;
231 size_t s;
232 ino_dev_hashtable_bucket_t *bucket;
233
234 i = hash_inode(statbuf->st_ino);
235 s = name ? strlen(name) : 0;
Erik Andersen0d068a22000-03-21 22:32:57 +0000236 bucket = xmalloc(sizeof(ino_dev_hashtable_bucket_t) + s);
Erik Andersen029011b2000-03-04 21:19:32 +0000237 bucket->ino = statbuf->st_ino;
238 bucket->dev = statbuf->st_dev;
239 if (name)
240 strcpy(bucket->name, name);
241 else
242 bucket->name[0] = '\0';
243 bucket->next = ino_dev_hashtable[i];
244 ino_dev_hashtable[i] = bucket;
245}
246
247/* Clear statbuf hash table */
248void reset_ino_dev_hashtable(void)
249{
250 int i;
251 ino_dev_hashtable_bucket_t *bucket;
252
253 for (i = 0; i < HASH_SIZE; i++) {
254 while (ino_dev_hashtable[i] != NULL) {
255 bucket = ino_dev_hashtable[i]->next;
256 free(ino_dev_hashtable[i]);
257 ino_dev_hashtable[i] = bucket;
258 }
259 }
260}
261
Erik Andersen23dea9b2000-05-13 00:28:25 +0000262#endif /* BB_CP_MV || BB_DU */
Eric Andersenc6cb79d1999-10-13 18:01:10 +0000263
Glenn L McGrathe699b9f2000-12-15 06:50:54 +0000264#if defined (BB_CP_MV) || defined (BB_DU) || defined (BB_LN)
Eric Andersenc6cb79d1999-10-13 18:01:10 +0000265/*
266 * Return TRUE if a fileName is a directory.
267 * Nonexistant files return FALSE.
268 */
Mark Whitleyf57c9442000-12-07 19:56:48 +0000269int is_directory(const char *fileName, const int followLinks, struct stat *statBuf)
Eric Andersencc8ed391999-10-05 16:24:54 +0000270{
Erik Andersene49d5ec2000-02-08 19:58:47 +0000271 int status;
Erik Andersen9ffdaa62000-02-11 21:55:04 +0000272 int didMalloc = 0;
273
274 if (statBuf == NULL) {
275 statBuf = (struct stat *)xmalloc(sizeof(struct stat));
276 ++didMalloc;
277 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000278
Erik Andersene49d5ec2000-02-08 19:58:47 +0000279 if (followLinks == TRUE)
Erik Andersen9ffdaa62000-02-11 21:55:04 +0000280 status = stat(fileName, statBuf);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000281 else
Erik Andersen9ffdaa62000-02-11 21:55:04 +0000282 status = lstat(fileName, statBuf);
Erik Andersenfac10d72000-02-07 05:29:42 +0000283
Erik Andersen9ffdaa62000-02-11 21:55:04 +0000284 if (status < 0 || !(S_ISDIR(statBuf->st_mode))) {
285 status = FALSE;
286 }
287 else status = TRUE;
288
289 if (didMalloc) {
290 free(statBuf);
291 statBuf = NULL;
292 }
293 return status;
Eric Andersencc8ed391999-10-05 16:24:54 +0000294}
Erik Andersen23dea9b2000-05-13 00:28:25 +0000295#endif
Eric Andersencc8ed391999-10-05 16:24:54 +0000296
Eric Andersenebee3012000-09-05 22:17:22 +0000297#if defined (BB_AR) || defined BB_CP_MV
Glenn L McGrath06aeb6c2000-08-25 03:50:10 +0000298/*
Mark Whitley47583682000-12-05 20:03:17 +0000299 * Copy chunksize bytes between two file descriptors
Glenn L McGrath06aeb6c2000-08-25 03:50:10 +0000300 */
Mark Whitley47583682000-12-05 20:03:17 +0000301int copy_file_chunk(int srcfd, int dstfd, size_t chunksize)
Glenn L McGrath06aeb6c2000-08-25 03:50:10 +0000302{
303 size_t size;
Mark Whitley47583682000-12-05 20:03:17 +0000304 char buffer[BUFSIZ]; /* BUFSIZ is declared in stdio.h */
Glenn L McGrath06aeb6c2000-08-25 03:50:10 +0000305
Mark Whitley47583682000-12-05 20:03:17 +0000306 while (chunksize > 0) {
307 if (chunksize > BUFSIZ)
Glenn L McGrath06aeb6c2000-08-25 03:50:10 +0000308 size = BUFSIZ;
309 else
Mark Whitley47583682000-12-05 20:03:17 +0000310 size = chunksize;
Mark Whitleyf57c9442000-12-07 19:56:48 +0000311 if (full_write(dstfd, buffer, full_read(srcfd, buffer, size)) < size)
Glenn L McGrath06aeb6c2000-08-25 03:50:10 +0000312 return(FALSE);
Mark Whitley47583682000-12-05 20:03:17 +0000313 chunksize -= size;
Glenn L McGrath06aeb6c2000-08-25 03:50:10 +0000314 }
315 return (TRUE);
316}
317#endif
318
319
Erik Andersen23dea9b2000-05-13 00:28:25 +0000320#if defined (BB_CP_MV)
Eric Andersenc6cb79d1999-10-13 18:01:10 +0000321/*
Erik Andersen59b9e872000-05-10 05:05:45 +0000322 * Copy one file to another, while possibly preserving its modes, times, and
323 * modes. Returns TRUE if successful, or FALSE on a failure with an error
324 * message output. (Failure is not indicated if attributes cannot be set.)
325 * -Erik Andersen
Eric Andersenc6cb79d1999-10-13 18:01:10 +0000326 */
327int
Mark Whitleyf57c9442000-12-07 19:56:48 +0000328copy_file(const char *srcName, const char *destName,
Erik Andersen59b9e872000-05-10 05:05:45 +0000329 int setModes, int followLinks, int forceFlag)
Eric Andersenc6cb79d1999-10-13 18:01:10 +0000330{
Erik Andersene49d5ec2000-02-08 19:58:47 +0000331 int rfd;
332 int wfd;
Erik Andersene49d5ec2000-02-08 19:58:47 +0000333 int status;
Erik Andersene49d5ec2000-02-08 19:58:47 +0000334 struct stat srcStatBuf;
335 struct stat dstStatBuf;
336 struct utimbuf times;
Eric Andersenc6cb79d1999-10-13 18:01:10 +0000337
Erik Andersene49d5ec2000-02-08 19:58:47 +0000338 if (followLinks == TRUE)
339 status = stat(srcName, &srcStatBuf);
340 else
341 status = lstat(srcName, &srcStatBuf);
Erik Andersenfac10d72000-02-07 05:29:42 +0000342
Erik Andersenfac10d72000-02-07 05:29:42 +0000343 if (status < 0) {
Erik Andersene49d5ec2000-02-08 19:58:47 +0000344 perror(srcName);
345 return FALSE;
Eric Andersenc6cb79d1999-10-13 18:01:10 +0000346 }
Erik Andersene49d5ec2000-02-08 19:58:47 +0000347
348 if (followLinks == TRUE)
349 status = stat(destName, &dstStatBuf);
350 else
351 status = lstat(destName, &dstStatBuf);
352
Erik Andersen59b9e872000-05-10 05:05:45 +0000353 if (status < 0 || forceFlag==TRUE) {
354 unlink(destName);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000355 dstStatBuf.st_ino = -1;
356 dstStatBuf.st_dev = -1;
357 }
358
359 if ((srcStatBuf.st_dev == dstStatBuf.st_dev) &&
360 (srcStatBuf.st_ino == dstStatBuf.st_ino)) {
Mark Whitleyf57c9442000-12-07 19:56:48 +0000361 error_msg("Copying file \"%s\" to itself\n", srcName);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000362 return FALSE;
363 }
364
365 if (S_ISDIR(srcStatBuf.st_mode)) {
366 //fprintf(stderr, "copying directory %s to %s\n", srcName, destName);
367 /* Make sure the directory is writable */
368 status = mkdir(destName, 0777777 ^ umask(0));
369 if (status < 0 && errno != EEXIST) {
370 perror(destName);
371 return FALSE;
372 }
373 } else if (S_ISLNK(srcStatBuf.st_mode)) {
Erik Andersen4f3f7572000-04-28 00:18:56 +0000374 char link_val[BUFSIZ + 1];
Erik Andersene49d5ec2000-02-08 19:58:47 +0000375 int link_size;
376
377 //fprintf(stderr, "copying link %s to %s\n", srcName, destName);
Erik Andersen4f3f7572000-04-28 00:18:56 +0000378 /* Warning: This could possibly truncate silently, to BUFSIZ chars */
379 link_size = readlink(srcName, &link_val[0], BUFSIZ);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000380 if (link_size < 0) {
381 perror(srcName);
382 return FALSE;
383 }
384 link_val[link_size] = '\0';
385 status = symlink(link_val, destName);
386 if (status < 0) {
387 perror(destName);
388 return FALSE;
389 }
Erik Andersen8e759aa2000-01-29 05:52:40 +0000390#if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1)
Erik Andersene49d5ec2000-02-08 19:58:47 +0000391 if (setModes == TRUE) {
Erik Andersen59b9e872000-05-10 05:05:45 +0000392 /* Try to set owner, but fail silently like GNU cp */
393 lchown(destName, srcStatBuf.st_uid, srcStatBuf.st_gid);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000394 }
Erik Andersen8e759aa2000-01-29 05:52:40 +0000395#endif
Erik Andersene49d5ec2000-02-08 19:58:47 +0000396 return TRUE;
397 } else if (S_ISFIFO(srcStatBuf.st_mode)) {
398 //fprintf(stderr, "copying fifo %s to %s\n", srcName, destName);
399 if (mkfifo(destName, 0644) < 0) {
400 perror(destName);
401 return FALSE;
402 }
403 } else if (S_ISBLK(srcStatBuf.st_mode) || S_ISCHR(srcStatBuf.st_mode)
404 || S_ISSOCK(srcStatBuf.st_mode)) {
405 //fprintf(stderr, "copying soc, blk, or chr %s to %s\n", srcName, destName);
406 if (mknod(destName, srcStatBuf.st_mode, srcStatBuf.st_rdev) < 0) {
407 perror(destName);
408 return FALSE;
409 }
410 } else if (S_ISREG(srcStatBuf.st_mode)) {
411 //fprintf(stderr, "copying regular file %s to %s\n", srcName, destName);
412 rfd = open(srcName, O_RDONLY);
413 if (rfd < 0) {
414 perror(srcName);
415 return FALSE;
416 }
417
Glenn L McGrath06aeb6c2000-08-25 03:50:10 +0000418 wfd = open(destName, O_WRONLY | O_CREAT | O_TRUNC,
Erik Andersene49d5ec2000-02-08 19:58:47 +0000419 srcStatBuf.st_mode);
420 if (wfd < 0) {
421 perror(destName);
422 close(rfd);
423 return FALSE;
424 }
425
Mark Whitley47583682000-12-05 20:03:17 +0000426 if (copy_file_chunk(rfd, wfd, srcStatBuf.st_size)==FALSE)
Glenn L McGrath06aeb6c2000-08-25 03:50:10 +0000427 goto error_exit;
428
Erik Andersene49d5ec2000-02-08 19:58:47 +0000429 close(rfd);
430 if (close(wfd) < 0) {
431 return FALSE;
432 }
433 }
434
435 if (setModes == TRUE) {
436 /* This is fine, since symlinks never get here */
437 if (chown(destName, srcStatBuf.st_uid, srcStatBuf.st_gid) < 0) {
438 perror(destName);
Matt Kraaie0bcce02000-09-27 02:29:39 +0000439 exit(EXIT_FAILURE);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000440 }
441 if (chmod(destName, srcStatBuf.st_mode) < 0) {
442 perror(destName);
Matt Kraaie0bcce02000-09-27 02:29:39 +0000443 exit(EXIT_FAILURE);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000444 }
445 times.actime = srcStatBuf.st_atime;
446 times.modtime = srcStatBuf.st_mtime;
447 if (utime(destName, &times) < 0) {
448 perror(destName);
Matt Kraaie0bcce02000-09-27 02:29:39 +0000449 exit(EXIT_FAILURE);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000450 }
451 }
452
Erik Andersenfac10d72000-02-07 05:29:42 +0000453 return TRUE;
Eric Andersenc6cb79d1999-10-13 18:01:10 +0000454
Erik Andersene49d5ec2000-02-08 19:58:47 +0000455 error_exit:
456 perror(destName);
Eric Andersenc6cb79d1999-10-13 18:01:10 +0000457 close(rfd);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000458 close(wfd);
Eric Andersenc6cb79d1999-10-13 18:01:10 +0000459
Erik Andersene49d5ec2000-02-08 19:58:47 +0000460 return FALSE;
Eric Andersenc6cb79d1999-10-13 18:01:10 +0000461}
Erik Andersen23dea9b2000-05-13 00:28:25 +0000462#endif /* BB_CP_MV */
Eric Andersencc8ed391999-10-05 16:24:54 +0000463
464
465
Glenn L McGrathac19b7e2000-09-11 05:06:13 +0000466#if defined BB_TAR || defined BB_LS ||defined BB_AR
Erik Andersen23dea9b2000-05-13 00:28:25 +0000467
Eric Andersen3d8dbe11999-11-09 01:51:02 +0000468#define TYPEINDEX(mode) (((mode) >> 12) & 0x0f)
469#define TYPECHAR(mode) ("0pcCd?bB-?l?s???" [TYPEINDEX(mode)])
470
471/* The special bits. If set, display SMODE0/1 instead of MODE0/1 */
472static const mode_t SBIT[] = {
Erik Andersene49d5ec2000-02-08 19:58:47 +0000473 0, 0, S_ISUID,
474 0, 0, S_ISGID,
475 0, 0, S_ISVTX
Eric Andersen3d8dbe11999-11-09 01:51:02 +0000476};
477
478/* The 9 mode bits to test */
479static const mode_t MBIT[] = {
Erik Andersene49d5ec2000-02-08 19:58:47 +0000480 S_IRUSR, S_IWUSR, S_IXUSR,
481 S_IRGRP, S_IWGRP, S_IXGRP,
482 S_IROTH, S_IWOTH, S_IXOTH
Eric Andersen3d8dbe11999-11-09 01:51:02 +0000483};
484
Mark Whitley26a3adb2000-12-05 20:10:27 +0000485static const char MODE1[] = "rwxrwxrwx";
486static const char MODE0[] = "---------";
487static const char SMODE1[] = "..s..s..t";
488static const char SMODE0[] = "..S..S..T";
Eric Andersen3d8dbe11999-11-09 01:51:02 +0000489
Eric Andersencc8ed391999-10-05 16:24:54 +0000490/*
491 * Return the standard ls-like mode string from a file mode.
492 * This is static and so is overwritten on each call.
493 */
Mark Whitleyf57c9442000-12-07 19:56:48 +0000494const char *mode_string(int mode)
Eric Andersencc8ed391999-10-05 16:24:54 +0000495{
Erik Andersene49d5ec2000-02-08 19:58:47 +0000496 static char buf[12];
Eric Andersencc8ed391999-10-05 16:24:54 +0000497
Erik Andersene49d5ec2000-02-08 19:58:47 +0000498 int i;
499
500 buf[0] = TYPECHAR(mode);
501 for (i = 0; i < 9; i++) {
502 if (mode & SBIT[i])
503 buf[i + 1] = (mode & MBIT[i]) ? SMODE1[i] : SMODE0[i];
504 else
505 buf[i + 1] = (mode & MBIT[i]) ? MODE1[i] : MODE0[i];
506 }
507 return buf;
Eric Andersencc8ed391999-10-05 16:24:54 +0000508}
Erik Andersen23dea9b2000-05-13 00:28:25 +0000509#endif /* BB_TAR || BB_LS */
Eric Andersencc8ed391999-10-05 16:24:54 +0000510
511
Pavel Roskin21ddb382000-07-17 19:31:54 +0000512#if defined BB_TAR || defined BB_AR
Eric Andersencc8ed391999-10-05 16:24:54 +0000513/*
Eric Andersen3d8dbe11999-11-09 01:51:02 +0000514 * Return the standard ls-like time string from a time_t
515 * This is static and so is overwritten on each call.
Eric Andersen17d49ef1999-10-06 20:25:32 +0000516 */
Mark Whitleyf57c9442000-12-07 19:56:48 +0000517const char *time_string(time_t timeVal)
Eric Andersen17d49ef1999-10-06 20:25:32 +0000518{
Erik Andersene49d5ec2000-02-08 19:58:47 +0000519 time_t now;
520 char *str;
521 static char buf[26];
Eric Andersen17d49ef1999-10-06 20:25:32 +0000522
Erik Andersene49d5ec2000-02-08 19:58:47 +0000523 time(&now);
Eric Andersen17d49ef1999-10-06 20:25:32 +0000524
Erik Andersene49d5ec2000-02-08 19:58:47 +0000525 str = ctime(&timeVal);
Eric Andersen17d49ef1999-10-06 20:25:32 +0000526
Erik Andersene49d5ec2000-02-08 19:58:47 +0000527 strcpy(buf, &str[4]);
528 buf[12] = '\0';
Eric Andersen17d49ef1999-10-06 20:25:32 +0000529
Erik Andersene49d5ec2000-02-08 19:58:47 +0000530 if ((timeVal > now) || (timeVal < now - 365 * 24 * 60 * 60L)) {
531 strcpy(&buf[7], &str[20]);
532 buf[11] = '\0';
533 }
Eric Andersen17d49ef1999-10-06 20:25:32 +0000534
Erik Andersene49d5ec2000-02-08 19:58:47 +0000535 return buf;
Eric Andersen17d49ef1999-10-06 20:25:32 +0000536}
Pavel Roskincc8a66b2000-07-17 20:18:42 +0000537#endif /* BB_TAR || BB_AR */
Eric Andersen17d49ef1999-10-06 20:25:32 +0000538
Eric Andersena2d61e72000-12-12 16:55:56 +0000539#if defined BB_TAR || defined BB_CP_MV || defined BB_AR || defined BB_DD
Eric Andersen17d49ef1999-10-06 20:25:32 +0000540/*
Eric Andersencc8ed391999-10-05 16:24:54 +0000541 * Write all of the supplied buffer out to a file.
542 * This does multiple writes as necessary.
543 * Returns the amount written, or -1 on an error.
544 */
Mark Whitleyf57c9442000-12-07 19:56:48 +0000545int full_write(int fd, const char *buf, int len)
Eric Andersencc8ed391999-10-05 16:24:54 +0000546{
Erik Andersene49d5ec2000-02-08 19:58:47 +0000547 int cc;
548 int total;
Eric Andersencc8ed391999-10-05 16:24:54 +0000549
Erik Andersene49d5ec2000-02-08 19:58:47 +0000550 total = 0;
Eric Andersencc8ed391999-10-05 16:24:54 +0000551
Erik Andersene49d5ec2000-02-08 19:58:47 +0000552 while (len > 0) {
553 cc = write(fd, buf, len);
Eric Andersencc8ed391999-10-05 16:24:54 +0000554
Erik Andersene49d5ec2000-02-08 19:58:47 +0000555 if (cc < 0)
556 return -1;
Eric Andersencc8ed391999-10-05 16:24:54 +0000557
Erik Andersene49d5ec2000-02-08 19:58:47 +0000558 buf += cc;
559 total += cc;
560 len -= cc;
561 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000562
Erik Andersene49d5ec2000-02-08 19:58:47 +0000563 return total;
Eric Andersencc8ed391999-10-05 16:24:54 +0000564}
Pavel Roskincc8a66b2000-07-17 20:18:42 +0000565#endif /* BB_TAR || BB_CP_MV || BB_AR */
Eric Andersencc8ed391999-10-05 16:24:54 +0000566
567
Eric Andersena2d61e72000-12-12 16:55:56 +0000568#if defined BB_TAR || defined BB_TAIL || defined BB_AR || defined BB_SH || defined BB_CP_MV || defined BB_DD
Eric Andersencc8ed391999-10-05 16:24:54 +0000569/*
570 * Read all of the supplied buffer from a file.
571 * This does multiple reads as necessary.
572 * Returns the amount read, or -1 on an error.
573 * A short read is returned on an end of file.
574 */
Mark Whitleyf57c9442000-12-07 19:56:48 +0000575int full_read(int fd, char *buf, int len)
Eric Andersencc8ed391999-10-05 16:24:54 +0000576{
Erik Andersene49d5ec2000-02-08 19:58:47 +0000577 int cc;
578 int total;
Eric Andersencc8ed391999-10-05 16:24:54 +0000579
Erik Andersene49d5ec2000-02-08 19:58:47 +0000580 total = 0;
Eric Andersencc8ed391999-10-05 16:24:54 +0000581
Erik Andersene49d5ec2000-02-08 19:58:47 +0000582 while (len > 0) {
583 cc = read(fd, buf, len);
Eric Andersencc8ed391999-10-05 16:24:54 +0000584
Erik Andersene49d5ec2000-02-08 19:58:47 +0000585 if (cc < 0)
586 return -1;
Eric Andersencc8ed391999-10-05 16:24:54 +0000587
Erik Andersene49d5ec2000-02-08 19:58:47 +0000588 if (cc == 0)
589 break;
Eric Andersencc8ed391999-10-05 16:24:54 +0000590
Erik Andersene49d5ec2000-02-08 19:58:47 +0000591 buf += cc;
592 total += cc;
593 len -= cc;
594 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000595
Erik Andersene49d5ec2000-02-08 19:58:47 +0000596 return total;
Eric Andersencc8ed391999-10-05 16:24:54 +0000597}
Pavel Roskincc8a66b2000-07-17 20:18:42 +0000598#endif /* BB_TAR || BB_TAIL || BB_AR || BB_SH */
Eric Andersencc8ed391999-10-05 16:24:54 +0000599
600
Erik Andersen23dea9b2000-05-13 00:28:25 +0000601#if defined (BB_CHMOD_CHOWN_CHGRP) \
602 || defined (BB_CP_MV) \
603 || defined (BB_FIND) \
604 || defined (BB_INSMOD) \
Pavel Roskin21ddb382000-07-17 19:31:54 +0000605 || defined (BB_LS) \
Erik Andersen23dea9b2000-05-13 00:28:25 +0000606 || defined (BB_RM) \
607 || defined (BB_TAR)
608
Eric Andersencc8ed391999-10-05 16:24:54 +0000609/*
Eric Andersen2b69c401999-10-05 22:58:32 +0000610 * Walk down all the directories under the specified
611 * location, and do something (something specified
612 * by the fileAction and dirAction function pointers).
Eric Andersenb7a1a751999-10-19 23:37:14 +0000613 *
Eric Andersenf3b2b522000-12-07 22:42:11 +0000614 * Unfortunately, while nftw(3) could replace this and reduce
Eric Andersen63a0e531999-10-22 05:12:14 +0000615 * code size a bit, nftw() wasn't supported before GNU libc 2.1,
Eric Andersencf8c9cf1999-11-05 00:31:46 +0000616 * and so isn't sufficiently portable to take over since glibc2.1
617 * is so stinking huge.
Eric Andersencc8ed391999-10-05 16:24:54 +0000618 */
Mark Whitleyf57c9442000-12-07 19:56:48 +0000619int recursive_action(const char *fileName,
Erik Andersene49d5ec2000-02-08 19:58:47 +0000620 int recurse, int followLinks, int depthFirst,
621 int (*fileAction) (const char *fileName,
Erik Andersen3364d782000-03-28 00:58:14 +0000622 struct stat * statbuf,
623 void* userData),
Erik Andersene49d5ec2000-02-08 19:58:47 +0000624 int (*dirAction) (const char *fileName,
Erik Andersen3364d782000-03-28 00:58:14 +0000625 struct stat * statbuf,
626 void* userData),
627 void* userData)
Eric Andersencc8ed391999-10-05 16:24:54 +0000628{
Erik Andersene49d5ec2000-02-08 19:58:47 +0000629 int status;
630 struct stat statbuf;
631 struct dirent *next;
Eric Andersen9d3aba71999-10-06 09:04:55 +0000632
Erik Andersene49d5ec2000-02-08 19:58:47 +0000633 if (followLinks == TRUE)
634 status = stat(fileName, &statbuf);
Eric Andersen50d63601999-11-09 01:47:36 +0000635 else
Erik Andersene49d5ec2000-02-08 19:58:47 +0000636 status = lstat(fileName, &statbuf);
Eric Andersencf8c9cf1999-11-05 00:31:46 +0000637
Eric Andersen2b69c401999-10-05 22:58:32 +0000638 if (status < 0) {
Erik Andersene49d5ec2000-02-08 19:58:47 +0000639#ifdef BB_DEBUG_PRINT_SCAFFOLD
640 fprintf(stderr,
641 "status=%d followLinks=%d TRUE=%d\n",
642 status, followLinks, TRUE);
643#endif
Mark Whitleyf57c9442000-12-07 19:56:48 +0000644 perror_msg("%s", fileName);
Erik Andersenfac10d72000-02-07 05:29:42 +0000645 return FALSE;
Eric Andersenbed30e91999-10-18 19:02:32 +0000646 }
Erik Andersene49d5ec2000-02-08 19:58:47 +0000647
648 if ((followLinks == FALSE) && (S_ISLNK(statbuf.st_mode))) {
649 if (fileAction == NULL)
650 return TRUE;
651 else
Erik Andersen3364d782000-03-28 00:58:14 +0000652 return fileAction(fileName, &statbuf, userData);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000653 }
654
655 if (recurse == FALSE) {
656 if (S_ISDIR(statbuf.st_mode)) {
657 if (dirAction != NULL)
Erik Andersen3364d782000-03-28 00:58:14 +0000658 return (dirAction(fileName, &statbuf, userData));
Erik Andersene49d5ec2000-02-08 19:58:47 +0000659 else
660 return TRUE;
661 }
662 }
663
664 if (S_ISDIR(statbuf.st_mode)) {
665 DIR *dir;
666
667 dir = opendir(fileName);
668 if (!dir) {
Mark Whitleyf57c9442000-12-07 19:56:48 +0000669 perror_msg("%s", fileName);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000670 return FALSE;
671 }
672 if (dirAction != NULL && depthFirst == FALSE) {
Erik Andersen3364d782000-03-28 00:58:14 +0000673 status = dirAction(fileName, &statbuf, userData);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000674 if (status == FALSE) {
Mark Whitleyf57c9442000-12-07 19:56:48 +0000675 perror_msg("%s", fileName);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000676 return FALSE;
677 }
678 }
679 while ((next = readdir(dir)) != NULL) {
Erik Andersen4f3f7572000-04-28 00:18:56 +0000680 char nextFile[BUFSIZ + 1];
Erik Andersene49d5ec2000-02-08 19:58:47 +0000681
682 if ((strcmp(next->d_name, "..") == 0)
683 || (strcmp(next->d_name, ".") == 0)) {
684 continue;
685 }
Erik Andersen4f3f7572000-04-28 00:18:56 +0000686 if (strlen(fileName) + strlen(next->d_name) + 1 > BUFSIZ) {
Mark Whitleyf57c9442000-12-07 19:56:48 +0000687 error_msg(name_too_long);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000688 return FALSE;
689 }
Erik Andersenc3660502000-04-18 21:18:57 +0000690 memset(nextFile, 0, sizeof(nextFile));
Erik Andersene49d5ec2000-02-08 19:58:47 +0000691 sprintf(nextFile, "%s/%s", fileName, next->d_name);
692 status =
Mark Whitleyf57c9442000-12-07 19:56:48 +0000693 recursive_action(nextFile, TRUE, followLinks, depthFirst,
Erik Andersen3364d782000-03-28 00:58:14 +0000694 fileAction, dirAction, userData);
Matt Kraai0f8f7b82000-08-01 18:16:56 +0000695 if (status == FALSE) {
Erik Andersene49d5ec2000-02-08 19:58:47 +0000696 closedir(dir);
697 return FALSE;
698 }
699 }
700 status = closedir(dir);
701 if (status < 0) {
Mark Whitleyf57c9442000-12-07 19:56:48 +0000702 perror_msg("%s", fileName);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000703 return FALSE;
704 }
705 if (dirAction != NULL && depthFirst == TRUE) {
Erik Andersen3364d782000-03-28 00:58:14 +0000706 status = dirAction(fileName, &statbuf, userData);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000707 if (status == FALSE) {
Mark Whitleyf57c9442000-12-07 19:56:48 +0000708 perror_msg("%s", fileName);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000709 return FALSE;
710 }
711 }
712 } else {
713 if (fileAction == NULL)
714 return TRUE;
715 else
Erik Andersen3364d782000-03-28 00:58:14 +0000716 return fileAction(fileName, &statbuf, userData);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000717 }
718 return TRUE;
Eric Andersencc8ed391999-10-05 16:24:54 +0000719}
720
Erik Andersen23dea9b2000-05-13 00:28:25 +0000721#endif /* BB_CHMOD_CHOWN_CHGRP || BB_CP_MV || BB_FIND || BB_LS || BB_INSMOD */
Eric Andersencc8ed391999-10-05 16:24:54 +0000722
Eric Andersenf6be9441999-10-13 21:12:06 +0000723
724
Glenn L McGrathe699b9f2000-12-15 06:50:54 +0000725#if defined (BB_TAR) || defined (BB_MKDIR)
Eric Andersenf6be9441999-10-13 21:12:06 +0000726/*
727 * Attempt to create the directories along the specified path, except for
728 * the final component. The mode is given for the final directory only,
729 * while all previous ones get default protections. Errors are not reported
730 * here, as failures to restore files can be reported later.
731 */
Mark Whitleyf57c9442000-12-07 19:56:48 +0000732extern int create_path(const char *name, int mode)
Eric Andersenf6be9441999-10-13 21:12:06 +0000733{
Erik Andersene49d5ec2000-02-08 19:58:47 +0000734 char *cp;
735 char *cpOld;
Erik Andersen4f3f7572000-04-28 00:18:56 +0000736 char buf[BUFSIZ + 1];
Erik Andersene49d5ec2000-02-08 19:58:47 +0000737 int retVal = 0;
Eric Andersenf6be9441999-10-13 21:12:06 +0000738
Erik Andersene49d5ec2000-02-08 19:58:47 +0000739 strcpy(buf, name);
740 for (cp = buf; *cp == '/'; cp++);
741 cp = strchr(cp, '/');
742 while (cp) {
743 cpOld = cp;
744 cp = strchr(cp + 1, '/');
745 *cpOld = '\0';
746 retVal = mkdir(buf, cp ? 0777 : mode);
747 if (retVal != 0 && errno != EEXIST) {
748 perror(buf);
749 return FALSE;
750 }
751 *cpOld = '/';
Erik Andersen06936df2000-01-23 02:14:20 +0000752 }
Erik Andersene49d5ec2000-02-08 19:58:47 +0000753 return TRUE;
Eric Andersenf6be9441999-10-13 21:12:06 +0000754}
Erik Andersen23dea9b2000-05-13 00:28:25 +0000755#endif /* BB_TAR || BB_MKDIR */
Eric Andersenf6be9441999-10-13 21:12:06 +0000756
757
758
Pavel Roskin21ddb382000-07-17 19:31:54 +0000759#if defined (BB_CHMOD_CHOWN_CHGRP) || defined (BB_MKDIR) \
Glenn L McGrathac19b7e2000-09-11 05:06:13 +0000760 || defined (BB_MKFIFO) || defined (BB_MKNOD) || defined (BB_AR)
Eric Andersence8f3b91999-10-20 07:03:36 +0000761/* [ugoa]{+|-|=}[rwxst] */
Erik Andersen23dea9b2000-05-13 00:28:25 +0000762
763
764
Erik Andersene49d5ec2000-02-08 19:58:47 +0000765extern int parse_mode(const char *s, mode_t * theMode)
Eric Andersenf6be9441999-10-13 21:12:06 +0000766{
Erik Andersene49d5ec2000-02-08 19:58:47 +0000767 mode_t andMode =
768
769 S_ISVTX | S_ISUID | S_ISGID | S_IRWXU | S_IRWXG | S_IRWXO;
Eric Andersence8f3b91999-10-20 07:03:36 +0000770 mode_t orMode = 0;
Erik Andersene49d5ec2000-02-08 19:58:47 +0000771 mode_t mode = 0;
772 mode_t groups = 0;
773 char type;
774 char c;
Eric Andersenf6be9441999-10-13 21:12:06 +0000775
Eric Andersen4e61db22000-09-01 00:06:17 +0000776 if (s==NULL)
777 return (FALSE);
778
Eric Andersenf6be9441999-10-13 21:12:06 +0000779 do {
Erik Andersene49d5ec2000-02-08 19:58:47 +0000780 for (;;) {
781 switch (c = *s++) {
Eric Andersenf6be9441999-10-13 21:12:06 +0000782 case '\0':
Eric Andersence8f3b91999-10-20 07:03:36 +0000783 return -1;
Eric Andersenf6be9441999-10-13 21:12:06 +0000784 case 'u':
Erik Andersene49d5ec2000-02-08 19:58:47 +0000785 groups |= S_ISUID | S_IRWXU;
Eric Andersenf6be9441999-10-13 21:12:06 +0000786 continue;
787 case 'g':
Erik Andersene49d5ec2000-02-08 19:58:47 +0000788 groups |= S_ISGID | S_IRWXG;
Eric Andersenf6be9441999-10-13 21:12:06 +0000789 continue;
790 case 'o':
791 groups |= S_IRWXO;
792 continue;
793 case 'a':
Erik Andersene49d5ec2000-02-08 19:58:47 +0000794 groups |= S_ISUID | S_ISGID | S_IRWXU | S_IRWXG | S_IRWXO;
Eric Andersenf6be9441999-10-13 21:12:06 +0000795 continue;
796 case '+':
797 case '=':
798 case '-':
799 type = c;
Erik Andersene49d5ec2000-02-08 19:58:47 +0000800 if (groups == 0) /* The default is "all" */
801 groups |=
802 S_ISUID | S_ISGID | S_IRWXU | S_IRWXG | S_IRWXO;
Eric Andersenf6be9441999-10-13 21:12:06 +0000803 break;
804 default:
Erik Andersene49d5ec2000-02-08 19:58:47 +0000805 if (isdigit(c) && c >= '0' && c <= '7' &&
806 mode == 0 && groups == 0) {
Eric Andersenfa0540f1999-10-22 18:18:31 +0000807 *theMode = strtol(--s, NULL, 8);
Eric Andersenf6be9441999-10-13 21:12:06 +0000808 return (TRUE);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000809 } else
Eric Andersenf6be9441999-10-13 21:12:06 +0000810 return (FALSE);
811 }
812 break;
813 }
814
Erik Andersene49d5ec2000-02-08 19:58:47 +0000815 while ((c = *s++) != '\0') {
816 switch (c) {
Eric Andersenf6be9441999-10-13 21:12:06 +0000817 case ',':
818 break;
819 case 'r':
Erik Andersene49d5ec2000-02-08 19:58:47 +0000820 mode |= S_IRUSR | S_IRGRP | S_IROTH;
Eric Andersenf6be9441999-10-13 21:12:06 +0000821 continue;
822 case 'w':
Erik Andersene49d5ec2000-02-08 19:58:47 +0000823 mode |= S_IWUSR | S_IWGRP | S_IWOTH;
Eric Andersenf6be9441999-10-13 21:12:06 +0000824 continue;
825 case 'x':
Erik Andersene49d5ec2000-02-08 19:58:47 +0000826 mode |= S_IXUSR | S_IXGRP | S_IXOTH;
Eric Andersenf6be9441999-10-13 21:12:06 +0000827 continue;
828 case 's':
Erik Andersene49d5ec2000-02-08 19:58:47 +0000829 mode |= S_IXGRP | S_ISUID | S_ISGID;
Eric Andersenf6be9441999-10-13 21:12:06 +0000830 continue;
831 case 't':
Eric Andersence8f3b91999-10-20 07:03:36 +0000832 mode |= 0;
Eric Andersenf6be9441999-10-13 21:12:06 +0000833 continue;
834 default:
Eric Andersence8f3b91999-10-20 07:03:36 +0000835 *theMode &= andMode;
836 *theMode |= orMode;
Erik Andersene49d5ec2000-02-08 19:58:47 +0000837 return (TRUE);
Eric Andersenf6be9441999-10-13 21:12:06 +0000838 }
839 break;
840 }
Erik Andersene49d5ec2000-02-08 19:58:47 +0000841 switch (type) {
Eric Andersenf6be9441999-10-13 21:12:06 +0000842 case '=':
Eric Andersence8f3b91999-10-20 07:03:36 +0000843 andMode &= ~(groups);
Eric Andersenf6be9441999-10-13 21:12:06 +0000844 /* fall through */
845 case '+':
Eric Andersence8f3b91999-10-20 07:03:36 +0000846 orMode |= mode & groups;
Eric Andersenf6be9441999-10-13 21:12:06 +0000847 break;
848 case '-':
Eric Andersence8f3b91999-10-20 07:03:36 +0000849 andMode &= ~(mode & groups);
850 orMode &= andMode;
Eric Andersenf6be9441999-10-13 21:12:06 +0000851 break;
852 }
Erik Andersene49d5ec2000-02-08 19:58:47 +0000853 } while (c == ',');
Eric Andersence8f3b91999-10-20 07:03:36 +0000854 *theMode &= andMode;
855 *theMode |= orMode;
Eric Andersenf6be9441999-10-13 21:12:06 +0000856 return (TRUE);
857}
Eric Andersence8f3b91999-10-20 07:03:36 +0000858
859
Pavel Roskin21ddb382000-07-17 19:31:54 +0000860#endif
861/* BB_CHMOD_CHOWN_CHGRP || BB_MKDIR || BB_MKFIFO || BB_MKNOD */
Eric Andersenf6be9441999-10-13 21:12:06 +0000862
Eric Andersene674eb71999-10-19 20:52:57 +0000863
864
Erik Andersen23dea9b2000-05-13 00:28:25 +0000865
866
Pavel Roskin21ddb382000-07-17 19:31:54 +0000867#if defined BB_CHMOD_CHOWN_CHGRP || defined BB_PS || defined BB_LS \
868 || defined BB_TAR || defined BB_ID || defined BB_LOGGER \
Eric Andersena2d61e72000-12-12 16:55:56 +0000869 || defined BB_LOGNAME || defined BB_WHOAMI || defined BB_SH
Erik Andersen23dea9b2000-05-13 00:28:25 +0000870
Erik Andersen94f5e0b2000-05-01 19:10:52 +0000871/* This parses entries in /etc/passwd and /etc/group. This is desirable
872 * for BusyBox, since we want to avoid using the glibc NSS stuff, which
873 * increases target size and is often not needed or wanted for embedded
874 * systems.
875 *
876 * /etc/passwd entries look like this:
877 * root:x:0:0:root:/root:/bin/bash
878 * and /etc/group entries look like this:
879 * root:x:0:
880 *
881 * This uses buf as storage to hold things.
882 *
883 */
Eric Andersenfad04fd2000-07-14 06:49:52 +0000884unsigned long my_getid(const char *filename, char *name, long id, long *gid)
Eric Andersend23f9ba1999-10-20 19:18:15 +0000885{
Eric Andersenaa0765e1999-10-22 04:30:20 +0000886 FILE *file;
Eric Andersend23f9ba1999-10-20 19:18:15 +0000887 char *rname, *start, *end, buf[128];
Eric Andersenfad04fd2000-07-14 06:49:52 +0000888 long rid;
889 long rgid = 0;
Eric Andersend23f9ba1999-10-20 19:18:15 +0000890
Erik Andersene49d5ec2000-02-08 19:58:47 +0000891 file = fopen(filename, "r");
Eric Andersenaa0765e1999-10-22 04:30:20 +0000892 if (file == NULL) {
Eric Andersen3199bda2000-06-02 17:38:18 +0000893 /* Do not complain. It is ok for /etc/passwd and
Erik Andersen330fd2b2000-05-19 05:35:19 +0000894 * friends to be missing... */
Erik Andersene49d5ec2000-02-08 19:58:47 +0000895 return (-1);
Eric Andersenaa0765e1999-10-22 04:30:20 +0000896 }
Eric Andersend23f9ba1999-10-20 19:18:15 +0000897
Erik Andersene49d5ec2000-02-08 19:58:47 +0000898 while (fgets(buf, 128, file) != NULL) {
Eric Andersend23f9ba1999-10-20 19:18:15 +0000899 if (buf[0] == '#')
900 continue;
901
Erik Andersen94f5e0b2000-05-01 19:10:52 +0000902 /* username/group name */
Eric Andersend23f9ba1999-10-20 19:18:15 +0000903 start = buf;
Erik Andersene49d5ec2000-02-08 19:58:47 +0000904 end = strchr(start, ':');
Eric Andersend23f9ba1999-10-20 19:18:15 +0000905 if (end == NULL)
906 continue;
907 *end = '\0';
908 rname = start;
909
Erik Andersen94f5e0b2000-05-01 19:10:52 +0000910 /* password */
Eric Andersend23f9ba1999-10-20 19:18:15 +0000911 start = end + 1;
Erik Andersene49d5ec2000-02-08 19:58:47 +0000912 end = strchr(start, ':');
Eric Andersend23f9ba1999-10-20 19:18:15 +0000913 if (end == NULL)
914 continue;
915
Erik Andersen94f5e0b2000-05-01 19:10:52 +0000916 /* uid in passwd, gid in group */
Eric Andersend23f9ba1999-10-20 19:18:15 +0000917 start = end + 1;
Erik Andersen5b46d792000-05-17 05:24:24 +0000918 rid = (unsigned long) strtol(start, &end, 10);
Eric Andersend23f9ba1999-10-20 19:18:15 +0000919 if (end == start)
920 continue;
921
Erik Andersen94f5e0b2000-05-01 19:10:52 +0000922 /* gid in passwd */
923 start = end + 1;
Erik Andersen5b46d792000-05-17 05:24:24 +0000924 rgid = (unsigned long) strtol(start, &end, 10);
Erik Andersen94f5e0b2000-05-01 19:10:52 +0000925
Eric Andersend23f9ba1999-10-20 19:18:15 +0000926 if (name) {
Erik Andersene49d5ec2000-02-08 19:58:47 +0000927 if (0 == strcmp(rname, name)) {
Erik Andersen94f5e0b2000-05-01 19:10:52 +0000928 if (gid) *gid = rgid;
Erik Andersene49d5ec2000-02-08 19:58:47 +0000929 fclose(file);
930 return (rid);
931 }
932 }
933 if (id != -1 && id == rid) {
934 strncpy(name, rname, 8);
Eric Andersen2d6282b2000-12-11 20:33:46 +0000935 name[8]='\0';
Erik Andersen94f5e0b2000-05-01 19:10:52 +0000936 if (gid) *gid = rgid;
Erik Andersene49d5ec2000-02-08 19:58:47 +0000937 fclose(file);
938 return (TRUE);
Eric Andersend23f9ba1999-10-20 19:18:15 +0000939 }
940 }
Eric Andersenaa0765e1999-10-22 04:30:20 +0000941 fclose(file);
Eric Andersend23f9ba1999-10-20 19:18:15 +0000942 return (-1);
943}
944
Erik Andersen94f5e0b2000-05-01 19:10:52 +0000945/* returns a uid given a username */
Eric Andersenfad04fd2000-07-14 06:49:52 +0000946long my_getpwnam(char *name)
Eric Andersend23f9ba1999-10-20 19:18:15 +0000947{
Erik Andersen94f5e0b2000-05-01 19:10:52 +0000948 return my_getid("/etc/passwd", name, -1, NULL);
Eric Andersend23f9ba1999-10-20 19:18:15 +0000949}
950
Erik Andersen94f5e0b2000-05-01 19:10:52 +0000951/* returns a gid given a group name */
Eric Andersenfad04fd2000-07-14 06:49:52 +0000952long my_getgrnam(char *name)
Eric Andersend23f9ba1999-10-20 19:18:15 +0000953{
Erik Andersen94f5e0b2000-05-01 19:10:52 +0000954 return my_getid("/etc/group", name, -1, NULL);
Eric Andersend23f9ba1999-10-20 19:18:15 +0000955}
956
Erik Andersen94f5e0b2000-05-01 19:10:52 +0000957/* gets a username given a uid */
Eric Andersenfad04fd2000-07-14 06:49:52 +0000958void my_getpwuid(char *name, long uid)
Eric Andersend23f9ba1999-10-20 19:18:15 +0000959{
Eric Andersenbd193a42000-12-13 01:52:39 +0000960 name[0] = '\0';
Erik Andersen94f5e0b2000-05-01 19:10:52 +0000961 my_getid("/etc/passwd", name, uid, NULL);
Eric Andersend23f9ba1999-10-20 19:18:15 +0000962}
963
Erik Andersen94f5e0b2000-05-01 19:10:52 +0000964/* gets a groupname given a gid */
Eric Andersenfad04fd2000-07-14 06:49:52 +0000965void my_getgrgid(char *group, long gid)
Eric Andersend23f9ba1999-10-20 19:18:15 +0000966{
Eric Andersenbd193a42000-12-13 01:52:39 +0000967 group[0] = '\0';
Erik Andersen94f5e0b2000-05-01 19:10:52 +0000968 my_getid("/etc/group", group, gid, NULL);
Eric Andersend23f9ba1999-10-20 19:18:15 +0000969}
970
Erik Andersen94f5e0b2000-05-01 19:10:52 +0000971/* gets a gid given a user name */
Eric Andersenfad04fd2000-07-14 06:49:52 +0000972long my_getpwnamegid(char *name)
Erik Andersen94f5e0b2000-05-01 19:10:52 +0000973{
Eric Andersenfad04fd2000-07-14 06:49:52 +0000974 long gid;
Erik Andersen94f5e0b2000-05-01 19:10:52 +0000975 my_getid("/etc/passwd", name, -1, &gid);
976 return gid;
977}
Eric Andersend23f9ba1999-10-20 19:18:15 +0000978
Pavel Roskin21ddb382000-07-17 19:31:54 +0000979#endif
980 /* BB_CHMOD_CHOWN_CHGRP || BB_PS || BB_LS || BB_TAR \
981 || BB_ID || BB_LOGGER || BB_LOGNAME || BB_WHOAMI */
Erik Andersen23dea9b2000-05-13 00:28:25 +0000982
983
Eric Andersenf86aee72000-07-06 17:20:46 +0000984#if (defined BB_CHVT) || (defined BB_DEALLOCVT) || (defined BB_SETKEYCODES)
Eric Andersen0460ff21999-10-25 23:32:44 +0000985
Eric Andersenbd22ed82000-07-08 18:55:24 +0000986/* From <linux/kd.h> */
987#define KDGKBTYPE 0x4B33 /* get keyboard type */
988#define KB_84 0x01
989#define KB_101 0x02 /* this is what we always answer */
Eric Andersen0460ff21999-10-25 23:32:44 +0000990
Erik Andersene49d5ec2000-02-08 19:58:47 +0000991int is_a_console(int fd)
Eric Andersen0460ff21999-10-25 23:32:44 +0000992{
Erik Andersene49d5ec2000-02-08 19:58:47 +0000993 char arg;
994
995 arg = 0;
996 return (ioctl(fd, KDGKBTYPE, &arg) == 0
997 && ((arg == KB_101) || (arg == KB_84)));
Eric Andersen0460ff21999-10-25 23:32:44 +0000998}
999
Erik Andersene49d5ec2000-02-08 19:58:47 +00001000static int open_a_console(char *fnam)
Eric Andersen0460ff21999-10-25 23:32:44 +00001001{
Erik Andersene49d5ec2000-02-08 19:58:47 +00001002 int fd;
1003
1004 /* try read-only */
1005 fd = open(fnam, O_RDWR);
1006
1007 /* if failed, try read-only */
1008 if (fd < 0 && errno == EACCES)
1009 fd = open(fnam, O_RDONLY);
1010
1011 /* if failed, try write-only */
1012 if (fd < 0 && errno == EACCES)
1013 fd = open(fnam, O_WRONLY);
1014
1015 /* if failed, fail */
1016 if (fd < 0)
1017 return -1;
1018
1019 /* if not a console, fail */
1020 if (!is_a_console(fd)) {
1021 close(fd);
1022 return -1;
1023 }
1024
1025 /* success */
1026 return fd;
Eric Andersen0460ff21999-10-25 23:32:44 +00001027}
1028
1029/*
1030 * Get an fd for use with kbd/console ioctls.
1031 * We try several things because opening /dev/console will fail
1032 * if someone else used X (which does a chown on /dev/console).
1033 *
1034 * if tty_name is non-NULL, try this one instead.
1035 */
1036
Erik Andersene49d5ec2000-02-08 19:58:47 +00001037int get_console_fd(char *tty_name)
Eric Andersen0460ff21999-10-25 23:32:44 +00001038{
Erik Andersene49d5ec2000-02-08 19:58:47 +00001039 int fd;
Eric Andersen0460ff21999-10-25 23:32:44 +00001040
Erik Andersene49d5ec2000-02-08 19:58:47 +00001041 if (tty_name) {
1042 if (-1 == (fd = open_a_console(tty_name)))
1043 return -1;
1044 else
1045 return fd;
1046 }
1047
1048 fd = open_a_console("/dev/tty");
1049 if (fd >= 0)
1050 return fd;
1051
1052 fd = open_a_console("/dev/tty0");
1053 if (fd >= 0)
1054 return fd;
1055
1056 fd = open_a_console("/dev/console");
1057 if (fd >= 0)
1058 return fd;
1059
1060 for (fd = 0; fd < 3; fd++)
1061 if (is_a_console(fd))
1062 return fd;
1063
Mark Whitleyf57c9442000-12-07 19:56:48 +00001064 error_msg("Couldnt get a file descriptor referring to the console\n");
Erik Andersene49d5ec2000-02-08 19:58:47 +00001065 return -1; /* total failure */
Eric Andersen0460ff21999-10-25 23:32:44 +00001066}
1067
1068
Eric Andersenf86aee72000-07-06 17:20:46 +00001069#endif /* BB_CHVT || BB_DEALLOCVT || BB_SETKEYCODES */
Eric Andersen0460ff21999-10-25 23:32:44 +00001070
1071
Eric Andersen9f16d612000-06-12 23:11:16 +00001072#if defined BB_FIND || defined BB_INSMOD
Eric Andersenb186d981999-12-03 09:19:54 +00001073/*
1074 * Routine to see if a text string is matched by a wildcard pattern.
1075 * Returns TRUE if the text is matched, or FALSE if it is not matched
1076 * or if the pattern is invalid.
1077 * * matches zero or more characters
1078 * ? matches a single character
1079 * [abc] matches 'a', 'b' or 'c'
1080 * \c quotes character c
1081 * Adapted from code written by Ingo Wilken, and
1082 * then taken from sash, Copyright (c) 1999 by David I. Bell
1083 * Permission is granted to use, distribute, or modify this source,
1084 * provided that this copyright notice remains intact.
1085 * Permission to distribute this code under the GPL has been granted.
1086 */
Erik Andersene49d5ec2000-02-08 19:58:47 +00001087extern int check_wildcard_match(const char *text, const char *pattern)
Eric Andersenb186d981999-12-03 09:19:54 +00001088{
Erik Andersene49d5ec2000-02-08 19:58:47 +00001089 const char *retryPat;
1090 const char *retryText;
1091 int ch;
1092 int found;
Erik Andersen632bb572000-04-18 22:09:06 +00001093 int len;
Eric Andersenb186d981999-12-03 09:19:54 +00001094
Erik Andersene49d5ec2000-02-08 19:58:47 +00001095 retryPat = NULL;
1096 retryText = NULL;
Eric Andersenb186d981999-12-03 09:19:54 +00001097
Erik Andersene49d5ec2000-02-08 19:58:47 +00001098 while (*text || *pattern) {
Eric Andersenb186d981999-12-03 09:19:54 +00001099 ch = *pattern++;
1100
Erik Andersene49d5ec2000-02-08 19:58:47 +00001101 switch (ch) {
1102 case '*':
1103 retryPat = pattern;
1104 retryText = text;
1105 break;
1106
1107 case '[':
1108 found = FALSE;
1109
1110 while ((ch = *pattern++) != ']') {
1111 if (ch == '\\')
1112 ch = *pattern++;
1113
1114 if (ch == '\0')
1115 return FALSE;
1116
1117 if (*text == ch)
1118 found = TRUE;
1119 }
Erik Andersen632bb572000-04-18 22:09:06 +00001120 len=strlen(text);
1121 if (found == FALSE && len!=0) {
1122 return FALSE;
1123 }
Erik Andersene49d5ec2000-02-08 19:58:47 +00001124 if (found == TRUE) {
Erik Andersen632bb572000-04-18 22:09:06 +00001125 if (strlen(pattern)==0 && len==1) {
1126 return TRUE;
1127 }
1128 if (len!=0) {
1129 text++;
1130 continue;
Erik Andersenc3660502000-04-18 21:18:57 +00001131 }
Erik Andersene49d5ec2000-02-08 19:58:47 +00001132 }
1133
1134 /* fall into next case */
1135
1136 case '?':
1137 if (*text++ == '\0')
1138 return FALSE;
1139
1140 break;
1141
1142 case '\\':
1143 ch = *pattern++;
1144
1145 if (ch == '\0')
1146 return FALSE;
1147
1148 /* fall into next case */
1149
1150 default:
1151 if (*text == ch) {
1152 if (*text)
1153 text++;
1154 break;
1155 }
1156
1157 if (*text) {
1158 pattern = retryPat;
1159 text = ++retryText;
1160 break;
1161 }
1162
Eric Andersenb186d981999-12-03 09:19:54 +00001163 return FALSE;
Eric Andersenb186d981999-12-03 09:19:54 +00001164 }
1165
Erik Andersene49d5ec2000-02-08 19:58:47 +00001166 if (pattern == NULL)
1167 return FALSE;
Eric Andersenb186d981999-12-03 09:19:54 +00001168 }
1169
Erik Andersene49d5ec2000-02-08 19:58:47 +00001170 return TRUE;
Eric Andersenb186d981999-12-03 09:19:54 +00001171}
Eric Andersen9f16d612000-06-12 23:11:16 +00001172#endif /* BB_FIND || BB_INSMOD */
Eric Andersenb186d981999-12-03 09:19:54 +00001173
1174
Eric Andersen29d2e361999-11-06 06:07:27 +00001175
1176
Erik Andersen23dea9b2000-05-13 00:28:25 +00001177#if defined BB_DF || defined BB_MTAB
Eric Andersen29d2e361999-11-06 06:07:27 +00001178/*
1179 * Given a block device, find the mount table entry if that block device
1180 * is mounted.
1181 *
1182 * Given any other file (or directory), find the mount table entry for its
1183 * filesystem.
1184 */
Mark Whitleyf57c9442000-12-07 19:56:48 +00001185extern struct mntent *find_mount_point(const char *name, const char *table)
Eric Andersen29d2e361999-11-06 06:07:27 +00001186{
Erik Andersene49d5ec2000-02-08 19:58:47 +00001187 struct stat s;
1188 dev_t mountDevice;
1189 FILE *mountTable;
1190 struct mntent *mountEntry;
Eric Andersen29d2e361999-11-06 06:07:27 +00001191
Erik Andersene49d5ec2000-02-08 19:58:47 +00001192 if (stat(name, &s) != 0)
1193 return 0;
Eric Andersen29d2e361999-11-06 06:07:27 +00001194
Erik Andersene49d5ec2000-02-08 19:58:47 +00001195 if ((s.st_mode & S_IFMT) == S_IFBLK)
1196 mountDevice = s.st_rdev;
1197 else
1198 mountDevice = s.st_dev;
Eric Andersen29d2e361999-11-06 06:07:27 +00001199
1200
Erik Andersene49d5ec2000-02-08 19:58:47 +00001201 if ((mountTable = setmntent(table, "r")) == 0)
1202 return 0;
Eric Andersen29d2e361999-11-06 06:07:27 +00001203
Erik Andersene49d5ec2000-02-08 19:58:47 +00001204 while ((mountEntry = getmntent(mountTable)) != 0) {
1205 if (strcmp(name, mountEntry->mnt_dir) == 0
1206 || strcmp(name, mountEntry->mnt_fsname) == 0) /* String match. */
1207 break;
1208 if (stat(mountEntry->mnt_fsname, &s) == 0 && s.st_rdev == mountDevice) /* Match the device. */
1209 break;
1210 if (stat(mountEntry->mnt_dir, &s) == 0 && s.st_dev == mountDevice) /* Match the directory's mount point. */
1211 break;
1212 }
1213 endmntent(mountTable);
1214 return mountEntry;
Eric Andersen29d2e361999-11-06 06:07:27 +00001215}
Erik Andersen23dea9b2000-05-13 00:28:25 +00001216#endif /* BB_DF || BB_MTAB */
Eric Andersen29d2e361999-11-06 06:07:27 +00001217
1218
1219
Erik Andersen23dea9b2000-05-13 00:28:25 +00001220#if defined BB_DD || defined BB_TAIL
Eric Andersen1792f8c1999-12-09 06:11:36 +00001221/*
1222 * Read a number with a possible multiplier.
1223 * Returns -1 if the number format is illegal.
1224 */
Mark Whitleyf57c9442000-12-07 19:56:48 +00001225extern long atoi_w_units(const char *cp)
Eric Andersen1792f8c1999-12-09 06:11:36 +00001226{
Erik Andersene49d5ec2000-02-08 19:58:47 +00001227 long value;
Eric Andersen1792f8c1999-12-09 06:11:36 +00001228
Mark Whitleyf57c9442000-12-07 19:56:48 +00001229 if (!is_decimal(*cp))
Erik Andersene49d5ec2000-02-08 19:58:47 +00001230 return -1;
Eric Andersen1792f8c1999-12-09 06:11:36 +00001231
Erik Andersene49d5ec2000-02-08 19:58:47 +00001232 value = 0;
Eric Andersen1792f8c1999-12-09 06:11:36 +00001233
Mark Whitleyf57c9442000-12-07 19:56:48 +00001234 while (is_decimal(*cp))
Erik Andersene49d5ec2000-02-08 19:58:47 +00001235 value = value * 10 + *cp++ - '0';
Eric Andersen1792f8c1999-12-09 06:11:36 +00001236
Erik Andersene49d5ec2000-02-08 19:58:47 +00001237 switch (*cp++) {
1238 case 'M':
1239 case 'm': /* `tail' uses it traditionally */
1240 value *= 1048576;
1241 break;
Eric Andersen1792f8c1999-12-09 06:11:36 +00001242
Erik Andersene49d5ec2000-02-08 19:58:47 +00001243 case 'k':
1244 value *= 1024;
1245 break;
Eric Andersen1792f8c1999-12-09 06:11:36 +00001246
Erik Andersene49d5ec2000-02-08 19:58:47 +00001247 case 'b':
1248 value *= 512;
1249 break;
Eric Andersen1792f8c1999-12-09 06:11:36 +00001250
Erik Andersene49d5ec2000-02-08 19:58:47 +00001251 case 'w':
1252 value *= 2;
1253 break;
Eric Andersen1792f8c1999-12-09 06:11:36 +00001254
Erik Andersene49d5ec2000-02-08 19:58:47 +00001255 case '\0':
1256 return value;
1257
1258 default:
1259 return -1;
1260 }
1261
1262 if (*cp)
1263 return -1;
1264
Eric Andersen1792f8c1999-12-09 06:11:36 +00001265 return value;
Eric Andersen1792f8c1999-12-09 06:11:36 +00001266}
Erik Andersen23dea9b2000-05-13 00:28:25 +00001267#endif /* BB_DD || BB_TAIL */
Eric Andersen1792f8c1999-12-09 06:11:36 +00001268
Eric Andersen6805d5d1999-12-09 22:39:55 +00001269
Glenn L McGrath06aeb6c2000-08-25 03:50:10 +00001270#if defined BB_INIT || defined BB_SYSLOGD
Erik Andersen31cf8e02000-02-07 20:31:19 +00001271/* try to open up the specified device */
1272extern int device_open(char *device, int mode)
1273{
Erik Andersene49d5ec2000-02-08 19:58:47 +00001274 int m, f, fd = -1;
Erik Andersen31cf8e02000-02-07 20:31:19 +00001275
Erik Andersene49d5ec2000-02-08 19:58:47 +00001276 m = mode | O_NONBLOCK;
Erik Andersen31cf8e02000-02-07 20:31:19 +00001277
Erik Andersene49d5ec2000-02-08 19:58:47 +00001278 /* Retry up to 5 times */
1279 for (f = 0; f < 5; f++)
1280 if ((fd = open(device, m, 0600)) >= 0)
1281 break;
1282 if (fd < 0)
1283 return fd;
1284 /* Reset original flags. */
1285 if (m != mode)
1286 fcntl(fd, F_SETFL, mode);
Erik Andersen31cf8e02000-02-07 20:31:19 +00001287 return fd;
Erik Andersen31cf8e02000-02-07 20:31:19 +00001288}
Erik Andersen23dea9b2000-05-13 00:28:25 +00001289#endif /* BB_INIT BB_SYSLOGD */
Erik Andersen31cf8e02000-02-07 20:31:19 +00001290
1291
Erik Andersen23dea9b2000-05-13 00:28:25 +00001292#if defined BB_KILLALL || ( defined BB_FEATURE_LINUXRC && ( defined BB_HALT || defined BB_REBOOT || defined BB_POWEROFF ))
Erik Andersen269bba22000-03-08 14:50:47 +00001293#ifdef BB_FEATURE_USE_DEVPS_PATCH
Eric Andersenc674d702000-07-10 22:57:14 +00001294#include <linux/devps.h> /* For Erik's nifty devps device driver */
Erik Andersen23dea9b2000-05-13 00:28:25 +00001295#endif
Erik Andersen246cc6d2000-03-07 07:41:42 +00001296
Erik Andersen23dea9b2000-05-13 00:28:25 +00001297#if defined BB_FEATURE_USE_DEVPS_PATCH
Mark Whitleyf57c9442000-12-07 19:56:48 +00001298/* find_pid_by_name()
John Beppuf95ca971999-12-09 22:10:18 +00001299 *
Erik Andersen246cc6d2000-03-07 07:41:42 +00001300 * This finds the pid of the specified process,
1301 * by using the /dev/ps device driver.
John Beppuf95ca971999-12-09 22:10:18 +00001302 *
Erik Andersen825aead2000-04-07 06:00:07 +00001303 * Returns a list of all matching PIDs
John Beppuf95ca971999-12-09 22:10:18 +00001304 */
Mark Whitleyf57c9442000-12-07 19:56:48 +00001305extern pid_t* find_pid_by_name( char* pidName)
John Beppuf95ca971999-12-09 22:10:18 +00001306{
Erik Andersen825aead2000-04-07 06:00:07 +00001307 int fd, i, j;
Erik Andersen246cc6d2000-03-07 07:41:42 +00001308 char device[] = "/dev/ps";
Erik Andersen246cc6d2000-03-07 07:41:42 +00001309 pid_t num_pids;
1310 pid_t* pid_array = NULL;
Erik Andersen825aead2000-04-07 06:00:07 +00001311 pid_t* pidList=NULL;
Erik Andersen246cc6d2000-03-07 07:41:42 +00001312
1313 /* open device */
1314 fd = open(device, O_RDONLY);
1315 if (fd < 0)
Mark Whitleyf57c9442000-12-07 19:56:48 +00001316 error_msg_and_die( "open failed for `%s': %s\n", device, strerror (errno));
Erik Andersen246cc6d2000-03-07 07:41:42 +00001317
1318 /* Find out how many processes there are */
1319 if (ioctl (fd, DEVPS_GET_NUM_PIDS, &num_pids)<0)
Mark Whitleyf57c9442000-12-07 19:56:48 +00001320 error_msg_and_die( "\nDEVPS_GET_PID_LIST: %s\n", strerror (errno));
Erik Andersen246cc6d2000-03-07 07:41:42 +00001321
1322 /* Allocate some memory -- grab a few extras just in case
1323 * some new processes start up while we wait. The kernel will
1324 * just ignore any extras if we give it too many, and will trunc.
1325 * the list if we give it too few. */
Matt Kraai322ae932000-09-13 02:46:14 +00001326 pid_array = (pid_t*) xcalloc( num_pids+10, sizeof(pid_t));
Erik Andersen246cc6d2000-03-07 07:41:42 +00001327 pid_array[0] = num_pids+10;
1328
1329 /* Now grab the pid list */
1330 if (ioctl (fd, DEVPS_GET_PID_LIST, pid_array)<0)
Mark Whitleyf57c9442000-12-07 19:56:48 +00001331 error_msg_and_die( "\nDEVPS_GET_PID_LIST: %s\n", strerror (errno));
Erik Andersen246cc6d2000-03-07 07:41:42 +00001332
1333 /* Now search for a match */
Eric Andersenf86aee72000-07-06 17:20:46 +00001334 for (i=1, j=0; i<pid_array[0] ; i++) {
Erik Andersen0a64de92000-04-18 20:00:03 +00001335 char* p;
Erik Andersen246cc6d2000-03-07 07:41:42 +00001336 struct pid_info info;
1337
1338 info.pid = pid_array[i];
1339 if (ioctl (fd, DEVPS_GET_PID_INFO, &info)<0)
Mark Whitleyf57c9442000-12-07 19:56:48 +00001340 error_msg_and_die( "\nDEVPS_GET_PID_INFO: %s\n", strerror (errno));
Erik Andersen246cc6d2000-03-07 07:41:42 +00001341
Erik Andersen0a64de92000-04-18 20:00:03 +00001342 /* Make sure we only match on the process name */
1343 p=info.command_line+1;
1344 while ((*p != 0) && !isspace(*(p)) && (*(p-1) != '\\')) {
1345 (p)++;
1346 }
1347 if (isspace(*(p)))
1348 *p='\0';
1349
Erik Andersenb9167cb2000-04-18 22:41:30 +00001350 if ((strstr(info.command_line, pidName) != NULL)
1351 && (strlen(pidName) == strlen(info.command_line))) {
Matt Kraai322ae932000-09-13 02:46:14 +00001352 pidList=xrealloc( pidList, sizeof(pid_t) * (j+2));
Erik Andersen825aead2000-04-07 06:00:07 +00001353 pidList[j++]=info.pid;
Erik Andersen246cc6d2000-03-07 07:41:42 +00001354 }
1355 }
Erik Andersen0a64de92000-04-18 20:00:03 +00001356 if (pidList)
1357 pidList[j]=0;
Erik Andersen246cc6d2000-03-07 07:41:42 +00001358
1359 /* Free memory */
1360 free( pid_array);
1361
1362 /* close device */
1363 if (close (fd) != 0)
Mark Whitleyf57c9442000-12-07 19:56:48 +00001364 error_msg_and_die( "close failed for `%s': %s\n",device, strerror (errno));
Erik Andersen246cc6d2000-03-07 07:41:42 +00001365
Erik Andersen825aead2000-04-07 06:00:07 +00001366 return pidList;
Erik Andersen246cc6d2000-03-07 07:41:42 +00001367}
Erik Andersen269bba22000-03-08 14:50:47 +00001368#else /* BB_FEATURE_USE_DEVPS_PATCH */
Erik Andersen246cc6d2000-03-07 07:41:42 +00001369#if ! defined BB_FEATURE_USE_PROCFS
1370#error Sorry, I depend on the /proc filesystem right now.
1371#endif
Erik Andersen2ac2fae2000-03-07 23:32:17 +00001372
Mark Whitleyf57c9442000-12-07 19:56:48 +00001373/* find_pid_by_name()
Erik Andersen246cc6d2000-03-07 07:41:42 +00001374 *
1375 * This finds the pid of the specified process.
1376 * Currently, it's implemented by rummaging through
1377 * the proc filesystem.
1378 *
Erik Andersen825aead2000-04-07 06:00:07 +00001379 * Returns a list of all matching PIDs
Erik Andersen246cc6d2000-03-07 07:41:42 +00001380 */
Mark Whitleyf57c9442000-12-07 19:56:48 +00001381extern pid_t* find_pid_by_name( char* pidName)
Erik Andersen246cc6d2000-03-07 07:41:42 +00001382{
Erik Andersen2ac2fae2000-03-07 23:32:17 +00001383 DIR *dir;
1384 struct dirent *next;
Erik Andersen825aead2000-04-07 06:00:07 +00001385 pid_t* pidList=NULL;
1386 int i=0;
John Beppuf95ca971999-12-09 22:10:18 +00001387
Erik Andersen2ac2fae2000-03-07 23:32:17 +00001388 dir = opendir("/proc");
1389 if (!dir)
Mark Whitleyf57c9442000-12-07 19:56:48 +00001390 error_msg_and_die( "Cannot open /proc: %s\n", strerror (errno));
Erik Andersen2ac2fae2000-03-07 23:32:17 +00001391
1392 while ((next = readdir(dir)) != NULL) {
Erik Andersene49d5ec2000-02-08 19:58:47 +00001393 FILE *status;
Erik Andersen2ac2fae2000-03-07 23:32:17 +00001394 char filename[256];
1395 char buffer[256];
John Beppuf95ca971999-12-09 22:10:18 +00001396
Erik Andersen2ac2fae2000-03-07 23:32:17 +00001397 /* If it isn't a number, we don't want it */
1398 if (!isdigit(*next->d_name))
1399 continue;
1400
Eric Andersen31e68292000-09-14 21:12:20 +00001401 sprintf(filename, "/proc/%s/cmdline", next->d_name);
Erik Andersene49d5ec2000-02-08 19:58:47 +00001402 status = fopen(filename, "r");
1403 if (!status) {
1404 continue;
1405 }
1406 fgets(buffer, 256, status);
1407 fclose(status);
John Beppuf95ca971999-12-09 22:10:18 +00001408
Eric Andersen31e68292000-09-14 21:12:20 +00001409 if (strstr(get_last_path_component(buffer), pidName) != NULL) {
Matt Kraai322ae932000-09-13 02:46:14 +00001410 pidList=xrealloc( pidList, sizeof(pid_t) * (i+2));
Erik Andersen825aead2000-04-07 06:00:07 +00001411 pidList[i++]=strtol(next->d_name, NULL, 0);
Erik Andersene49d5ec2000-02-08 19:58:47 +00001412 }
John Beppuf95ca971999-12-09 22:10:18 +00001413 }
Eric Andersen31e68292000-09-14 21:12:20 +00001414
Erik Andersen0a64de92000-04-18 20:00:03 +00001415 if (pidList)
Erik Andersena6c75222000-04-18 00:00:52 +00001416 pidList[i]=0;
Erik Andersen825aead2000-04-07 06:00:07 +00001417 return pidList;
John Beppuf95ca971999-12-09 22:10:18 +00001418}
Erik Andersen269bba22000-03-08 14:50:47 +00001419#endif /* BB_FEATURE_USE_DEVPS_PATCH */
Erik Andersen23dea9b2000-05-13 00:28:25 +00001420#endif /* BB_KILLALL || ( BB_FEATURE_LINUXRC && ( BB_HALT || BB_REBOOT || BB_POWEROFF )) */
Eric Andersen1792f8c1999-12-09 06:11:36 +00001421
Eric Andersenae6eae02000-07-19 17:35:54 +00001422#ifndef DMALLOC
Erik Andersen0d068a22000-03-21 22:32:57 +00001423/* this should really be farmed out to libbusybox.a */
Erik Andersene49d5ec2000-02-08 19:58:47 +00001424extern void *xmalloc(size_t size)
Erik Andersen3fe39dc2000-01-25 18:13:53 +00001425{
Eric Andersenae6eae02000-07-19 17:35:54 +00001426 void *ptr = malloc(size);
Erik Andersen3fe39dc2000-01-25 18:13:53 +00001427
Eric Andersenae6eae02000-07-19 17:35:54 +00001428 if (!ptr)
Mark Whitleyf57c9442000-12-07 19:56:48 +00001429 error_msg_and_die(memory_exhausted);
Eric Andersenae6eae02000-07-19 17:35:54 +00001430 return ptr;
Erik Andersen3fe39dc2000-01-25 18:13:53 +00001431}
1432
Eric Andersen501c88b2000-07-28 15:14:45 +00001433extern void *xrealloc(void *old, size_t size)
Eric Andersenae6eae02000-07-19 17:35:54 +00001434{
1435 void *ptr = realloc(old, size);
1436 if (!ptr)
Mark Whitleyf57c9442000-12-07 19:56:48 +00001437 error_msg_and_die(memory_exhausted);
Eric Andersenae6eae02000-07-19 17:35:54 +00001438 return ptr;
1439}
Eric Andersen501c88b2000-07-28 15:14:45 +00001440
1441extern void *xcalloc(size_t nmemb, size_t size)
1442{
1443 void *ptr = calloc(nmemb, size);
1444 if (!ptr)
Mark Whitleyf57c9442000-12-07 19:56:48 +00001445 error_msg_and_die(memory_exhausted);
Eric Andersen501c88b2000-07-28 15:14:45 +00001446 return ptr;
1447}
Eric Andersenae6eae02000-07-19 17:35:54 +00001448#endif
1449
Eric Andersenf3b2b522000-12-07 22:42:11 +00001450#if defined BB_FEATURE_NFSMOUNT || defined BB_LS || defined BB_SH || defined BB_WGET
Eric Andersenae6eae02000-07-19 17:35:54 +00001451# ifndef DMALLOC
Eric Andersenda1d1e72000-07-10 23:39:44 +00001452extern char * xstrdup (const char *s) {
1453 char *t;
1454
1455 if (s == NULL)
1456 return NULL;
1457
1458 t = strdup (s);
1459
1460 if (t == NULL)
Mark Whitleyf57c9442000-12-07 19:56:48 +00001461 error_msg_and_die(memory_exhausted);
Eric Andersenda1d1e72000-07-10 23:39:44 +00001462
1463 return t;
1464}
Eric Andersenae6eae02000-07-19 17:35:54 +00001465# endif
Matt Kraai88cc3052000-08-26 16:52:28 +00001466#endif
Eric Andersenda1d1e72000-07-10 23:39:44 +00001467
Matt Kraai88cc3052000-08-26 16:52:28 +00001468#if defined BB_FEATURE_NFSMOUNT
Eric Andersenda1d1e72000-07-10 23:39:44 +00001469extern char * xstrndup (const char *s, int n) {
1470 char *t;
1471
1472 if (s == NULL)
Mark Whitleyf57c9442000-12-07 19:56:48 +00001473 error_msg_and_die("xstrndup bug");
Eric Andersenda1d1e72000-07-10 23:39:44 +00001474
1475 t = xmalloc(n+1);
1476 strncpy(t,s,n);
1477 t[n] = 0;
1478
1479 return t;
1480}
1481#endif
1482
1483
Erik Andersen23dea9b2000-05-13 00:28:25 +00001484#if (__GLIBC__ < 2) && (defined BB_SYSLOGD || defined BB_INIT)
Erik Andersen7dc16072000-01-04 01:10:25 +00001485extern int vdprintf(int d, const char *format, va_list ap)
1486{
Erik Andersene49d5ec2000-02-08 19:58:47 +00001487 char buf[BUF_SIZE];
1488 int len;
Erik Andersen7dc16072000-01-04 01:10:25 +00001489
Erik Andersene49d5ec2000-02-08 19:58:47 +00001490 len = vsprintf(buf, format, ap);
1491 return write(d, buf, len);
Erik Andersen7dc16072000-01-04 01:10:25 +00001492}
Erik Andersen23dea9b2000-05-13 00:28:25 +00001493#endif /* BB_SYSLOGD */
Erik Andersen7dc16072000-01-04 01:10:25 +00001494
Eric Andersen624cc772000-09-21 02:04:51 +00001495
Erik Andersen23dea9b2000-05-13 00:28:25 +00001496#if defined BB_FEATURE_MOUNT_LOOP
Eric Andersen624cc772000-09-21 02:04:51 +00001497#include <fcntl.h>
1498#include "loop.h" /* Pull in loop device support */
1499
Erik Andersen5cbdd712000-01-26 20:06:48 +00001500extern int del_loop(const char *device)
1501{
Erik Andersene49d5ec2000-02-08 19:58:47 +00001502 int fd;
Erik Andersen5cbdd712000-01-26 20:06:48 +00001503
Erik Andersene49d5ec2000-02-08 19:58:47 +00001504 if ((fd = open(device, O_RDONLY)) < 0) {
1505 perror(device);
1506 return (FALSE);
1507 }
1508 if (ioctl(fd, LOOP_CLR_FD, 0) < 0) {
1509 perror("ioctl: LOOP_CLR_FD");
1510 return (FALSE);
1511 }
1512 close(fd);
1513 return (TRUE);
Erik Andersen5cbdd712000-01-26 20:06:48 +00001514}
Erik Andersende7965c2000-01-26 23:49:21 +00001515
Erik Andersene49d5ec2000-02-08 19:58:47 +00001516extern int set_loop(const char *device, const char *file, int offset,
1517 int *loopro)
Erik Andersende7965c2000-01-26 23:49:21 +00001518{
1519 struct loop_info loopinfo;
Erik Andersene49d5ec2000-02-08 19:58:47 +00001520 int fd, ffd, mode;
1521
Erik Andersende7965c2000-01-26 23:49:21 +00001522 mode = *loopro ? O_RDONLY : O_RDWR;
Erik Andersene49d5ec2000-02-08 19:58:47 +00001523 if ((ffd = open(file, mode)) < 0 && !*loopro
1524 && (errno != EROFS || (ffd = open(file, mode = O_RDONLY)) < 0)) {
1525 perror(file);
1526 return 1;
Erik Andersende7965c2000-01-26 23:49:21 +00001527 }
Erik Andersene49d5ec2000-02-08 19:58:47 +00001528 if ((fd = open(device, mode)) < 0) {
1529 close(ffd);
1530 perror(device);
1531 return 1;
Erik Andersende7965c2000-01-26 23:49:21 +00001532 }
1533 *loopro = (mode == O_RDONLY);
1534
1535 memset(&loopinfo, 0, sizeof(loopinfo));
1536 strncpy(loopinfo.lo_name, file, LO_NAME_SIZE);
Erik Andersene49d5ec2000-02-08 19:58:47 +00001537 loopinfo.lo_name[LO_NAME_SIZE - 1] = 0;
Erik Andersende7965c2000-01-26 23:49:21 +00001538
1539 loopinfo.lo_offset = offset;
1540
1541 loopinfo.lo_encrypt_key_size = 0;
1542 if (ioctl(fd, LOOP_SET_FD, ffd) < 0) {
1543 perror("ioctl: LOOP_SET_FD");
1544 close(fd);
1545 close(ffd);
1546 return 1;
1547 }
1548 if (ioctl(fd, LOOP_SET_STATUS, &loopinfo) < 0) {
1549 (void) ioctl(fd, LOOP_CLR_FD, 0);
1550 perror("ioctl: LOOP_SET_STATUS");
1551 close(fd);
1552 close(ffd);
1553 return 1;
1554 }
1555 close(fd);
1556 close(ffd);
1557 return 0;
1558}
1559
Erik Andersene49d5ec2000-02-08 19:58:47 +00001560extern char *find_unused_loop_device(void)
Erik Andersende7965c2000-01-26 23:49:21 +00001561{
1562 char dev[20];
1563 int i, fd;
1564 struct stat statbuf;
1565 struct loop_info loopinfo;
1566
Erik Andersene49d5ec2000-02-08 19:58:47 +00001567 for (i = 0; i <= 7; i++) {
1568 sprintf(dev, "/dev/loop%d", i);
1569 if (stat(dev, &statbuf) == 0 && S_ISBLK(statbuf.st_mode)) {
1570 if ((fd = open(dev, O_RDONLY)) >= 0) {
1571 if (ioctl(fd, LOOP_GET_STATUS, &loopinfo) == -1) {
1572 if (errno == ENXIO) { /* probably free */
1573 close(fd);
1574 return strdup(dev);
1575 }
1576 }
1577 close(fd);
Erik Andersende7965c2000-01-26 23:49:21 +00001578 }
Erik Andersende7965c2000-01-26 23:49:21 +00001579 }
Erik Andersende7965c2000-01-26 23:49:21 +00001580 }
Erik Andersene49d5ec2000-02-08 19:58:47 +00001581 return NULL;
Erik Andersende7965c2000-01-26 23:49:21 +00001582}
Erik Andersen23dea9b2000-05-13 00:28:25 +00001583#endif /* BB_FEATURE_MOUNT_LOOP */
Erik Andersende7965c2000-01-26 23:49:21 +00001584
Erik Andersen23dea9b2000-05-13 00:28:25 +00001585#if defined BB_MOUNT || defined BB_DF || ( defined BB_UMOUNT && ! defined BB_MTAB)
Erik Andersenec5bd902000-03-22 07:12:05 +00001586extern int find_real_root_device_name(char* name)
Erik Andersen016ffe92000-03-22 00:58:54 +00001587{
Erik Andersen016ffe92000-03-22 00:58:54 +00001588 DIR *dir;
1589 struct dirent *entry;
1590 struct stat statBuf, rootStat;
1591 char fileName[BUFSIZ];
1592
Erik Andersenec5bd902000-03-22 07:12:05 +00001593 if (stat("/", &rootStat) != 0) {
Mark Whitleyf57c9442000-12-07 19:56:48 +00001594 error_msg("could not stat '/'\n");
Erik Andersenec5bd902000-03-22 07:12:05 +00001595 return( FALSE);
1596 }
Erik Andersen016ffe92000-03-22 00:58:54 +00001597
Erik Andersenec5bd902000-03-22 07:12:05 +00001598 dir = opendir("/dev");
1599 if (!dir) {
Mark Whitleyf57c9442000-12-07 19:56:48 +00001600 error_msg("could not open '/dev'\n");
Erik Andersenec5bd902000-03-22 07:12:05 +00001601 return( FALSE);
1602 }
Erik Andersen016ffe92000-03-22 00:58:54 +00001603
1604 while((entry = readdir(dir)) != NULL) {
Erik Andersenec5bd902000-03-22 07:12:05 +00001605
Erik Andersen016ffe92000-03-22 00:58:54 +00001606 /* Must skip ".." since that is "/", and so we
1607 * would get a false positive on ".." */
Erik Andersen016ffe92000-03-22 00:58:54 +00001608 if (strcmp(entry->d_name, "..") == 0)
1609 continue;
1610
Eric Andersenf9ca6532000-08-11 17:45:02 +00001611 snprintf( fileName, strlen(name)+1, "/dev/%s", entry->d_name);
Erik Andersen016ffe92000-03-22 00:58:54 +00001612
1613 if (stat(fileName, &statBuf) != 0)
1614 continue;
Erik Andersenec5bd902000-03-22 07:12:05 +00001615 /* Some char devices have the same dev_t as block
1616 * devices, so make sure this is a block device */
1617 if (! S_ISBLK(statBuf.st_mode))
1618 continue;
Erik Andersen016ffe92000-03-22 00:58:54 +00001619 if (statBuf.st_rdev == rootStat.st_rdev) {
Erik Andersenec5bd902000-03-22 07:12:05 +00001620 strcpy(name, fileName);
1621 return ( TRUE);
Erik Andersen016ffe92000-03-22 00:58:54 +00001622 }
1623 }
1624
Erik Andersenec5bd902000-03-22 07:12:05 +00001625 return( FALSE);
Erik Andersen016ffe92000-03-22 00:58:54 +00001626}
Erik Andersen23dea9b2000-05-13 00:28:25 +00001627#endif
Erik Andersen016ffe92000-03-22 00:58:54 +00001628
Mark Whitley1ca41772000-06-28 22:15:26 +00001629
1630/* get_line_from_file() - This function reads an entire line from a text file
1631 * up to a newline. It returns a malloc'ed char * which must be stored and
1632 * free'ed by the caller. */
1633extern char *get_line_from_file(FILE *file)
John Beppu5a728cf2000-04-17 04:22:09 +00001634{
Mark Whitley9a8243a2000-07-10 19:31:31 +00001635 static const int GROWBY = 80; /* how large we will grow strings by */
1636
Mark Whitley1ca41772000-06-28 22:15:26 +00001637 int ch;
1638 int idx = 0;
1639 char *linebuf = NULL;
1640 int linebufsz = 0;
John Beppu5a728cf2000-04-17 04:22:09 +00001641
Mark Whitley1ca41772000-06-28 22:15:26 +00001642 while (1) {
1643 ch = fgetc(file);
1644 if (ch == EOF)
1645 break;
1646 /* grow the line buffer as necessary */
Eric Andersen285b4462000-09-23 19:56:46 +00001647 while (idx > linebufsz-2)
Matt Kraai322ae932000-09-13 02:46:14 +00001648 linebuf = xrealloc(linebuf, linebufsz += GROWBY);
Mark Whitley1ca41772000-06-28 22:15:26 +00001649 linebuf[idx++] = (char)ch;
1650 if ((char)ch == '\n')
1651 break;
1652 }
John Beppu5a728cf2000-04-17 04:22:09 +00001653
Mark Whitley1ca41772000-06-28 22:15:26 +00001654 if (idx == 0)
1655 return NULL;
John Beppu5a728cf2000-04-17 04:22:09 +00001656
Mark Whitley1ca41772000-06-28 22:15:26 +00001657 linebuf[idx] = 0;
1658 return linebuf;
John Beppu5a728cf2000-04-17 04:22:09 +00001659}
Erik Andersen016ffe92000-03-22 00:58:54 +00001660
Eric Andersen944be902000-09-25 16:58:39 +00001661#if defined BB_CAT
Pavel Roskincc8a66b2000-07-17 20:18:42 +00001662extern void print_file(FILE *file)
1663{
1664 int c;
1665
1666 while ((c = getc(file)) != EOF)
1667 putc(c, stdout);
1668 fclose(file);
1669 fflush(stdout);
1670}
1671
1672extern int print_file_by_name(char *filename)
1673{
1674 FILE *file;
Matt Kraaic0321f92000-09-27 04:09:22 +00001675 if ((file = wfopen(filename, "r")) == NULL)
1676 return FALSE;
1677 print_file(file);
Pavel Roskincc8a66b2000-07-17 20:18:42 +00001678 return TRUE;
1679}
Matt Kraaie7c1af12000-09-27 03:01:40 +00001680#endif /* BB_CAT */
Pavel Roskincc8a66b2000-07-17 20:18:42 +00001681
Matt Kraaicabafae2000-11-30 04:55:40 +00001682#if defined BB_ECHO || defined BB_SH || defined BB_TR
Eric Andersenf7cf2f72000-07-05 17:26:35 +00001683char process_escape_sequence(char **ptr)
1684{
1685 char c;
1686
1687 switch (c = *(*ptr)++) {
1688 case 'a':
1689 c = '\a';
1690 break;
1691 case 'b':
1692 c = '\b';
1693 break;
1694 case 'f':
1695 c = '\f';
1696 break;
1697 case 'n':
1698 c = '\n';
1699 break;
Eric Andersen9bd71e82000-11-29 23:07:57 +00001700 case 'r':
1701 c = '\r';
1702 break;
Eric Andersenf7cf2f72000-07-05 17:26:35 +00001703 case 't':
1704 c = '\t';
1705 break;
1706 case 'v':
1707 c = '\v';
1708 break;
1709 case '\\':
1710 c = '\\';
1711 break;
1712 case '0': case '1': case '2': case '3':
1713 case '4': case '5': case '6': case '7':
1714 c -= '0';
1715 if ('0' <= **ptr && **ptr <= '7') {
1716 c = c * 8 + (*(*ptr)++ - '0');
1717 if ('0' <= **ptr && **ptr <= '7')
1718 c = c * 8 + (*(*ptr)++ - '0');
1719 }
1720 break;
1721 default:
1722 (*ptr)--;
1723 c = '\\';
1724 break;
1725 }
1726 return c;
1727}
1728#endif
1729
Eric Andersenba1ff9b2000-10-01 17:01:36 +00001730#if defined BB_BASENAME || defined BB_LN || defined BB_SH || defined BB_INIT || defined BB_FEATURE_USE_PROCFS
Eric Andersen0b4551f2000-07-10 16:44:03 +00001731char *get_last_path_component(char *path)
1732{
1733 char *s=path+strlen(path)-1;
1734
1735 /* strip trailing slashes */
Eric Andersen69a6b2d2000-12-12 23:13:54 +00001736 while (s != path && *s == '/') {
Eric Andersen0b4551f2000-07-10 16:44:03 +00001737 *s-- = '\0';
1738 }
1739
1740 /* find last component */
1741 s = strrchr(path, '/');
Eric Andersen69a6b2d2000-12-12 23:13:54 +00001742 if (s == NULL || s[1] == '\0')
1743 return path;
1744 else
1745 return s+1;
Eric Andersen0b4551f2000-07-10 16:44:03 +00001746}
1747#endif
1748
Mark Whitleydf5f6ba2000-07-11 16:53:56 +00001749#if defined BB_GREP || defined BB_SED
Mark Whitleyc41e8c82000-07-12 23:35:21 +00001750void xregcomp(regex_t *preg, const char *regex, int cflags)
Mark Whitleydf5f6ba2000-07-11 16:53:56 +00001751{
1752 int ret;
1753 if ((ret = regcomp(preg, regex, cflags)) != 0) {
1754 int errmsgsz = regerror(ret, preg, NULL, 0);
1755 char *errmsg = xmalloc(errmsgsz);
1756 regerror(ret, preg, errmsg, errmsgsz);
Mark Whitleyf57c9442000-12-07 19:56:48 +00001757 error_msg_and_die("xregcomp: %s\n", errmsg);
Mark Whitleydf5f6ba2000-07-11 16:53:56 +00001758 }
Mark Whitleydf5f6ba2000-07-11 16:53:56 +00001759}
1760#endif
1761
Eric Andersen7a86e612000-10-09 18:21:44 +00001762#if defined BB_CAT || defined BB_HEAD || defined BB_WC
Matt Kraaic0321f92000-09-27 04:09:22 +00001763FILE *wfopen(const char *path, const char *mode)
1764{
1765 FILE *fp;
1766 if ((fp = fopen(path, mode)) == NULL) {
Mark Whitleyf57c9442000-12-07 19:56:48 +00001767 error_msg("%s: %s\n", path, strerror(errno));
Matt Kraaic0321f92000-09-27 04:09:22 +00001768 errno = 0;
1769 }
1770 return fp;
1771}
1772#endif
1773
Eric Andersene790ddb2000-11-17 06:50:42 +00001774#if defined BB_HOSTNAME || defined BB_LOADACM || defined BB_MORE \
1775 || defined BB_SED || defined BB_SH || defined BB_UNIQ \
1776 || defined BB_WC || defined BB_CMP
Matt Kraaie0bcce02000-09-27 02:29:39 +00001777FILE *xfopen(const char *path, const char *mode)
1778{
1779 FILE *fp;
1780 if ((fp = fopen(path, mode)) == NULL)
Mark Whitleyf57c9442000-12-07 19:56:48 +00001781 error_msg_and_die("%s: %s\n", path, strerror(errno));
Matt Kraaie0bcce02000-09-27 02:29:39 +00001782 return fp;
1783}
1784#endif
1785
Eric Andersene5aef922000-11-17 18:25:26 +00001786int applet_name_compare(const void *x, const void *y)
1787{
1788 const struct BB_applet *applet1 = x;
1789 const struct BB_applet *applet2 = y;
1790
1791 return strcmp(applet1->name, applet2->name);
1792}
1793
Eric Andersencc8ed391999-10-05 16:24:54 +00001794/* END CODE */
Erik Andersen029011b2000-03-04 21:19:32 +00001795/*
1796Local Variables:
1797c-file-style: "linux"
1798c-basic-offset: 4
1799tab-width: 4
1800End:
1801*/