Ignore:
Timestamp:
Nov 6, 2007, 11:01:53 AM (16 years ago)
Author:
Bruno Cornec
Message:
  • Better output for mindi-busybox revision
  • Remove dummy file created on NFS - report from Arnaud Tiger <arnaud.tiger_at_hp.com>
  • strace useful for debug
  • fix new versions for pb (2.0.0 for mindi and 1.7.2 for mindi-busybox)
  • fix build process for mindi-busybox + options used in that version (dd for label-partitions-as-necessary)
  • fix typo in label-partitions-as-necessary which doesn't seem to work
  • Update to busybox 1.7.2
  • perl is now required at restore time to support uuid swap partitions (and will be used for many other thigs

in the future for sure)

  • next mindi version will be 2.0.0 due to all the changes made in it (udev may break working distros)
  • small optimization in mindi on keyboard handling (one single find instead of multiple)
  • better interaction for USB device when launching mindi manually
  • attempt to automatically guess block disk size for ramdisk
  • fix typos in bkphw
  • Fix the remaining problem with UUID support for swap partitions
  • Updates mondoarchive man page for USB support
  • Adds preliminary Hardware support to mindi (Proliant SSSTK)
  • Tries to add udev support also for rhel4
  • Fix UUID support which was still broken.
  • Be conservative in test for the start-nfs script
  • Update config file for mindi-busybox for 1.7.2 migration
  • Try to run around a busybox bug (1.2.2 pb on inexistant links)
  • Add build content for mindi-busybox in pb
  • Remove distributions content for mindi-busybox
  • Fix a warning on inexistant raidtab
  • Solve problem on tmpfs in restore init (Problem of inexistant symlink and busybox)
  • Create MONDO_CACHE and use it everywhere + creation at start
  • Really never try to eject a USB device
  • Fix a issue with &> usage (replaced with 1> and 2>)
  • Adds magic file to depllist in order to have file working + ldd which helps for debugging issues
  • tty modes correct to avoid sh error messages
  • Use ext3 normally and not ext2 instead
  • USB device should be corrected after reading (take 1st part)
  • Adds a mount_USB_here function derived from mount_CDROM_here
  • usb detection place before /dev detection in device name at restore time
  • Fix when restoring from USB: media is asked in interactive mode
  • Adds USB support for mondorestore
  • mount_cdrom => mount_media
  • elilo.efi is now searched throughout /boot/efi and not in a fixed place as there is no standard
  • untar-and-softlink => untar (+ interface change)
  • suppress useless softlinks creation/removal in boot process
  • avoids udevd messages on groups
  • Increase # of disks to 99 as in mindi at restore time (should be a conf file parameter)
  • skip existing big file creation
  • seems to work correctly for USB mindi boot
  • Adds group and tty link to udev conf
  • Always load usb-torage (even 2.6) to initiate USB bus discovery
  • Better printing of messages
  • Attempt to fix a bug in supporting OpenSusE 10.3 kernel for initramfs (mindi may now use multiple regex for kernel initrd detection)
  • Links were not correctly done as non relative for modules in mindi
  • exclusion of modules denied now works
  • Also create modules in their ordinary place, so that classical modprobe works + copy modules.dep
  • Fix bugs for DENY_MODS handling
  • Add device /dev/console for udev
  • ide-generic should now really be excluded
  • Fix a bug in major number for tty
  • If udev then adds modprobe/insmod to rootfs
  • tty0 is also cretaed with udev
  • ide-generic put rather in DENY_MODS
  • udevd remove from deplist s handled in mindi directly
  • better default for mindi when using --usb
  • Handles dynamically linked busybox (in case we want to use it soon ;-)
  • Adds fixed devices to create for udev
  • ide-generic should not be part of the initrd when using libata v2
  • support a dynamically linked udev (case on Ubuntu 7.10 and Mandriva 2008.0 so should be quite generic) This will give incitation to move to dyn. linked binaries in the initrd which will help for other tasks (ia6 4)
  • Improvement in udev support (do not use cl options not available in busybox)
  • Udev in mindi
    • auto creation of the right links at boot time with udev-links.conf(from Mandriva 2008.0)
    • rework startup of udev as current makes kernel crash (from Mandriva 2008.0)
    • add support for 64 bits udev
  • Try to render MyInsmod silent at boot time
  • Adds udev support (mandatory for newest distributions to avoid remapping of devices in a different way as on the original system)
  • We also need vaft format support for USB boot
  • Adds libusual support (Ubuntu 7.10 needs it for USB)
  • Improve Ubuntu/Debian keyboard detection and support
  • pbinit adapted to new pb (0.8.10). Filtering of docs done in it
  • Suppress some mondo warnings and errors on USB again
  • Tries to fix lack of files in deb mindi package
  • Verify should now work for USB devices
  • More log/mesages improvement for USB support
  • - Supress g_erase_tmpdir_and_scratchdir
  • Improve some log messages for USB support
  • Try to improve install in mindi to avoid issues with isolinux.cfg not installed vene if in the pkg :-(
  • Improve mindi-busybox build
  • In conformity with pb 0.8.9
  • Add support for Ubuntu 7.10 in build process
  • Add USB Key button to Menu UI (CD streamer removed)
  • Attempt to fix error messages on tmp/scratch files at the end by removing those dir at the latest possible.
  • Fix a bug linked to the size of the -E param which could be used (Arnaud Tiger/René Ribaud).
  • Integrate ~/.pbrc content into mondorescue.pb (required project-builder >= 0.8.7)
  • Put mondorescue in conformity with new pb filtering rules
  • Add USB support at restore time (no test done yet). New start-usb script PB varibale added where useful
  • Unmounting USB device before removal of temporary scratchdir
  • Stil refining USB copy back to mondo (one command was not executed)
  • No need to have the image subdor in the csratchdir when USB.
  • umount the USB partition before attempting to use it
  • Remove useless copy from mindi to mondo at end of USB handling

(risky merge, we are raising the limits of 2 diverging branches. The status of stable is not completely sure as such. Will need lots of tests, but it's not yet done :-()
(merge -r1692:1769 $SVN_M/branches/2.2.5)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/stable/mindi-busybox/include/libbb.h

    r821 r1770  
    33 * Busybox main internal header file
    44 *
    5  * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
    6  *
    75 * Based in part on code from sash, Copyright (c) 1999 by David I. Bell
    86 * Permission has been granted to redistribute this code under the GPL.
    97 *
     8 * Licensed under the GPL version 2, see the file LICENSE in this tarball.
    109 */
    1110#ifndef __LIBBUSYBOX_H__
    1211#define __LIBBUSYBOX_H__    1
    1312
    14 #include "bb_config.h"
    1513#include "platform.h"
    1614
    1715#include <ctype.h>
    1816#include <dirent.h>
     17#include <errno.h>
    1918#include <fcntl.h>
    2019#include <inttypes.h>
     20#include <mntent.h>
    2121#include <netdb.h>
     22#include <setjmp.h>
     23#include <signal.h>
    2224#include <stdio.h>
    2325#include <stdlib.h>
    2426#include <stdarg.h>
     27#include <stddef.h>
    2528#include <string.h>
    26 #include <strings.h>
     29/* #include <strings.h> - said to be obsolete */
     30#include <sys/ioctl.h>
     31#include <sys/mman.h>
    2732#include <sys/socket.h>
    2833#include <sys/stat.h>
     34#include <sys/statfs.h>
    2935#include <sys/time.h>
    3036#include <sys/types.h>
     37#include <sys/wait.h>
    3138#include <termios.h>
     39#include <time.h>
    3240#include <unistd.h>
    33 
    34 #ifdef CONFIG_SELINUX
     41#include <utime.h>
     42
     43#if ENABLE_SELINUX
    3544#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)
    3652#endif
    3753
    3854#include "pwd_.h"
    3955#include "grp_.h"
    40 #ifdef CONFIG_FEATURE_SHADOWPASSWDS
     56/* ifdef it out, because it may include <shadow.h> */
     57/* and we may not even _have_ <shadow.h>! */
     58#if ENABLE_FEATURE_SHADOWPASSWDS
    4159#include "shadow_.h"
    42 #endif
    43 #ifdef CONFIG_FEATURE_SHA1_PASSWORDS
    44 # include "sha1.h"
    4560#endif
    4661
    … …  
    4964#include <sys/param.h>
    5065#ifndef PATH_MAX
    51 #define  PATH_MAX         256
    52 #endif
    53 
    54 #ifdef DMALLOC
    55 #include <dmalloc.h>
    56 #endif
     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)))
    57125
    58126/* Some useful definitions */
    … …  
    81149
    82150/* buffer allocation schemes */
    83 #ifdef CONFIG_FEATURE_BUFFERS_GO_ON_STACK
    84 #define RESERVE_CONFIG_BUFFER(buffer,len)           char buffer[len]
     151#if ENABLE_FEATURE_BUFFERS_GO_ON_STACK
     152#define RESERVE_CONFIG_BUFFER(buffer,len)  char buffer[len]
    85153#define RESERVE_CONFIG_UBUFFER(buffer,len) unsigned char buffer[len]
    86154#define RELEASE_CONFIG_BUFFER(buffer)      ((void)0)
    87155#else
    88 #ifdef CONFIG_FEATURE_BUFFERS_GO_IN_BSS
     156#if ENABLE_FEATURE_BUFFERS_GO_IN_BSS
    89157#define RESERVE_CONFIG_BUFFER(buffer,len)  static          char buffer[len]
    90158#define RESERVE_CONFIG_UBUFFER(buffer,len) static unsigned char buffer[len]
    91159#define RELEASE_CONFIG_BUFFER(buffer)      ((void)0)
    92160#else
    93 #define RESERVE_CONFIG_BUFFER(buffer,len)           char *buffer=xmalloc(len)
    94 #define RESERVE_CONFIG_UBUFFER(buffer,len) unsigned char *buffer=xmalloc(len)
    95 #define RELEASE_CONFIG_BUFFER(buffer)      free (buffer)
    96 #endif
    97 #endif
    98 
    99 
    100 typedef struct llist_s {
    101     char *data;
    102     struct llist_s *link;
    103 } llist_t;
    104 extern void llist_add_to(llist_t **old_head, void *data);
    105 extern void llist_add_to_end(llist_t **list_head, void *data);
    106 extern void *llist_pop(llist_t **elm);
    107 extern void llist_free(llist_t *elm, void (*freeit)(void *data));
    108 
    109 
    110 extern void bb_show_usage(void) ATTRIBUTE_NORETURN ATTRIBUTE_EXTERNALLY_VISIBLE;
    111 extern void bb_error_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2)));
    112 extern void bb_error_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2)));
    113 extern void bb_perror_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2)));
    114 extern void bb_perror_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2)));
    115 extern void bb_vherror_msg(const char *s, va_list p);
    116 extern void bb_herror_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2)));
    117 extern void bb_herror_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2)));
    118 
    119 extern void bb_perror_nomsg_and_die(void) ATTRIBUTE_NORETURN;
    120 extern void bb_perror_nomsg(void);
    121 
    122 /* These two are used internally -- you shouldn't need to use them */
    123 extern void bb_verror_msg(const char *s, va_list p) __attribute__ ((format (printf, 1, 0)));
    124 extern void bb_vperror_msg(const char *s, va_list p)  __attribute__ ((format (printf, 1, 0)));
    125 
    126 extern int bb_echo(int argc, char** argv);
    127 extern int bb_test(int argc, char** argv);
    128 
    129 extern const char *bb_mode_string(int mode);
    130 extern int is_directory(const char *name, int followLinks, struct stat *statBuf);
    131 extern DIR *bb_opendir(const char *path);
    132 extern DIR *bb_xopendir(const char *path);
    133 
    134 extern int remove_file(const char *path, int flags);
    135 extern int copy_file(const char *source, const char *dest, int flags);
    136 extern ssize_t safe_read(int fd, void *buf, size_t count);
    137 extern ssize_t bb_full_read(int fd, void *buf, size_t len);
    138 extern ssize_t safe_write(int fd, const void *buf, size_t count);
    139 extern ssize_t bb_full_write(int fd, const void *buf, size_t len);
    140 extern int recursive_action(const char *fileName, int recurse,
    141       int followLinks, int depthFirst,
    142       int (*fileAction) (const char *fileName, struct stat* statbuf, void* userData),
    143       int (*dirAction) (const char *fileName, struct stat* statbuf, void* userData),
    144       void* userData);
    145 
    146 extern int bb_parse_mode( const char* s, mode_t* theMode);
    147 extern long bb_xgetlarg(const char *arg, int base, long lower, long upper);
    148 
    149 extern unsigned int tty_baud_to_value(speed_t speed);
    150 extern speed_t tty_value_to_baud(unsigned int value);
    151 
    152 extern int get_linux_version_code(void);
    153 
    154 extern int get_console_fd(void);
    155 extern struct mntent *find_mount_point(const char *name, const char *table);
    156 extern void erase_mtab(const char * name);
    157 extern long *find_pid_by_name( const char* pidName);
    158 extern long *pidlist_reverse(long *pidList);
    159 extern char *find_block_device(char *path);
    160 extern char *bb_get_line_from_file(FILE *file);
    161 extern char *bb_get_chomped_line_from_file(FILE *file);
    162 extern char *bb_get_chunk_from_file(FILE *file, int *end);
    163 extern int bb_copyfd_size(int fd1, int fd2, const off_t size);
    164 extern int bb_copyfd_eof(int fd1, int fd2);
    165 extern void  bb_xprint_and_close_file(FILE *file);
    166 extern int   bb_xprint_file_by_name(const char *filename);
    167 extern char  bb_process_escape_sequence(const char **ptr);
    168 extern char *bb_get_last_path_component(char *path);
    169 extern FILE *bb_wfopen(const char *path, const char *mode);
    170 extern FILE *bb_wfopen_input(const char *filename);
    171 extern FILE *bb_xfopen(const char *path, const char *mode);
    172 
    173 extern int   bb_fclose_nonstdin(FILE *f);
    174 extern void  bb_fflush_stdout_and_exit(int retval) ATTRIBUTE_NORETURN;
    175 
    176 extern void xstat(const char *filename, struct stat *buf);
    177 extern int  bb_xsocket(int domain, int type, int protocol);
    178 extern pid_t bb_spawn(char **argv);
    179 extern pid_t bb_xspawn(char **argv);
    180 extern int wait4pid(int pid);
    181 extern void bb_xdaemon(int nochdir, int noclose);
    182 extern void bb_xbind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen);
    183 extern void bb_xlisten(int s, int backlog);
    184 extern void bb_xchdir(const char *path);
    185 extern void xsetgid(gid_t gid);
    186 extern void xsetuid(uid_t uid);
    187 
    188 #define BB_GETOPT_ERROR 0x80000000UL
    189 extern const char *bb_opt_complementally;
    190 extern const struct option *bb_applet_long_options;
    191 extern unsigned long bb_getopt_ulflags(int argc, char **argv, const char *applet_opts, ...);
    192 
    193 extern int bb_vfprintf(FILE * __restrict stream, const char * __restrict format,
    194                        va_list arg) __attribute__ ((format (printf, 2, 0)));
    195 extern int bb_vprintf(const char * __restrict format, va_list arg)
    196     __attribute__ ((format (printf, 1, 0)));
    197 extern int bb_fprintf(FILE * __restrict stream, const char * __restrict format, ...)
    198     __attribute__ ((format (printf, 2, 3)));
    199 extern int bb_printf(const char * __restrict format, ...)
    200     __attribute__ ((format (printf, 1, 2)));
    201 
    202 //#warning rename to xferror_filename?
    203 extern void bb_xferror(FILE *fp, const char *fn);
    204 extern void bb_xferror_stdout(void);
    205 extern void bb_xfflush_stdout(void);
    206 
    207 extern void bb_warn_ignoring_args(int n);
    208 
    209 extern void chomp(char *s);
    210 extern void trim(char *s);
    211 extern char *skip_whitespace(const char *);
    212 
    213 extern struct BB_applet *find_applet_by_name(const char *name);
    214 void run_applet_by_name(const char *name, int argc, char **argv);
    215 
    216 /* dmalloc will redefine these to it's own implementation. It is safe
    217  * to have the prototypes here unconditionally.  */
    218 extern void *xmalloc(size_t size);
    219 extern void *xrealloc(void *old, size_t size);
    220 extern void *xzalloc(size_t size);
    221 extern void *xcalloc(size_t nmemb, size_t size);
    222 
    223 extern char *bb_xstrdup (const char *s);
    224 extern char *bb_xstrndup (const char *s, int n);
    225 extern char *safe_strncpy(char *dst, const char *src, size_t size);
    226 extern int safe_strtoi(char *arg, int* value);
    227 extern int safe_strtod(char *arg, double* value);
    228 extern int safe_strtol(char *arg, long* value);
    229 extern int safe_strtoul(char *arg, unsigned long* value);
    230 
    231 struct suffix_mult {
    232     const char *suffix;
    233     unsigned int mult;
    234 };
    235 
    236 extern unsigned long bb_xgetularg_bnd_sfx(const char *arg, int base,
    237                                           unsigned long lower,
    238                                           unsigned long upper,
    239                                           const struct suffix_mult *suffixes);
    240 extern unsigned long bb_xgetularg_bnd(const char *arg, int base,
    241                                       unsigned long lower,
    242                                       unsigned long upper);
    243 extern unsigned long bb_xgetularg10_bnd(const char *arg,
    244                                         unsigned long lower,
    245                                         unsigned long upper);
    246 extern unsigned long bb_xgetularg10(const char *arg);
    247 
    248 extern long bb_xgetlarg_bnd_sfx(const char *arg, int base,
    249                                 long lower,
    250                                 long upper,
    251                                 const struct suffix_mult *suffixes);
    252 extern long bb_xgetlarg10_sfx(const char *arg, const struct suffix_mult *suffixes);
    253 
    254 
    255 //#warning pitchable now?
    256 extern unsigned long bb_xparse_number(const char *numstr,
    257         const struct suffix_mult *suffixes);
    258 
    259 
    260 /* These parse entries in /etc/passwd and /etc/group.  This is desirable
    261  * for BusyBox since we want to avoid using the glibc NSS stuff, which
    262  * increases target size and is often not needed on embedded systems.  */
    263 extern long bb_xgetpwnam(const char *name);
    264 extern long bb_xgetgrnam(const char *name);
    265 extern char * bb_getug(char *buffer, char *idname, long id, int bufsize, char prefix);
    266 extern char * bb_getpwuid(char *name, long uid, int bufsize);
    267 extern char * bb_getgrgid(char *group, long gid, int bufsize);
    268 extern char *bb_askpass(int timeout, const char * prompt);
    269 
    270 extern int device_open(const char *device, int mode);
    271 
    272 extern char *query_loop(const char *device);
    273 extern int del_loop(const char *device);
    274 extern int set_loop(char **device, const char *file, int offset);
    275 
    276 #if (__GLIBC__ < 2)
    277 extern int vdprintf(int d, const char *format, va_list ap);
    278 #endif
    279 
    280 int nfsmount(const char *spec, const char *node, int *flags,
    281          char **mount_opts, int running_bg);
    282 
     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);
    283183/* Include our own copy of struct sysinfo to avoid binary compatibility
    284184 * problems with Linux 2.4, which changed things.  Grumble, grumble. */
    … …  
    299199    char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding: libc5 uses this.. */
    300200};
    301 extern int sysinfo (struct sysinfo* info);
    302 
     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);
    303216enum {
    304     KILOBYTE = 1024,
    305     MEGABYTE = (KILOBYTE*1024),
    306     GIGABYTE = (MEGABYTE*1024)
    307 };
     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)?
    308457const char *make_human_readable_str(unsigned long long size,
    309458        unsigned long block_size, unsigned long display_unit);
    310 
     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);
    311752int bb_ask_confirmation(void);
    312753int klogctl(int type, char * b, int len);
    313754
    314 char *xgetcwd(char *cwd);
    315 char *xreadlink(const char *path);
     755extern int bb_parse_mode(const char* s, mode_t* theMode);
     756
    316757char *concat_path_file(const char *path, const char *filename);
    317758char *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) */
    318761char *last_char_is(const char *s, int c);
    319762
    320 int read_package_field(const char *package_buffer, char **field_name, char **field_value);
    321 //#warning yuk!
    322 char *fgets_str(FILE *file, const char *terminating_string);
    323 
    324 extern int uncompress(int fd_in, int fd_out);
    325 extern int inflate(int in, int out);
    326 
    327 extern struct hostent *xgethostbyname(const char *name);
    328 extern struct hostent *xgethostbyname2(const char *name, int af);
    329 extern int create_icmp_socket(void);
    330 extern int create_icmp6_socket(void);
    331 extern int xconnect(struct sockaddr_in *s_addr);
    332 extern unsigned short bb_lookup_port(const char *port, const char *protocol, unsigned short default_port);
    333 extern void bb_lookup_host(struct sockaddr_in *s_in, const char *host);
    334 
    335 //#warning wrap this?
    336 char *dirname (char *path);
    337 
    338 int bb_make_directory (char *path, long mode, int flags);
    339 
    340 const char *u_signal_names(const char *str_sig, int *signo, int startnum);
     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
    341773char *bb_simplify_path(const char *path);
    342774
    343 enum {  /* DO NOT CHANGE THESE VALUES!  cp.c depends on them. */
     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. */
    344974    FILEUTILS_PRESERVE_STATUS = 1,
    345975    FILEUTILS_DEREFERENCE = 2,
    346976    FILEUTILS_RECUR = 4,
    347977    FILEUTILS_FORCE = 8,
    348     FILEUTILS_INTERACTIVE = 16
    349 };
    350 
    351 extern const char *bb_applet_name;
    352 
    353 extern const char * const bb_msg_full_version;
    354 extern const char * const bb_msg_memory_exhausted;
    355 extern const char * const bb_msg_invalid_date;
    356 extern const char * const bb_msg_io_error;
    357 extern const char * const bb_msg_read_error;
    358 extern const char * const bb_msg_write_error;
    359 extern const char * const bb_msg_name_longer_than_foo;
    360 extern const char * const bb_msg_unknown;
    361 extern const char * const bb_msg_can_not_create_raw_socket;
    362 extern const char * const bb_msg_perm_denied_are_you_root;
    363 extern const char * const bb_msg_requires_arg;
    364 extern const char * const bb_msg_invalid_arg;
    365 extern const char * const bb_msg_standard_input;
    366 extern const char * const bb_msg_standard_output;
    367 
    368 extern const char * const bb_path_nologin_file;
    369 extern const char * const bb_path_passwd_file;
    370 extern const char * const bb_path_shadow_file;
    371 extern const char * const bb_path_gshadow_file;
    372 extern const char * const bb_path_group_file;
    373 extern const char * const bb_path_securetty_file;
    374 extern const char * const bb_path_motd_file;
    375 extern const char * const bb_path_wtmp_file;
    376 extern const char * const bb_dev_null;
     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
    3771026
    3781027#ifndef BUFSIZ
    3791028#define BUFSIZ 4096
    3801029#endif
    381 extern char bb_common_bufsiz1[BUFSIZ+1];
    382 
    383 /*
    384  * You can change LIBBB_DEFAULT_LOGIN_SHELL, but don`t use,
    385  * use bb_default_login_shell and next defines,
    386  * if you LIBBB_DEFAULT_LOGIN_SHELL change,
    387  * don`t lose change increment constant!
    388  */
     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;
     1036/* '*const' ptr makes gcc optimize code much better.
     1037 * Magic prevents ptr_to_globals from going into rodata.
     1038 * If you want to assign a value, use PTR_TO_GLOBALS = xxx */
     1039extern struct globals *const ptr_to_globals;
     1040#define PTR_TO_GLOBALS (*(struct globals**)&ptr_to_globals)
     1041
     1042
     1043/* You can change LIBBB_DEFAULT_LOGIN_SHELL, but don't use it,
     1044 * use bb_default_login_shell and following defines.
     1045 * If you change LIBBB_DEFAULT_LOGIN_SHELL,
     1046 * don't forget to change increment constant. */
    3891047#define LIBBB_DEFAULT_LOGIN_SHELL      "-/bin/sh"
    390 
    391 extern const char * const bb_default_login_shell;
     1048extern const char bb_default_login_shell[];
    3921049/* "/bin/sh" */
    3931050#define DEFAULT_SHELL     (bb_default_login_shell+1)
    … …  
    3961053
    3971054
    398 extern const char bb_path_mtab_file[];
    399 
    400 extern int bb_default_error_retval;
    401 
    402 #ifdef CONFIG_FEATURE_DEVFS
     1055#if ENABLE_FEATURE_DEVFS
    4031056# define CURRENT_VC "/dev/vc/0"
    4041057# define VC_1 "/dev/vc/1"
    … …  
    4211074# define VC_FORMAT "/dev/vc/%d"
    4221075# define LOOP_FORMAT "/dev/loop/%d"
     1076# define LOOP_NAMESIZE (sizeof("/dev/loop/") + sizeof(int)*3 + 1)
     1077# define LOOP_NAME "/dev/loop/"
    4231078# define FB_0 "/dev/fb/0"
    4241079#else
    … …  
    4401095# define VC_FORMAT "/dev/tty%d"
    4411096# define LOOP_FORMAT "/dev/loop%d"
     1097# define LOOP_NAMESIZE (sizeof("/dev/loop") + sizeof(int)*3 + 1)
     1098# define LOOP_NAME "/dev/loop"
    4421099# define FB_0 "/dev/fb0"
    4431100#endif
    444 
    445 //#warning put these in .o files
    4461101
    4471102/* The following devices are the same on devfs and non-devfs systems.  */
    4481103#define CURRENT_TTY "/dev/tty"
    449 #define CONSOLE_DEV "/dev/console"
    450 
    451 int is_in_ino_dev_hashtable(const struct stat *statbuf, char **name);
    452 void add_to_ino_dev_hashtable(const struct stat *statbuf, const char *name);
    453 void reset_ino_dev_hashtable(void);
    454 
    455 char *bb_xasprintf(const char *format, ...) __attribute__ ((format (printf, 1, 2)));
    456 
    457 #define FAIL_DELAY    3
    458 extern void bb_do_delay(int seconds);
    459 extern void change_identity ( const struct passwd *pw );
    460 extern const char *change_identity_e2str ( const struct passwd *pw );
    461 extern void run_shell ( const char *shell, int loginshell, const char *command, const char **additional_args);
    462 #ifdef CONFIG_SELINUX
    463 extern void renew_current_security_context(void);
    464 extern void set_current_security_context(security_context_t sid);
    465 #endif
    466 extern int run_parts(char **args, const unsigned char test_mode, char **env);
    467 extern int restricted_shell ( const char *shell );
    468 extern void setup_environment ( const char *shell, int loginshell, int changeenv, const struct passwd *pw );
    469 extern int correct_password ( const struct passwd *pw );
    470 extern char *pw_encrypt(const char *clear, const char *salt);
    471 extern struct spwd *pwd_to_spwd(const struct passwd *pw);
    472 extern int obscure(const char *old, const char *newval, const struct passwd *pwdp);
    473 
    474 extern int bb_xopen(const char *pathname, int flags);
    475 extern int bb_xopen3(const char *pathname, int flags, int mode);
    476 extern ssize_t bb_xread(int fd, void *buf, size_t count);
    477 extern void bb_xread_all(int fd, void *buf, size_t count);
    478 extern unsigned char bb_xread_char(int fd);
    479 
    480 #ifndef COMM_LEN
    481 #ifdef TASK_COMM_LEN
    482 #define COMM_LEN TASK_COMM_LEN
    483 #else
    484 /* synchronize with sizeof(task_struct.comm) in /usr/include/linux/sched.h */
    485 #define COMM_LEN 16
    486 #endif
    487 #endif
    488 typedef struct {
    489     int pid;
    490     char user[9];
    491     char state[4];
    492     unsigned long rss;
    493     int ppid;
    494 #ifdef CONFIG_FEATURE_TOP_CPU_USAGE_PERCENTAGE
    495     unsigned pcpu;
    496     unsigned pscpu;
    497     unsigned long stime, utime;
    498 #endif
    499     char *cmd;
    500 
    501     /* basename of executable file in call to exec(2),
    502         size from kernel headers */
    503     char short_cmd[COMM_LEN];
    504 } procps_status_t;
    505 
    506 extern procps_status_t * procps_scan(int save_user_arg0);
    507 extern int compare_string_array(const char * const string_array[], const char *key);
    508 
    509 extern int my_query_module(const char *name, int which, void **buf, size_t *bufsize, size_t *ret);
    510 
    511 extern void print_login_issue(const char *issue_file, const char *tty);
    512 extern void print_login_prompt(void);
    513 
    514 #ifdef BB_NOMMU
    515 extern void vfork_daemon(int nochdir, int noclose);
    516 extern void vfork_daemon_rexec(int nochdir, int noclose,
    517         int argc, char **argv, char *foreground_opt);
    518 #endif
    519 
    520 extern int get_terminal_width_height(int fd, int *width, int *height);
    521 extern unsigned long get_ug_id(const char *s, long (*__bb_getxxnam)(const char *));
    522 
    523 typedef struct _sha1_ctx_t_ {
    524     uint32_t count[2];
    525     uint32_t hash[5];
    526     uint32_t wbuf[16];
    527 } sha1_ctx_t;
    528 
    529 void sha1_begin(sha1_ctx_t *ctx);
    530 void sha1_hash(const void *data, size_t length, sha1_ctx_t *ctx);
    531 void *sha1_end(void *resbuf, sha1_ctx_t *ctx);
    532 
    533 typedef struct _md5_ctx_t_ {
    534     uint32_t A;
    535     uint32_t B;
    536     uint32_t C;
    537     uint32_t D;
    538     uint64_t total;
    539     uint32_t buflen;
    540     char buffer[128];
    541 } md5_ctx_t;
    542 
    543 void md5_begin(md5_ctx_t *ctx);
    544 void md5_hash(const void *data, size_t length, md5_ctx_t *ctx);
    545 void *md5_end(void *resbuf, md5_ctx_t *ctx);
    546 
    547 extern uint32_t *bb_crc32_filltable (int endian);
     1104#define DEV_CONSOLE "/dev/console"
     1105
    5481106
    5491107#ifndef RB_POWER_OFF
    … …  
    5521110#endif
    5531111
    554 extern const char BB_BANNER[];
     1112/* Make sure we call functions instead of macros.  */
     1113#undef isalnum
     1114#undef isalpha
     1115#undef isascii
     1116#undef isblank
     1117#undef iscntrl
     1118#undef isgraph
     1119#undef islower
     1120#undef isprint
     1121#undef ispunct
     1122#undef isspace
     1123#undef isupper
     1124#undef isxdigit
     1125
     1126/* This one is more efficient - we save ~400 bytes */
     1127#undef isdigit
     1128#define isdigit(a) ((unsigned)((a) - '0') <= 9)
     1129
     1130
     1131#ifdef DMALLOC
     1132#include <dmalloc.h>
     1133#endif
     1134
     1135
     1136#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
    5551137
    5561138#endif /* __LIBBUSYBOX_H__ */
Note: See TracChangeset for help on using the changeset viewer.