1/* vi: set sw=4 ts=4: */ 2/* 3 * Busybox main internal header file 4 * 5 * Based in part on code from sash, Copyright (c) 1999 by David I. Bell 6 * Permission has been granted to redistribute this code under the GPL. 7 * 8 * Licensed under the GPL version 2, see the file LICENSE in this tarball. 9 */ 10#ifndef __LIBBUSYBOX_H__ 11#define __LIBBUSYBOX_H__ 1 12 13#include "platform.h" 14 15#include <ctype.h> 16#include <dirent.h> 17#include <errno.h> 18#include <fcntl.h> 19#include <inttypes.h> 20#include <mntent.h> 21#include <netdb.h> 22#include <setjmp.h> 23#include <signal.h> 24#include <stdio.h> 25#include <stdlib.h> 26#include <stdarg.h> 27#include <stddef.h> 28#include <string.h> 29/* #include <strings.h> - said to be obsolete */ 30#include <sys/ioctl.h> 31#include <sys/mman.h> 32#include <sys/socket.h> 33#include <sys/stat.h> 34#include <sys/statfs.h> 35#include <sys/time.h> 36#include <sys/types.h> 37#include <sys/wait.h> 38#include <termios.h> 39#include <time.h> 40#include <unistd.h> 41#include <utime.h> 42 43#if ENABLE_SELINUX 44#include <selinux/selinux.h> 45#include <selinux/context.h> 46#endif 47 48#if ENABLE_LOCALE_SUPPORT 49#include <locale.h> 50#else 51#define setlocale(x,y) ((void)0) 52#endif 53 54#include "pwd_.h" 55#include "grp_.h" 56/* ifdef it out, because it may include <shadow.h> */ 57/* and we may not even _have_ <shadow.h>! */ 58#if ENABLE_FEATURE_SHADOWPASSWDS 59#include "shadow_.h" 60#endif 61 62/* Try to pull in PATH_MAX */ 63#include <limits.h> 64#include <sys/param.h> 65#ifndef PATH_MAX 66#define PATH_MAX 256 67#endif 68 69/* Tested to work correctly (IIRC :]) */ 70#define MAXINT(T) (T)( \ 71 ((T)-1) > 0 \ 72 ? (T)-1 \ 73 : (T)~((T)1 << (sizeof(T)*8-1)) \ 74 ) 75 76#define MININT(T) (T)( \ 77 ((T)-1) > 0 \ 78 ? (T)0 \ 79 : ((T)1 << (sizeof(T)*8-1)) \ 80 ) 81 82/* Large file support */ 83/* Note that CONFIG_LFS forces bbox to be built with all common ops 84 * (stat, lseek etc) mapped to "largefile" variants by libc. 85 * Practically it means that open() automatically has O_LARGEFILE added 86 * and all filesize/file_offset parameters and struct members are "large" 87 * (in today's world - signed 64bit). For full support of large files, 88 * we need a few helper #defines (below) and careful use of off_t 89 * instead of int/ssize_t. No lseek64(), O_LARGEFILE etc necessary */ 90#if ENABLE_LFS 91/* CONFIG_LFS is on */ 92# if ULONG_MAX > 0xffffffff 93/* "long" is long enough on this system */ 94# define XATOOFF(a) xatoul_range(a, 0, LONG_MAX) 95/* usage: sz = BB_STRTOOFF(s, NULL, 10); if (errno || sz < 0) die(); */ 96# define BB_STRTOOFF bb_strtoul 97# define STRTOOFF strtoul 98/* usage: printf("size: %"OFF_FMT"d (%"OFF_FMT"x)\n", sz, sz); */ 99# define OFF_FMT "l" 100# else 101/* "long" is too short, need "long long" */ 102# define XATOOFF(a) xatoull_range(a, 0, LLONG_MAX) 103# define BB_STRTOOFF bb_strtoull 104# define STRTOOFF strtoull 105# define OFF_FMT "ll" 106# endif 107#else 108/* CONFIG_LFS is off */ 109# if UINT_MAX == 0xffffffff 110/* While sizeof(off_t) == sizeof(int), off_t is typedef'ed to long anyway. 111 * gcc will throw warnings on printf("%d", off_t). Crap... */ 112# define XATOOFF(a) xatoi_u(a) 113# define BB_STRTOOFF bb_strtou 114# define STRTOOFF strtol 115# define OFF_FMT "l" 116# else 117# define XATOOFF(a) xatoul_range(a, 0, LONG_MAX) 118# define BB_STRTOOFF bb_strtoul 119# define STRTOOFF strtol 120# define OFF_FMT "l" 121# endif 122#endif 123/* scary. better ideas? (but do *test* them first!) */ 124#define OFF_T_MAX ((off_t)~((off_t)1 << (sizeof(off_t)*8-1))) 125 126/* Some useful definitions */ 127#undef FALSE 128#define FALSE ((int) 0) 129#undef TRUE 130#define TRUE ((int) 1) 131#undef SKIP 132#define SKIP ((int) 2) 133 134/* for mtab.c */ 135#define MTAB_GETMOUNTPT '1' 136#define MTAB_GETDEVICE '2' 137 138#define BUF_SIZE 8192 139#define EXPAND_ALLOC 1024 140 141/* Macros for min/max. */ 142#ifndef MIN 143#define MIN(a,b) (((a)<(b))?(a):(b)) 144#endif 145 146#ifndef MAX 147#define MAX(a,b) (((a)>(b))?(a):(b)) 148#endif 149 150/* buffer allocation schemes */ 151#if ENABLE_FEATURE_BUFFERS_GO_ON_STACK 152#define RESERVE_CONFIG_BUFFER(buffer,len) char buffer[len] 153#define RESERVE_CONFIG_UBUFFER(buffer,len) unsigned char buffer[len] 154#define RELEASE_CONFIG_BUFFER(buffer) ((void)0) 155#else 156#if ENABLE_FEATURE_BUFFERS_GO_IN_BSS 157#define RESERVE_CONFIG_BUFFER(buffer,len) static char buffer[len] 158#define RESERVE_CONFIG_UBUFFER(buffer,len) static unsigned char buffer[len] 159#define RELEASE_CONFIG_BUFFER(buffer) ((void)0) 160#else 161#define RESERVE_CONFIG_BUFFER(buffer,len) char *buffer = xmalloc(len) 162#define RESERVE_CONFIG_UBUFFER(buffer,len) unsigned char *buffer = xmalloc(len) 163#define RELEASE_CONFIG_BUFFER(buffer) free(buffer) 164#endif 165#endif 166 167 168#if defined(__GLIBC__) 169/* glibc uses __errno_location() to get a ptr to errno */ 170/* We can just memorize it once - no multithreading in busybox :) */ 171extern int *const bb_errno; 172#undef errno 173#define errno (*bb_errno) 174#endif 175 176#if defined(__GLIBC__) && __GLIBC__ < 2 177int vdprintf(int d, const char *format, va_list ap); 178#endif 179// This is declared here rather than #including <libgen.h> in order to avoid 180// confusing the two versions of basename. See the dirname/basename man page 181// for details. 182char *dirname(char *path); 183/* Include our own copy of struct sysinfo to avoid binary compatibility 184 * problems with Linux 2.4, which changed things. Grumble, grumble. */ 185struct sysinfo { 186 long uptime; /* Seconds since boot */ 187 unsigned long loads[3]; /* 1, 5, and 15 minute load averages */ 188 unsigned long totalram; /* Total usable main memory size */ 189 unsigned long freeram; /* Available memory size */ 190 unsigned long sharedram; /* Amount of shared memory */ 191 unsigned long bufferram; /* Memory used by buffers */ 192 unsigned long totalswap; /* Total swap space size */ 193 unsigned long freeswap; /* swap space still available */ 194 unsigned short procs; /* Number of current processes */ 195 unsigned short pad; /* Padding needed for m68k */ 196 unsigned long totalhigh; /* Total high memory size */ 197 unsigned long freehigh; /* Available high memory size */ 198 unsigned int mem_unit; /* Memory unit size in bytes */ 199 char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding: libc5 uses this.. */ 200}; 201int sysinfo(struct sysinfo* info); 202 203unsigned long long monotonic_us(void); 204unsigned monotonic_sec(void); 205 206extern void chomp(char *s); 207extern void trim(char *s); 208extern char *skip_whitespace(const char *); 209extern char *skip_non_whitespace(const char *); 210 211//TODO: supply a pointer to char[11] buffer (avoid statics)? 212extern const char *bb_mode_string(mode_t mode); 213extern int is_directory(const char *name, int followLinks, struct stat *statBuf); 214extern int remove_file(const char *path, int flags); 215extern int copy_file(const char *source, const char *dest, int flags); 216enum { 217 ACTION_RECURSE = (1 << 0), 218 ACTION_FOLLOWLINKS = (1 << 1), 219 ACTION_FOLLOWLINKS_L0 = (1 << 2), 220 ACTION_DEPTHFIRST = (1 << 3), 221 /*ACTION_REVERSE = (1 << 4), - unused */ 222}; 223extern int recursive_action(const char *fileName, unsigned flags, 224 int (*fileAction) (const char *fileName, struct stat* statbuf, void* userData, int depth), 225 int (*dirAction) (const char *fileName, struct stat* statbuf, void* userData, int depth), 226 void* userData, unsigned depth); 227extern int device_open(const char *device, int mode); 228extern int get_console_fd(void); 229extern char *find_block_device(const char *path); 230/* bb_copyfd_XX print read/write errors and return -1 if they occur */ 231extern off_t bb_copyfd_eof(int fd1, int fd2); 232extern off_t bb_copyfd_size(int fd1, int fd2, off_t size); 233extern void bb_copyfd_exact_size(int fd1, int fd2, off_t size); 234/* "short" copy can be detected by return value < size */ 235/* this helper yells "short read!" if param is not -1 */ 236extern void complain_copyfd_and_die(off_t sz) ATTRIBUTE_NORETURN; 237extern char bb_process_escape_sequence(const char **ptr); 238/* TODO: sometimes modifies its parameter, which 239 * makes it rather inconvenient at times: */ 240extern char *bb_get_last_path_component(char *path); 241 242int ndelay_on(int fd); 243int ndelay_off(int fd); 244void xdup2(int, int); 245void xmove_fd(int, int); 246 247 248DIR *xopendir(const char *path); 249DIR *warn_opendir(const char *path); 250 251/* UNUSED: char *xmalloc_realpath(const char *path); */ 252char *xmalloc_readlink(const char *path); 253char *xmalloc_readlink_or_warn(const char *path); 254char *xrealloc_getcwd_or_warn(char *cwd); 255 256 257//TODO: signal(sid, f) is the same? then why? 258extern void sig_catch(int,void (*)(int)); 259//#define sig_ignore(s) (sig_catch((s), SIG_IGN)) 260//#define sig_uncatch(s) (sig_catch((s), SIG_DFL)) 261extern void sig_block(int); 262extern void sig_unblock(int); 263/* UNUSED: extern void sig_blocknone(void); */ 264extern void sig_pause(void); 265 266 267void xsetgid(gid_t gid); 268void xsetuid(uid_t uid); 269void xchdir(const char *path); 270void xsetenv(const char *key, const char *value); 271void xunlink(const char *pathname); 272void xstat(const char *pathname, struct stat *buf); 273int xopen(const char *pathname, int flags); 274int xopen3(const char *pathname, int flags, int mode); 275int open_or_warn(const char *pathname, int flags); 276int open3_or_warn(const char *pathname, int flags, int mode); 277void xpipe(int filedes[2]); 278off_t xlseek(int fd, off_t offset, int whence); 279off_t fdlength(int fd); 280 281int xsocket(int domain, int type, int protocol); 282void xbind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen); 283void xlisten(int s, int backlog); 284void xconnect(int s, const struct sockaddr *s_addr, socklen_t addrlen); 285ssize_t xsendto(int s, const void *buf, size_t len, const struct sockaddr *to, 286 socklen_t tolen); 287/* SO_REUSEADDR allows a server to rebind to an address that is already 288 * "in use" by old connections to e.g. previous server instance which is 289 * killed or crashed. Without it bind will fail until all such connections 290 * time out. Linux does not allow multiple live binds on same ip:port 291 * regardless of SO_REUSEADDR (unlike some other flavors of Unix). 292 * Turn it on before you call bind(). */ 293void setsockopt_reuseaddr(int fd); /* On Linux this never fails. */ 294int setsockopt_broadcast(int fd); 295/* NB: returns port in host byte order */ 296unsigned bb_lookup_port(const char *port, const char *protocol, unsigned default_port); 297typedef struct len_and_sockaddr { 298 socklen_t len; 299 union { 300 struct sockaddr sa; 301 struct sockaddr_in sin; 302#if ENABLE_FEATURE_IPV6 303 struct sockaddr_in6 sin6; 304#endif 305 }; 306} len_and_sockaddr; 307enum { 308 LSA_SIZEOF_SA = sizeof( 309 union { 310 struct sockaddr sa; 311 struct sockaddr_in sin; 312#if ENABLE_FEATURE_IPV6 313 struct sockaddr_in6 sin6; 314#endif 315 } 316 ) 317}; 318/* Create stream socket, and allocate suitable lsa. 319 * (lsa of correct size and lsa->sa.sa_family (AF_INET/AF_INET6)) 320 * af == AF_UNSPEC will result in trying to create IPv6 socket, 321 * and if kernel doesn't support it, IPv4. 322 */ 323int xsocket_type(len_and_sockaddr **lsap, USE_FEATURE_IPV6(int af,) int sock_type); 324int xsocket_stream(len_and_sockaddr **lsap); 325/* Create server socket bound to bindaddr:port. bindaddr can be NULL, 326 * numeric IP ("N.N.N.N") or numeric IPv6 address, 327 * and can have ":PORT" suffix (for IPv6 use "[X:X:...:X]:PORT"). 328 * Only if there is no suffix, port argument is used */ 329/* NB: these set SO_REUSEADDR before bind */ 330int create_and_bind_stream_or_die(const char *bindaddr, int port); 331int create_and_bind_dgram_or_die(const char *bindaddr, int port); 332/* Create client TCP socket connected to peer:port. Peer cannot be NULL. 333 * Peer can be numeric IP ("N.N.N.N"), numeric IPv6 address or hostname, 334 * and can have ":PORT" suffix (for IPv6 use "[X:X:...:X]:PORT"). 335 * If there is no suffix, port argument is used */ 336int create_and_connect_stream_or_die(const char *peer, int port); 337/* Connect to peer identified by lsa */ 338int xconnect_stream(const len_and_sockaddr *lsa); 339/* Return malloc'ed len_and_sockaddr with socket address of host:port 340 * Currently will return IPv4 or IPv6 sockaddrs only 341 * (depending on host), but in theory nothing prevents e.g. 342 * UNIX socket address being returned, IPX sockaddr etc... 343 * On error does bb_error_msg and returns NULL */ 344len_and_sockaddr* host2sockaddr(const char *host, int port); 345/* Version which dies on error */ 346len_and_sockaddr* xhost2sockaddr(const char *host, int port); 347len_and_sockaddr* xdotted2sockaddr(const char *host, int port); 348#if ENABLE_FEATURE_IPV6 349/* Same, useful if you want to force family (e.g. IPv6) */ 350len_and_sockaddr* host_and_af2sockaddr(const char *host, int port, sa_family_t af); 351len_and_sockaddr* xhost_and_af2sockaddr(const char *host, int port, sa_family_t af); 352#else 353/* [we evaluate af: think about "host_and_af2sockaddr(..., af++)"] */ 354#define host_and_af2sockaddr(host, port, af) ((void)(af), host2sockaddr((host), (port))) 355#define xhost_and_af2sockaddr(host, port, af) ((void)(af), xhost2sockaddr((host), (port))) 356#endif 357/* Assign sin[6]_port member if the socket is an AF_INET[6] one, 358 * otherwise no-op. Useful for ftp. 359 * NB: does NOT do htons() internally, just direct assignment. */ 360void set_nport(len_and_sockaddr *lsa, unsigned port); 361/* Retrieve sin[6]_port or return -1 for non-INET[6] lsa's */ 362int get_nport(const struct sockaddr *sa); 363/* Reverse DNS. Returns NULL on failure. */ 364char* xmalloc_sockaddr2host(const struct sockaddr *sa); 365/* This one doesn't append :PORTNUM */ 366char* xmalloc_sockaddr2host_noport(const struct sockaddr *sa); 367/* This one also doesn't fall back to dotted IP (returns NULL) */ 368char* xmalloc_sockaddr2hostonly_noport(const struct sockaddr *sa); 369/* inet_[ap]ton on steroids */ 370char* xmalloc_sockaddr2dotted(const struct sockaddr *sa); 371char* xmalloc_sockaddr2dotted_noport(const struct sockaddr *sa); 372// "old" (ipv4 only) API 373// users: traceroute.c hostname.c - use _list_ of all IPs 374struct hostent *xgethostbyname(const char *name); 375// Also mount.c and inetd.c are using gethostbyname(), 376// + inet_common.c has additional IPv4-only stuff 377 378 379void socket_want_pktinfo(int fd); 380ssize_t send_to_from(int fd, void *buf, size_t len, int flags, 381 const struct sockaddr *from, const struct sockaddr *to, 382 socklen_t tolen); 383ssize_t recv_from_to(int fd, void *buf, size_t len, int flags, 384 struct sockaddr *from, struct sockaddr *to, 385 socklen_t sa_size); 386 387 388extern char *xstrdup(const char *s); 389extern char *xstrndup(const char *s, int n); 390extern char *safe_strncpy(char *dst, const char *src, size_t size); 391extern char *xasprintf(const char *format, ...) __attribute__ ((format (printf, 1, 2))); 392// gcc-4.1.1 still isn't good enough at optimizing it 393// (+200 bytes compared to macro) 394//static ALWAYS_INLINE 395//int LONE_DASH(const char *s) { return s[0] == '-' && !s[1]; } 396//static ALWAYS_INLINE 397//int NOT_LONE_DASH(const char *s) { return s[0] != '-' || s[1]; } 398#define LONE_DASH(s) ((s)[0] == '-' && !(s)[1]) 399#define NOT_LONE_DASH(s) ((s)[0] != '-' || (s)[1]) 400#define LONE_CHAR(s,c) ((s)[0] == (c) && !(s)[1]) 401#define NOT_LONE_CHAR(s,c) ((s)[0] != (c) || (s)[1]) 402#define DOT_OR_DOTDOT(s) ((s)[0] == '.' && (!(s)[1] || ((s)[1] == '.' && !(s)[2]))) 403 404/* dmalloc will redefine these to it's own implementation. It is safe 405 * to have the prototypes here unconditionally. */ 406extern void *malloc_or_warn(size_t size); 407extern void *xmalloc(size_t size); 408extern void *xzalloc(size_t size); 409extern void *xrealloc(void *old, size_t size); 410 411extern ssize_t safe_read(int fd, void *buf, size_t count); 412extern ssize_t full_read(int fd, void *buf, size_t count); 413extern void xread(int fd, void *buf, size_t count); 414extern unsigned char xread_char(int fd); 415// Read one line a-la fgets. Uses one read(), works only on seekable streams 416extern char *reads(int fd, char *buf, size_t count); 417// Read one line a-la fgets. Reads byte-by-byte. 418// Useful when it is important to not read ahead. 419extern char *xmalloc_reads(int fd, char *pfx); 420extern ssize_t read_close(int fd, void *buf, size_t count); 421extern ssize_t open_read_close(const char *filename, void *buf, size_t count); 422extern void *xmalloc_open_read_close(const char *filename, size_t *sizep); 423 424extern ssize_t safe_write(int fd, const void *buf, size_t count); 425extern ssize_t full_write(int fd, const void *buf, size_t count); 426extern void xwrite(int fd, const void *buf, size_t count); 427 428/* Reads and prints to stdout till eof, then closes FILE. Exits on error: */ 429extern void xprint_and_close_file(FILE *file); 430extern char *xmalloc_fgets(FILE *file); 431/* Read up to (and including) TERMINATING_STRING: */ 432extern char *xmalloc_fgets_str(FILE *file, const char *terminating_string); 433/* Chops off '\n' from the end, unlike fgets: */ 434extern char *xmalloc_getline(FILE *file); 435extern char *bb_get_chunk_from_file(FILE *file, int *end); 436extern void die_if_ferror(FILE *file, const char *msg); 437extern void die_if_ferror_stdout(void); 438extern void xfflush_stdout(void); 439extern void fflush_stdout_and_exit(int retval) ATTRIBUTE_NORETURN; 440extern int fclose_if_not_stdin(FILE *file); 441extern FILE *xfopen(const char *filename, const char *mode); 442/* Prints warning to stderr and returns NULL on failure: */ 443extern FILE *fopen_or_warn(const char *filename, const char *mode); 444/* "Opens" stdin if filename is special, else just opens file: */ 445extern FILE *fopen_or_warn_stdin(const char *filename); 446 447/* Convert each alpha char in str to lower-case */ 448extern char* str_tolower(char *str); 449 450char *utoa(unsigned n); 451char *itoa(int n); 452/* Returns a pointer past the formatted number, does NOT null-terminate */ 453char *utoa_to_buf(unsigned n, char *buf, unsigned buflen); 454char *itoa_to_buf(int n, char *buf, unsigned buflen); 455void smart_ulltoa5(unsigned long long ul, char buf[5]); 456//TODO: provide pointer to buf (avoid statics)? 457const char *make_human_readable_str(unsigned long long size, 458 unsigned long block_size, unsigned long display_unit); 459/* Put a string of hex bytes ("1b2e66fe"...), return advanced pointer */ 460char *bin2hex(char *buf, const char *cp, int count); 461 462/* Last element is marked by mult == 0 */ 463struct suffix_mult { 464 char suffix[4]; 465 unsigned mult; 466}; 467#include "xatonum.h" 468/* Specialized: */ 469/* Using xatoi() instead of naive atoi() is not always convenient - 470 * in many places people want *non-negative* values, but store them 471 * in signed int. Therefore we need this one: 472 * dies if input is not in [0, INT_MAX] range. Also will reject '-0' etc */ 473int xatoi_u(const char *numstr); 474/* Useful for reading port numbers */ 475uint16_t xatou16(const char *numstr); 476 477 478/* These parse entries in /etc/passwd and /etc/group. This is desirable 479 * for BusyBox since we want to avoid using the glibc NSS stuff, which 480 * increases target size and is often not needed on embedded systems. */ 481long xuname2uid(const char *name); 482long xgroup2gid(const char *name); 483/* wrapper: allows string to contain numeric uid or gid */ 484unsigned long get_ug_id(const char *s, long (*xname2id)(const char *)); 485/* from chpst. Does not die, returns 0 on failure */ 486struct bb_uidgid_t { 487 uid_t uid; 488 gid_t gid; 489}; 490/* always sets uid and gid */ 491int get_uidgid(struct bb_uidgid_t*, const char*, int numeric_ok); 492/* chown-like handling of "user[:[group]" */ 493void parse_chown_usergroup_or_die(struct bb_uidgid_t *u, char *user_group); 494/* bb_getpwuid, bb_getgrgid: 495 * bb_getXXXid(buf, bufsz, id) - copy user/group name or id 496 * as a string to buf, return user/group name or NULL 497 * bb_getXXXid(NULL, 0, id) - return user/group name or NULL 498 * bb_getXXXid(NULL, -1, id) - return user/group name or exit 499*/ 500char *bb_getpwuid(char *name, int bufsize, long uid); 501char *bb_getgrgid(char *group, int bufsize, long gid); 502/* versions which cache results (useful for ps, ls etc) */ 503const char* get_cached_username(uid_t uid); 504const char* get_cached_groupname(gid_t gid); 505void clear_username_cache(void); 506/* internally usernames are saved in fixed-sized char[] buffers */ 507enum { USERNAME_MAX_SIZE = 16 - sizeof(int) }; 508 509 510struct bb_applet; 511int execable_file(const char *name); 512char *find_execable(const char *filename); 513int exists_execable(const char *filename); 514 515#if ENABLE_FEATURE_PREFER_APPLETS 516int bb_execvp(const char *file, char *const argv[]); 517#define BB_EXECVP(prog,cmd) bb_execvp(prog,cmd) 518#define BB_EXECLP(prog,cmd,...) \ 519 execlp((find_applet_by_name(prog)) ? CONFIG_BUSYBOX_EXEC_PATH : prog, \ 520 cmd, __VA_ARGS__) 521#else 522#define BB_EXECVP(prog,cmd) execvp(prog,cmd) 523#define BB_EXECLP(prog,cmd,...) execlp(prog,cmd, __VA_ARGS__) 524#endif 525 526/* NOMMU friendy fork+exec */ 527pid_t spawn(char **argv); 528pid_t xspawn(char **argv); 529 530/* Unlike waitpid, waits ONLY for one process, 531 * It's safe to pass negative 'pids' from failed [v]fork - 532 * wait4pid will return -1 (and will not clobber [v]fork's errno). 533 * IOW: rc = wait4pid(spawn(argv)); 534 * if (rc < 0) bb_perror_msg("%s", argv[0]); 535 * if (rc > 0) bb_error_msg("exit code: %d", rc); 536 */ 537int wait4pid(int pid); 538int wait_pid(int *wstat, int pid); 539int wait_nohang(int *wstat); 540#define wait_crashed(w) ((w) & 127) 541#define wait_exitcode(w) ((w) >> 8) 542#define wait_stopsig(w) ((w) >> 8) 543#define wait_stopped(w) (((w) & 127) == 127) 544/* wait4pid(spawn(argv)) + NOFORK/NOEXEC (if configured) */ 545int spawn_and_wait(char **argv); 546struct nofork_save_area { 547 jmp_buf die_jmp; 548 const struct bb_applet *current_applet; 549 int xfunc_error_retval; 550 uint32_t option_mask32; 551 int die_sleep; 552 smallint saved; 553}; 554void save_nofork_data(struct nofork_save_area *save); 555void restore_nofork_data(struct nofork_save_area *save); 556/* Does NOT check that applet is NOFORK, just blindly runs it */ 557int run_nofork_applet(const struct bb_applet *a, char **argv); 558int run_nofork_applet_prime(struct nofork_save_area *old, const struct bb_applet *a, char **argv); 559 560/* Helpers for daemonization. 561 * 562 * bb_daemonize(flags) = daemonize, does not compile on NOMMU 563 * 564 * bb_daemonize_or_rexec(flags, argv) = daemonizes on MMU (and ignores argv), 565 * rexec's itself on NOMMU with argv passed as command line. 566 * Thus bb_daemonize_or_rexec may cause your <applet>_main() to be re-executed 567 * from the start. (It will detect it and not reexec again second time). 568 * You have to audit carefully that you don't do something twice as a result 569 * (opening files/sockets, parsing config files etc...)! 570 * 571 * Both of the above will redirect fd 0,1,2 to /dev/null and drop ctty 572 * (will do setsid()). 573 * 574 * forkexit_or_rexec(argv) = bare-bones "fork + parent exits" on MMU, 575 * "vfork + re-exec ourself" on NOMMU. No fd redirection, no setsid(). 576 * Currently used for openvt. On MMU ignores argv. 577 * 578 * Helper for network daemons in foreground mode: 579 * 580 * bb_sanitize_stdio() = make sure that fd 0,1,2 are opened by opening them 581 * to /dev/null if they are not. 582 */ 583enum { 584 DAEMON_CHDIR_ROOT = 1, 585 DAEMON_DEVNULL_STDIO = 2, 586 DAEMON_CLOSE_EXTRA_FDS = 4, 587 DAEMON_ONLY_SANITIZE = 8, /* internal use */ 588}; 589#if BB_MMU 590 void forkexit_or_rexec(void); 591 enum { re_execed = 0 }; 592# define forkexit_or_rexec(argv) forkexit_or_rexec() 593# define bb_daemonize_or_rexec(flags, argv) bb_daemonize_or_rexec(flags) 594# define bb_daemonize(flags) bb_daemonize_or_rexec(flags, bogus) 595#else 596 void re_exec(char **argv) ATTRIBUTE_NORETURN; 597 void forkexit_or_rexec(char **argv); 598 extern bool re_execed; 599# define fork() BUG_fork_is_unavailable_on_nommu() 600# define daemon(a,b) BUG_daemon_is_unavailable_on_nommu() 601# define bb_daemonize(a) BUG_bb_daemonize_is_unavailable_on_nommu() 602#endif 603void bb_daemonize_or_rexec(int flags, char **argv); 604void bb_sanitize_stdio(void); 605 606 607extern const char *opt_complementary; 608#if ENABLE_GETOPT_LONG 609#define No_argument "\0" 610#define Required_argument "\001" 611#define Optional_argument "\002" 612extern const char *applet_long_options; 613#endif 614extern uint32_t option_mask32; 615extern uint32_t getopt32(char **argv, const char *applet_opts, ...); 616 617 618typedef struct llist_t { 619 char *data; 620 struct llist_t *link; 621} llist_t; 622void llist_add_to(llist_t **old_head, void *data); 623void llist_add_to_end(llist_t **list_head, void *data); 624void *llist_pop(llist_t **elm); 625void llist_unlink(llist_t **head, llist_t *elm); 626void llist_free(llist_t *elm, void (*freeit)(void *data)); 627llist_t *llist_rev(llist_t *list); 628/* BTW, surprisingly, changing API to 629 * llist_t *llist_add_to(llist_t *old_head, void *data) 630 * etc does not result in smaller code... */ 631 632/* start_stop_daemon and udhcpc are special - they want 633 * to create pidfiles regardless of FEATURE_PIDFILE */ 634#if ENABLE_FEATURE_PIDFILE || defined(WANT_PIDFILE) 635/* True only if we created pidfile which is *file*, not /dev/null etc */ 636extern smallint wrote_pidfile; 637void write_pidfile(const char *path); 638#define remove_pidfile(path) do { if (wrote_pidfile) unlink(path); } while (0) 639#else 640enum { wrote_pidfile = 0 }; 641#define write_pidfile(path) ((void)0) 642#define remove_pidfile(path) ((void)0) 643#endif 644 645enum { 646 LOGMODE_NONE = 0, 647 LOGMODE_STDIO = (1 << 0), 648 LOGMODE_SYSLOG = (1 << 1) * ENABLE_FEATURE_SYSLOG, 649 LOGMODE_BOTH = LOGMODE_SYSLOG + LOGMODE_STDIO, 650}; 651extern const char *msg_eol; 652extern smallint logmode; 653extern int die_sleep; 654extern int xfunc_error_retval; 655extern jmp_buf die_jmp; 656extern void xfunc_die(void) ATTRIBUTE_NORETURN; 657extern void bb_show_usage(void) ATTRIBUTE_NORETURN ATTRIBUTE_EXTERNALLY_VISIBLE; 658extern void bb_error_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2))); 659extern void bb_error_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2))); 660extern void bb_perror_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2))); 661extern void bb_perror_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2))); 662extern void bb_herror_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2))); 663extern void bb_herror_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2))); 664extern void bb_perror_nomsg_and_die(void) ATTRIBUTE_NORETURN; 665extern void bb_perror_nomsg(void); 666extern void bb_info_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2))); 667extern void bb_verror_msg(const char *s, va_list p, const char *strerr); 668 669 670/* applets which are useful from another applets */ 671int bb_cat(char** argv); 672int bb_echo(char** argv); 673int test_main(int argc, char** argv); 674int kill_main(int argc, char **argv); 675#if ENABLE_ROUTE 676void bb_displayroutes(int noresolve, int netstatfmt); 677#endif 678int chown_main(int argc, char **argv); 679#if ENABLE_GUNZIP 680int gunzip_main(int argc, char **argv); 681#endif 682int bbunpack(char **argv, 683 char* (*make_new_name)(char *filename), 684 USE_DESKTOP(long long) int (*unpacker)(void) 685); 686 687 688/* Networking */ 689int create_icmp_socket(void); 690int create_icmp6_socket(void); 691/* interface.c */ 692/* This structure defines protocol families and their handlers. */ 693struct aftype { 694 const char *name; 695 const char *title; 696 int af; 697 int alen; 698 char *(*print) (unsigned char *); 699 const char *(*sprint) (struct sockaddr *, int numeric); 700 int (*input) (/*int type,*/ const char *bufp, struct sockaddr *); 701 void (*herror) (char *text); 702 int (*rprint) (int options); 703 int (*rinput) (int typ, int ext, char **argv); 704 705 /* may modify src */ 706 int (*getmask) (char *src, struct sockaddr * mask, char *name); 707}; 708/* This structure defines hardware protocols and their handlers. */ 709struct hwtype { 710 const char *name; 711 const char *title; 712 int type; 713 int alen; 714 char *(*print) (unsigned char *); 715 int (*input) (const char *, struct sockaddr *); 716 int (*activate) (int fd); 717 int suppress_null_addr; 718}; 719extern smallint interface_opt_a; 720int display_interfaces(char *ifname); 721const struct aftype *get_aftype(const char *name); 722const struct hwtype *get_hwtype(const char *name); 723const struct hwtype *get_hwntype(int type); 724 725 726#ifndef BUILD_INDIVIDUAL 727extern const struct bb_applet *find_applet_by_name(const char *name); 728/* Returns only if applet is not found. */ 729extern void run_applet_and_exit(const char *name, char **argv); 730extern void run_current_applet_and_exit(char **argv) ATTRIBUTE_NORETURN; 731#endif 732 733extern int match_fstype(const struct mntent *mt, const char *fstypes); 734extern struct mntent *find_mount_point(const char *name, const char *table); 735extern void erase_mtab(const char * name); 736extern unsigned int tty_baud_to_value(speed_t speed); 737extern speed_t tty_value_to_baud(unsigned int value); 738extern void bb_warn_ignoring_args(int n); 739 740extern int get_linux_version_code(void); 741 742extern char *query_loop(const char *device); 743extern int del_loop(const char *device); 744/* If *devname is not NULL, use that name, otherwise try to find free one, 745 * malloc and return it in *devname. 746 * return value: 1: read-only loopdev was setup, 0: rw, < 0: error */ 747extern int set_loop(char **devname, const char *file, unsigned long long offset); 748 749 750//TODO: pass buf pointer or return allocated buf (avoid statics)? 751char *bb_askpass(int timeout, const char * prompt); 752int bb_ask_confirmation(void); 753int klogctl(int type, char * b, int len); 754 755extern int bb_parse_mode(const char* s, mode_t* theMode); 756 757char *concat_path_file(const char *path, const char *filename); 758char *concat_subpath_file(const char *path, const char *filename); 759const char *bb_basename(const char *name); 760/* NB: can violate const-ness (similarly to strchr) */ 761char *last_char_is(const char *s, int c); 762 763 764USE_DESKTOP(long long) int uncompress(int fd_in, int fd_out); 765int inflate(int in, int out); 766 767 768int bb_make_directory(char *path, long mode, int flags); 769 770int get_signum(const char *name); 771const char *get_signame(int number); 772 773char *bb_simplify_path(const char *path); 774 775#define FAIL_DELAY 3 776extern void bb_do_delay(int seconds); 777extern void change_identity(const struct passwd *pw); 778extern const char *change_identity_e2str(const struct passwd *pw); 779extern void run_shell(const char *shell, int loginshell, const char *command, const char **additional_args); 780#if ENABLE_SELINUX 781extern void renew_current_security_context(void); 782extern void set_current_security_context(security_context_t sid); 783extern context_t set_security_context_component(security_context_t cur_context, 784 char *user, char *role, char *type, char *range); 785extern void setfscreatecon_or_die(security_context_t scontext); 786#endif 787extern void selinux_or_die(void); 788extern int restricted_shell(const char *shell); 789extern void setup_environment(const char *shell, int loginshell, int changeenv, const struct passwd *pw); 790extern int correct_password(const struct passwd *pw); 791/* Returns a ptr to static storage */ 792extern char *pw_encrypt(const char *clear, const char *salt); 793extern int obscure(const char *old, const char *newval, const struct passwd *pwdp); 794extern int index_in_str_array(const char *const string_array[], const char *key); 795extern int index_in_strings(const char *strings, const char *key); 796extern int index_in_substr_array(const char *const string_array[], const char *key); 797extern int index_in_substrings(const char *strings, const char *key); 798extern void print_login_issue(const char *issue_file, const char *tty); 799extern void print_login_prompt(void); 800 801/* rnd is additional random input. New one is returned. 802 * Useful if you call crypt_make_salt many times in a row: 803 * rnd = crypt_make_salt(buf1, 4, 0); 804 * rnd = crypt_make_salt(buf2, 4, rnd); 805 * rnd = crypt_make_salt(buf3, 4, rnd); 806 * (otherwise we risk having same salt generated) 807 */ 808extern int crypt_make_salt(char *p, int cnt, int rnd); 809 810/* Returns number of lines changed, or -1 on error */ 811extern int update_passwd(const char *filename, const char *username, 812 const char *new_pw); 813 814/* NB: typically you want to pass fd 0, not 1. Think 'applet | grep something' */ 815int get_terminal_width_height(int fd, int *width, int *height); 816 817int ioctl_or_perror(int fd, int request, void *argp, const char *fmt,...) __attribute__ ((format (printf, 4, 5))); 818void ioctl_or_perror_and_die(int fd, int request, void *argp, const char *fmt,...) __attribute__ ((format (printf, 4, 5))); 819#if ENABLE_IOCTL_HEX2STR_ERROR 820int bb_ioctl_or_warn(int fd, int request, void *argp, const char *ioctl_name); 821void bb_xioctl(int fd, int request, void *argp, const char *ioctl_name); 822#define ioctl_or_warn(fd,request,argp) bb_ioctl_or_warn(fd,request,argp,#request) 823#define xioctl(fd,request,argp) bb_xioctl(fd,request,argp,#request) 824#else 825int bb_ioctl_or_warn(int fd, int request, void *argp); 826void bb_xioctl(int fd, int request, void *argp); 827#define ioctl_or_warn(fd,request,argp) bb_ioctl_or_warn(fd,request,argp) 828#define xioctl(fd,request,argp) bb_xioctl(fd,request,argp) 829#endif 830 831char *is_in_ino_dev_hashtable(const struct stat *statbuf); 832void add_to_ino_dev_hashtable(const struct stat *statbuf, const char *name); 833void reset_ino_dev_hashtable(void); 834#ifdef __GLIBC__ 835/* At least glibc has horrendously large inline for this, so wrap it */ 836unsigned long long bb_makedev(unsigned int major, unsigned int minor); 837#undef makedev 838#define makedev(a,b) bb_makedev(a,b) 839#endif 840 841 842#if ENABLE_FEATURE_EDITING 843/* It's NOT just ENABLEd or disabled. It's a number: */ 844#ifdef CONFIG_FEATURE_EDITING_HISTORY 845#define MAX_HISTORY (CONFIG_FEATURE_EDITING_HISTORY + 0) 846#else 847#define MAX_HISTORY 0 848#endif 849typedef struct line_input_t { 850 int flags; 851 const char *path_lookup; 852#if MAX_HISTORY 853 int cnt_history; 854 int cur_history; 855 USE_FEATURE_EDITING_SAVEHISTORY(const char *hist_file;) 856 char *history[MAX_HISTORY + 1]; 857#endif 858} line_input_t; 859enum { 860 DO_HISTORY = 1 * (MAX_HISTORY > 0), 861 SAVE_HISTORY = 2 * (MAX_HISTORY > 0) * ENABLE_FEATURE_EDITING_SAVEHISTORY, 862 TAB_COMPLETION = 4 * ENABLE_FEATURE_TAB_COMPLETION, 863 USERNAME_COMPLETION = 8 * ENABLE_FEATURE_USERNAME_COMPLETION, 864 VI_MODE = 0x10 * ENABLE_FEATURE_EDITING_VI, 865 WITH_PATH_LOOKUP = 0x20, 866 FOR_SHELL = DO_HISTORY | SAVE_HISTORY | TAB_COMPLETION | USERNAME_COMPLETION, 867}; 868line_input_t *new_line_input_t(int flags); 869int read_line_input(const char* prompt, char* command, int maxsize, line_input_t *state); 870#else 871int read_line_input(const char* prompt, char* command, int maxsize); 872#define read_line_input(prompt, command, maxsize, state) \ 873 read_line_input(prompt, command, maxsize) 874#endif 875 876 877#ifndef COMM_LEN 878#ifdef TASK_COMM_LEN 879enum { COMM_LEN = TASK_COMM_LEN }; 880#else 881/* synchronize with sizeof(task_struct.comm) in /usr/include/linux/sched.h */ 882enum { COMM_LEN = 16 }; 883#endif 884#endif 885typedef struct { 886 DIR *dir; 887/* Fields are set to 0/NULL if failed to determine (or not requested) */ 888 /*char *cmd;*/ 889 char *argv0; 890 /*char *exe;*/ 891 USE_SELINUX(char *context;) 892 /* Everything below must contain no ptrs to malloc'ed data: 893 * it is memset(0) for each process in procps_scan() */ 894 unsigned vsz, rss; /* we round it to kbytes */ 895 unsigned long stime, utime; 896 unsigned pid; 897 unsigned ppid; 898 unsigned pgid; 899 unsigned sid; 900 unsigned uid; 901 unsigned gid; 902 unsigned tty_major,tty_minor; 903 char state[4]; 904 /* basename of executable in exec(2), read from /proc/N/stat 905 * (if executable is symlink or script, it is NOT replaced 906 * by link target or interpreter name) */ 907 char comm[COMM_LEN]; 908 /* user/group? - use passwd/group parsing functions */ 909} procps_status_t; 910enum { 911 PSSCAN_PID = 1 << 0, 912 PSSCAN_PPID = 1 << 1, 913 PSSCAN_PGID = 1 << 2, 914 PSSCAN_SID = 1 << 3, 915 PSSCAN_UIDGID = 1 << 4, 916 PSSCAN_COMM = 1 << 5, 917 /* PSSCAN_CMD = 1 << 6, - use read_cmdline instead */ 918 PSSCAN_ARGV0 = 1 << 7, 919 /* PSSCAN_EXE = 1 << 8, - not implemented */ 920 PSSCAN_STATE = 1 << 9, 921 PSSCAN_VSZ = 1 << 10, 922 PSSCAN_RSS = 1 << 11, 923 PSSCAN_STIME = 1 << 12, 924 PSSCAN_UTIME = 1 << 13, 925 PSSCAN_TTY = 1 << 14, 926 USE_SELINUX(PSSCAN_CONTEXT = 1 << 15,) 927 /* These are all retrieved from proc/NN/stat in one go: */ 928 PSSCAN_STAT = PSSCAN_PPID | PSSCAN_PGID | PSSCAN_SID 929 | PSSCAN_COMM | PSSCAN_STATE 930 | PSSCAN_VSZ | PSSCAN_RSS 931 | PSSCAN_STIME | PSSCAN_UTIME 932 | PSSCAN_TTY, 933}; 934procps_status_t* alloc_procps_scan(int flags); 935void free_procps_scan(procps_status_t* sp); 936procps_status_t* procps_scan(procps_status_t* sp, int flags); 937/* Format cmdline (up to col chars) into char buf[col+1] */ 938/* Puts [comm] if cmdline is empty (-> process is a kernel thread) */ 939void read_cmdline(char *buf, int col, unsigned pid, const char *comm); 940pid_t *find_pid_by_name(const char* procName); 941pid_t *pidlist_reverse(pid_t *pidList); 942 943 944extern const char bb_uuenc_tbl_base64[]; 945extern const char bb_uuenc_tbl_std[]; 946void bb_uuencode(char *store, const void *s, int length, const char *tbl); 947 948typedef struct sha1_ctx_t { 949 uint32_t count[2]; 950 uint32_t hash[5]; 951 uint32_t wbuf[16]; 952} sha1_ctx_t; 953void sha1_begin(sha1_ctx_t *ctx); 954void sha1_hash(const void *data, size_t length, sha1_ctx_t *ctx); 955void *sha1_end(void *resbuf, sha1_ctx_t *ctx); 956 957typedef struct md5_ctx_t { 958 uint32_t A; 959 uint32_t B; 960 uint32_t C; 961 uint32_t D; 962 uint64_t total; 963 uint32_t buflen; 964 char buffer[128]; 965} md5_ctx_t; 966void md5_begin(md5_ctx_t *ctx); 967void md5_hash(const void *data, size_t length, md5_ctx_t *ctx); 968void *md5_end(void *resbuf, md5_ctx_t *ctx); 969 970uint32_t *crc32_filltable(uint32_t *tbl256, int endian); 971 972 973enum { /* DO NOT CHANGE THESE VALUES! cp.c, mv.c, install.c depend on them. */ 974 FILEUTILS_PRESERVE_STATUS = 1, 975 FILEUTILS_DEREFERENCE = 2, 976 FILEUTILS_RECUR = 4, 977 FILEUTILS_FORCE = 8, 978 FILEUTILS_INTERACTIVE = 0x10, 979 FILEUTILS_MAKE_HARDLINK = 0x20, 980 FILEUTILS_MAKE_SOFTLINK = 0x40, 981#if ENABLE_SELINUX 982 FILEUTILS_PRESERVE_SECURITY_CONTEXT = 0x80, 983 FILEUTILS_SET_SECURITY_CONTEXT = 0x100 984#endif 985}; 986 987#define FILEUTILS_CP_OPTSTR "pdRfils" USE_SELINUX("c") 988extern const struct bb_applet *current_applet; 989extern const char *applet_name; 990/* "BusyBox vN.N.N (timestamp or extra_vestion)" */ 991extern const char bb_banner[]; 992extern const char bb_msg_memory_exhausted[]; 993extern const char bb_msg_invalid_date[]; 994extern const char bb_msg_read_error[]; 995extern const char bb_msg_write_error[]; 996extern const char bb_msg_unknown[]; 997extern const char bb_msg_can_not_create_raw_socket[]; 998extern const char bb_msg_perm_denied_are_you_root[]; 999extern const char bb_msg_requires_arg[]; 1000extern const char bb_msg_invalid_arg[]; 1001extern const char bb_msg_standard_input[]; 1002extern const char bb_msg_standard_output[]; 1003 1004extern const char bb_str_default[]; 1005/* NB: (bb_hexdigits_upcase[i] | 0x20) -> lowercase hex digit */ 1006extern const char bb_hexdigits_upcase[]; 1007 1008extern const char bb_path_mtab_file[]; 1009extern const char bb_path_passwd_file[]; 1010extern const char bb_path_shadow_file[]; 1011extern const char bb_path_gshadow_file[]; 1012extern const char bb_path_group_file[]; 1013extern const char bb_path_motd_file[]; 1014extern const char bb_path_wtmp_file[]; 1015extern const char bb_dev_null[]; 1016extern const char bb_busybox_exec_path[]; 1017/* util-linux manpage says /sbin:/bin:/usr/sbin:/usr/bin, 1018 * but I want to save a few bytes here */ 1019extern const char bb_PATH_root_path[]; /* "PATH=/sbin:/usr/sbin:/bin:/usr/bin" */ 1020#define bb_default_root_path (bb_PATH_root_path + sizeof("PATH")) 1021#define bb_default_path (bb_PATH_root_path + sizeof("PATH=/sbin:/usr/sbin")) 1022 1023extern const int const_int_0; 1024extern const int const_int_1; 1025 1026 1027#ifndef BUFSIZ 1028#define BUFSIZ 4096 1029#endif 1030/* Providing hard guarantee on minimum size (think of BUFSIZ == 128) */ 1031enum { COMMON_BUFSIZE = (BUFSIZ >= 256*sizeof(void*) ? BUFSIZ+1 : 256*sizeof(void*)) }; 1032extern char bb_common_bufsiz1[COMMON_BUFSIZE]; 1033/* This struct is deliberately not defined. */ 1034/* See docs/keep_data_small.txt */ 1035struct globals; 1036extern struct globals *const ptr_to_globals; 1037#define PTR_TO_GLOBALS (*(struct globals**)&ptr_to_globals) 1038 1039 1040/* You can change LIBBB_DEFAULT_LOGIN_SHELL, but don't use it, 1041 * use bb_default_login_shell and following defines. 1042 * If you change LIBBB_DEFAULT_LOGIN_SHELL, 1043 * don't forget to change increment constant. */ 1044#define LIBBB_DEFAULT_LOGIN_SHELL "-/bin/sh" 1045extern const char bb_default_login_shell[]; 1046/* "/bin/sh" */ 1047#define DEFAULT_SHELL (bb_default_login_shell+1) 1048/* "sh" */ 1049#define DEFAULT_SHELL_SHORT_NAME (bb_default_login_shell+6) 1050 1051 1052#if ENABLE_FEATURE_DEVFS 1053# define CURRENT_VC "/dev/vc/0" 1054# define VC_1 "/dev/vc/1" 1055# define VC_2 "/dev/vc/2" 1056# define VC_3 "/dev/vc/3" 1057# define VC_4 "/dev/vc/4" 1058# define VC_5 "/dev/vc/5" 1059#if defined(__sh__) || defined(__H8300H__) || defined(__H8300S__) 1060/* Yes, this sucks, but both SH (including sh64) and H8 have a SCI(F) for their 1061 respective serial ports .. as such, we can't use the common device paths for 1062 these. -- PFM */ 1063# define SC_0 "/dev/ttsc/0" 1064# define SC_1 "/dev/ttsc/1" 1065# define SC_FORMAT "/dev/ttsc/%d" 1066#else 1067# define SC_0 "/dev/tts/0" 1068# define SC_1 "/dev/tts/1" 1069# define SC_FORMAT "/dev/tts/%d" 1070#endif 1071# define VC_FORMAT "/dev/vc/%d" 1072# define LOOP_FORMAT "/dev/loop/%d" 1073# define LOOP_NAMESIZE (sizeof("/dev/loop/") + sizeof(int)*3 + 1) 1074# define LOOP_NAME "/dev/loop/" 1075# define FB_0 "/dev/fb/0" 1076#else 1077# define CURRENT_VC "/dev/tty0" 1078# define VC_1 "/dev/tty1" 1079# define VC_2 "/dev/tty2" 1080# define VC_3 "/dev/tty3" 1081# define VC_4 "/dev/tty4" 1082# define VC_5 "/dev/tty5" 1083#if defined(__sh__) || defined(__H8300H__) || defined(__H8300S__) 1084# define SC_0 "/dev/ttySC0" 1085# define SC_1 "/dev/ttySC1" 1086# define SC_FORMAT "/dev/ttySC%d" 1087#else 1088# define SC_0 "/dev/ttyS0" 1089# define SC_1 "/dev/ttyS1" 1090# define SC_FORMAT "/dev/ttyS%d" 1091#endif 1092# define VC_FORMAT "/dev/tty%d" 1093# define LOOP_FORMAT "/dev/loop%d" 1094# define LOOP_NAMESIZE (sizeof("/dev/loop") + sizeof(int)*3 + 1) 1095# define LOOP_NAME "/dev/loop" 1096# define FB_0 "/dev/fb0" 1097#endif 1098 1099/* The following devices are the same on devfs and non-devfs systems. */ 1100#define CURRENT_TTY "/dev/tty" 1101#define DEV_CONSOLE "/dev/console" 1102 1103 1104#ifndef RB_POWER_OFF 1105/* Stop system and switch power off if possible. */ 1106#define RB_POWER_OFF 0x4321fedc 1107#endif 1108 1109/* Make sure we call functions instead of macros. */ 1110#undef isalnum 1111#undef isalpha 1112#undef isascii 1113#undef isblank 1114#undef iscntrl 1115#undef isgraph 1116#undef islower 1117#undef isprint 1118#undef ispunct 1119#undef isspace 1120#undef isupper 1121#undef isxdigit 1122 1123/* This one is more efficient - we save ~400 bytes */ 1124#undef isdigit 1125#define isdigit(a) ((unsigned)((a) - '0') <= 9) 1126 1127 1128#ifdef DMALLOC 1129#include <dmalloc.h> 1130#endif 1131 1132 1133#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) 1134 1135#endif /* __LIBBUSYBOX_H__ */ 1136