libbb.h 88 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372
  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 GPL.
  7. *
  8. * Licensed under GPLv2, see file LICENSE in this source tree.
  9. */
  10. #ifndef LIBBB_H
  11. #define LIBBB_H 1
  12. #include "platform.h"
  13. #include <ctype.h>
  14. #include <dirent.h>
  15. #include <errno.h>
  16. #include <fcntl.h>
  17. #include <inttypes.h>
  18. #include <netdb.h>
  19. #include <setjmp.h>
  20. #include <signal.h>
  21. #include <paths.h>
  22. #if defined __UCLIBC__ /* TODO: and glibc? */
  23. /* use inlined versions of these: */
  24. # define sigfillset(s) __sigfillset(s)
  25. # define sigemptyset(s) __sigemptyset(s)
  26. # define sigisemptyset(s) __sigisemptyset(s)
  27. #endif
  28. #include <stdint.h>
  29. #include <stdio.h>
  30. #include <stdlib.h>
  31. #include <stdarg.h>
  32. #include <stddef.h>
  33. #include <string.h>
  34. /* There are two incompatible basename's, let's not use them! */
  35. /* See the dirname/basename man page for details */
  36. #include <libgen.h> /* dirname,basename */
  37. #undef basename
  38. #define basename dont_use_basename
  39. #include <poll.h>
  40. #include <sys/ioctl.h>
  41. #include <sys/mman.h>
  42. #include <sys/resource.h>
  43. #include <sys/socket.h>
  44. #include <sys/stat.h>
  45. #include <sys/time.h>
  46. #include <sys/types.h>
  47. #if !defined(major) || defined(__GLIBC__)
  48. # include <sys/sysmacros.h>
  49. #endif
  50. #include <sys/wait.h>
  51. #include <termios.h>
  52. #include <time.h>
  53. #include <sys/param.h>
  54. #include <pwd.h>
  55. #include <grp.h>
  56. #if ENABLE_FEATURE_SHADOWPASSWDS
  57. # if !ENABLE_USE_BB_SHADOW
  58. /* If using busybox's shadow implementation, do not include the shadow.h
  59. * header as the toolchain may not provide it at all.
  60. */
  61. # include <shadow.h>
  62. # endif
  63. #endif
  64. #if defined(ANDROID) || defined(__ANDROID__)
  65. # define endpwent() ((void)0)
  66. # define endgrent() ((void)0)
  67. #endif
  68. #ifdef HAVE_MNTENT_H
  69. # include <mntent.h>
  70. #endif
  71. #ifdef HAVE_SYS_STATFS_H
  72. # include <sys/statfs.h>
  73. #endif
  74. /* Don't do this here:
  75. * #include <sys/sysinfo.h>
  76. * Some linux/ includes pull in conflicting definition
  77. * of struct sysinfo (only in some toolchanins), which breaks build.
  78. * Include sys/sysinfo.h only in those files which need it.
  79. */
  80. #if ENABLE_SELINUX
  81. # include <selinux/selinux.h>
  82. # include <selinux/context.h>
  83. #endif
  84. #if ENABLE_FEATURE_UTMP
  85. # if defined __UCLIBC__ && ( \
  86. (UCLIBC_VERSION >= KERNEL_VERSION(0, 9, 32) \
  87. && UCLIBC_VERSION < KERNEL_VERSION(0, 9, 34) \
  88. && defined __UCLIBC_HAS_UTMPX__ \
  89. ) || ( \
  90. UCLIBC_VERSION >= KERNEL_VERSION(0, 9, 34) \
  91. ) \
  92. )
  93. # include <utmpx.h>
  94. # elif defined __UCLIBC__
  95. # include <utmp.h>
  96. # define utmpx utmp
  97. # define setutxent setutent
  98. # define endutxent endutent
  99. # define getutxent getutent
  100. # define getutxid getutid
  101. # define getutxline getutline
  102. # define pututxline pututline
  103. # define utmpxname utmpname
  104. # define updwtmpx updwtmp
  105. # define _PATH_UTMPX _PATH_UTMP
  106. # else
  107. # include <utmp.h>
  108. # include <utmpx.h>
  109. # if defined _PATH_UTMP && !defined _PATH_UTMPX
  110. # define _PATH_UTMPX _PATH_UTMP
  111. # endif
  112. # endif
  113. #endif
  114. #if ENABLE_LOCALE_SUPPORT
  115. # include <locale.h>
  116. #else
  117. # define setlocale(x,y) ((void)0)
  118. #endif
  119. #ifdef DMALLOC
  120. # include <dmalloc.h>
  121. #endif
  122. /* Just in case libc doesn't define some of these... */
  123. #ifndef _PATH_PASSWD
  124. #define _PATH_PASSWD "/etc/passwd"
  125. #endif
  126. #ifndef _PATH_GROUP
  127. #define _PATH_GROUP "/etc/group"
  128. #endif
  129. #ifndef _PATH_SHADOW
  130. #define _PATH_SHADOW "/etc/shadow"
  131. #endif
  132. #ifndef _PATH_GSHADOW
  133. #define _PATH_GSHADOW "/etc/gshadow"
  134. #endif
  135. #if defined __FreeBSD__ || defined __OpenBSD__
  136. # include <netinet/in.h>
  137. # include <arpa/inet.h>
  138. #elif defined __APPLE__
  139. # include <netinet/in.h>
  140. #else
  141. # include <arpa/inet.h>
  142. //This breaks on bionic:
  143. //# if !defined(__socklen_t_defined) && !defined(_SOCKLEN_T_DECLARED)
  144. ///* We #define socklen_t *after* includes, otherwise we get
  145. // * typedef redefinition errors from system headers
  146. // * (in case "is it defined already" detection above failed)
  147. // */
  148. //# define socklen_t bb_socklen_t
  149. // typedef unsigned socklen_t;
  150. //# endif
  151. //if this is still needed, add a fix along the lines of
  152. // ifdef SPECIFIC_BROKEN_LIBC_CHECK / typedef socklen_t / endif
  153. //in platform.h instead!
  154. #endif
  155. #ifndef HAVE_CLEARENV
  156. # define clearenv() do { if (environ) environ[0] = NULL; } while (0)
  157. #endif
  158. #ifndef HAVE_FDATASYNC
  159. # define fdatasync fsync
  160. #endif
  161. #ifndef HAVE_XTABS
  162. # define XTABS TAB3
  163. #endif
  164. /*
  165. * Use '%m' to append error string on platforms that support it,
  166. * '%s' and strerror() on those that don't.
  167. */
  168. #ifdef HAVE_PRINTF_PERCENTM
  169. # define STRERROR_FMT "%m"
  170. # define STRERROR_ERRNO /*nothing*/
  171. #else
  172. # define STRERROR_FMT "%s"
  173. # define STRERROR_ERRNO ,strerror(errno)
  174. #endif
  175. /* Some libc's forget to declare these, do it ourself */
  176. extern char **environ;
  177. /* klogctl is in libc's klog.h, but we cheat and not #include that */
  178. int klogctl(int type, char *b, int len);
  179. #ifndef PATH_MAX
  180. # define PATH_MAX 256
  181. #endif
  182. #ifndef BUFSIZ
  183. # define BUFSIZ 4096
  184. #endif
  185. /* Busybox does not use threads, we can speed up stdio. */
  186. #ifdef HAVE_UNLOCKED_STDIO
  187. # undef getc
  188. # define getc(stream) getc_unlocked(stream)
  189. # undef getchar
  190. # define getchar() getchar_unlocked()
  191. # undef putc
  192. # define putc(c,stream) putc_unlocked(c,stream)
  193. # undef putchar
  194. # define putchar(c) putchar_unlocked(c)
  195. # undef fgetc
  196. # define fgetc(stream) getc_unlocked(stream)
  197. # undef fputc
  198. # define fputc(c,stream) putc_unlocked(c,stream)
  199. #endif
  200. /* Above functions are required by POSIX.1-2008, below ones are extensions */
  201. #ifdef HAVE_UNLOCKED_LINE_OPS
  202. # undef fgets
  203. # define fgets(s,n,stream) fgets_unlocked(s,n,stream)
  204. # undef fputs
  205. # define fputs(s,stream) fputs_unlocked(s,stream)
  206. /* musl <= 1.1.15 does not support fflush_unlocked(NULL) */
  207. //# undef fflush
  208. //# define fflush(stream) fflush_unlocked(stream)
  209. # undef feof
  210. # define feof(stream) feof_unlocked(stream)
  211. # undef ferror
  212. # define ferror(stream) ferror_unlocked(stream)
  213. # undef fileno
  214. # define fileno(stream) fileno_unlocked(stream)
  215. #endif
  216. /* Make all declarations hidden (-fvisibility flag only affects definitions) */
  217. /* (don't include system headers after this until corresponding pop!) */
  218. PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN
  219. #if ENABLE_USE_BB_PWD_GRP
  220. # include "pwd_.h"
  221. # include "grp_.h"
  222. #endif
  223. #if ENABLE_FEATURE_SHADOWPASSWDS
  224. # if ENABLE_USE_BB_SHADOW
  225. # include "shadow_.h"
  226. # endif
  227. #endif
  228. /* Tested to work correctly with all int types (IIRC :]) */
  229. #define MAXINT(T) (T)( \
  230. ((T)-1) > 0 \
  231. ? (T)-1 \
  232. : (T)~((T)1 << (sizeof(T)*8-1)) \
  233. )
  234. #define MININT(T) (T)( \
  235. ((T)-1) > 0 \
  236. ? (T)0 \
  237. : ((T)1 << (sizeof(T)*8-1)) \
  238. )
  239. /* Large file support */
  240. /* Note that CONFIG_LFS=y forces bbox to be built with all common ops
  241. * (stat, lseek etc) mapped to "largefile" variants by libc.
  242. * Practically it means that open() automatically has O_LARGEFILE added
  243. * and all filesize/file_offset parameters and struct members are "large"
  244. * (in today's world - signed 64bit). For full support of large files,
  245. * we need a few helper #defines (below) and careful use of off_t
  246. * instead of int/ssize_t. No lseek64(), O_LARGEFILE etc necessary */
  247. #if ENABLE_LFS
  248. /* CONFIG_LFS is on */
  249. # if ULONG_MAX > 0xffffffff
  250. /* "long" is long enough on this system */
  251. typedef unsigned long uoff_t;
  252. # define XATOOFF(a) xatoul_range((a), 0, LONG_MAX)
  253. /* usage: sz = BB_STRTOOFF(s, NULL, 10); if (errno || sz < 0) die(); */
  254. # define BB_STRTOOFF bb_strtoul
  255. # define STRTOOFF strtoul
  256. /* usage: printf("size: %"OFF_FMT"d (%"OFF_FMT"x)\n", sz, sz); */
  257. # define OFF_FMT "l"
  258. # else
  259. /* "long" is too short, need "long long" */
  260. typedef unsigned long long uoff_t;
  261. # define XATOOFF(a) xatoull_range((a), 0, LLONG_MAX)
  262. # define BB_STRTOOFF bb_strtoull
  263. # define STRTOOFF strtoull
  264. # define OFF_FMT "ll"
  265. # endif
  266. #else
  267. /* CONFIG_LFS is off */
  268. # if UINT_MAX == 0xffffffff
  269. /* While sizeof(off_t) == sizeof(int), off_t is typedef'ed to long anyway.
  270. * gcc will throw warnings on printf("%d", off_t). Crap... */
  271. typedef unsigned long uoff_t;
  272. # define XATOOFF(a) xatoi_positive(a)
  273. # define BB_STRTOOFF bb_strtou
  274. # define STRTOOFF strtol
  275. # define OFF_FMT "l"
  276. # else
  277. typedef unsigned long uoff_t;
  278. # define XATOOFF(a) xatoul_range((a), 0, LONG_MAX)
  279. # define BB_STRTOOFF bb_strtoul
  280. # define STRTOOFF strtol
  281. # define OFF_FMT "l"
  282. # endif
  283. #endif
  284. /* scary. better ideas? (but do *test* them first!) */
  285. #define OFF_T_MAX ((off_t)~((off_t)1 << (sizeof(off_t)*8-1)))
  286. /* Users report bionic to use 32-bit off_t even if LARGEFILE support is requested.
  287. * We misdetected that. Don't let it build:
  288. */
  289. struct BUG_off_t_size_is_misdetected {
  290. char BUG_off_t_size_is_misdetected[sizeof(off_t) == sizeof(uoff_t) ? 1 : -1];
  291. };
  292. /* Some useful definitions */
  293. #undef FALSE
  294. #define FALSE ((int) 0)
  295. #undef TRUE
  296. #define TRUE ((int) 1)
  297. #undef SKIP
  298. #define SKIP ((int) 2)
  299. /* Macros for min/max. */
  300. #ifndef MIN
  301. #define MIN(a,b) (((a)<(b))?(a):(b))
  302. #endif
  303. #ifndef MAX
  304. #define MAX(a,b) (((a)>(b))?(a):(b))
  305. #endif
  306. /* buffer allocation schemes */
  307. #if ENABLE_FEATURE_BUFFERS_GO_ON_STACK
  308. #define RESERVE_CONFIG_BUFFER(buffer,len) char buffer[len]
  309. #define RESERVE_CONFIG_UBUFFER(buffer,len) unsigned char buffer[len]
  310. #define RELEASE_CONFIG_BUFFER(buffer) ((void)0)
  311. #else
  312. #if ENABLE_FEATURE_BUFFERS_GO_IN_BSS
  313. #define RESERVE_CONFIG_BUFFER(buffer,len) static char buffer[len]
  314. #define RESERVE_CONFIG_UBUFFER(buffer,len) static unsigned char buffer[len]
  315. #define RELEASE_CONFIG_BUFFER(buffer) ((void)0)
  316. #else
  317. #define RESERVE_CONFIG_BUFFER(buffer,len) char *buffer = xmalloc(len)
  318. #define RESERVE_CONFIG_UBUFFER(buffer,len) unsigned char *buffer = xmalloc(len)
  319. #define RELEASE_CONFIG_BUFFER(buffer) free(buffer)
  320. #endif
  321. #endif
  322. #if defined(__GLIBC__)
  323. /* glibc uses __errno_location() to get a ptr to errno */
  324. /* We can just memorize it once - no multithreading in busybox :) */
  325. extern int *const bb_errno;
  326. #undef errno
  327. #define errno (*bb_errno)
  328. #endif
  329. #if !(ULONG_MAX > 0xffffffff)
  330. /* Only 32-bit CPUs need this, 64-bit ones use inlined version */
  331. uint64_t bb_bswap_64(uint64_t x) FAST_FUNC;
  332. #endif
  333. unsigned long FAST_FUNC isqrt(unsigned long long N);
  334. unsigned long long monotonic_ns(void) FAST_FUNC;
  335. unsigned long long monotonic_us(void) FAST_FUNC;
  336. unsigned long long monotonic_ms(void) FAST_FUNC;
  337. unsigned monotonic_sec(void) FAST_FUNC;
  338. extern void chomp(char *s) FAST_FUNC;
  339. extern char *trim(char *s) FAST_FUNC;
  340. extern char *skip_whitespace(const char *) FAST_FUNC;
  341. extern char *skip_non_whitespace(const char *) FAST_FUNC;
  342. extern char *skip_dev_pfx(const char *tty_name) FAST_FUNC;
  343. extern char *strrstr(const char *haystack, const char *needle) FAST_FUNC;
  344. /* dmalloc will redefine these to it's own implementation. It is safe
  345. * to have the prototypes here unconditionally. */
  346. void *malloc_or_warn(size_t size) FAST_FUNC RETURNS_MALLOC;
  347. void *xmalloc(size_t size) FAST_FUNC RETURNS_MALLOC;
  348. void *xzalloc(size_t size) FAST_FUNC RETURNS_MALLOC;
  349. void *xrealloc(void *old, size_t size) FAST_FUNC;
  350. /* After v = xrealloc_vector(v, SHIFT, idx) it's ok to use
  351. * at least v[idx] and v[idx+1], for all idx values.
  352. * SHIFT specifies how many new elements are added (1:2, 2:4, ..., 8:256...)
  353. * when all elements are used up. New elements are zeroed out.
  354. * xrealloc_vector(v, SHIFT, idx) *MUST* be called with consecutive IDXs -
  355. * skipping an index is a bad bug - it may miss a realloc!
  356. */
  357. #define xrealloc_vector(vector, shift, idx) \
  358. xrealloc_vector_helper((vector), (sizeof((vector)[0]) << 8) + (shift), (idx))
  359. void* xrealloc_vector_helper(void *vector, unsigned sizeof_and_shift, int idx) FAST_FUNC;
  360. char *xstrdup(const char *s) FAST_FUNC RETURNS_MALLOC;
  361. char *xstrndup(const char *s, int n) FAST_FUNC RETURNS_MALLOC;
  362. void *xmemdup(const void *s, int n) FAST_FUNC RETURNS_MALLOC;
  363. //TODO: supply a pointer to char[11] buffer (avoid statics)?
  364. extern const char *bb_mode_string(mode_t mode) FAST_FUNC;
  365. extern int is_directory(const char *name, int followLinks) FAST_FUNC;
  366. enum { /* cp.c, mv.c, install.c depend on these values. CAREFUL when changing them! */
  367. FILEUTILS_PRESERVE_STATUS = 1 << 0, /* -p */
  368. FILEUTILS_DEREFERENCE = 1 << 1, /* !-d */
  369. FILEUTILS_RECUR = 1 << 2, /* -R */
  370. FILEUTILS_FORCE = 1 << 3, /* -f */
  371. FILEUTILS_INTERACTIVE = 1 << 4, /* -i */
  372. FILEUTILS_MAKE_HARDLINK = 1 << 5, /* -l */
  373. FILEUTILS_MAKE_SOFTLINK = 1 << 6, /* -s */
  374. FILEUTILS_DEREF_SOFTLINK = 1 << 7, /* -L */
  375. FILEUTILS_DEREFERENCE_L0 = 1 << 8, /* -H */
  376. /* -a = -pdR (mapped in cp.c) */
  377. /* -r = -dR (mapped in cp.c) */
  378. /* -P = -d (mapped in cp.c) */
  379. FILEUTILS_VERBOSE = (1 << 12) * ENABLE_FEATURE_VERBOSE, /* -v */
  380. FILEUTILS_UPDATE = 1 << 13, /* -u */
  381. FILEUTILS_NO_TARGET_DIR = 1 << 14, /* -T */
  382. #if ENABLE_SELINUX
  383. FILEUTILS_PRESERVE_SECURITY_CONTEXT = 1 << 15, /* -c */
  384. #endif
  385. FILEUTILS_RMDEST = 1 << (16 - !ENABLE_SELINUX), /* --remove-destination */
  386. /* bit 17 skipped for "cp --parents" */
  387. FILEUTILS_REFLINK = 1 << (18 - !ENABLE_SELINUX), /* cp --reflink=auto */
  388. FILEUTILS_REFLINK_ALWAYS = 1 << (19 - !ENABLE_SELINUX), /* cp --reflink[=always] */
  389. /*
  390. * Hole. cp may have some bits set here,
  391. * they should not affect remove_file()/copy_file()
  392. */
  393. #if ENABLE_SELINUX
  394. FILEUTILS_SET_SECURITY_CONTEXT = 1 << 30,
  395. #endif
  396. FILEUTILS_IGNORE_CHMOD_ERR = 1 << 31,
  397. };
  398. #define FILEUTILS_CP_OPTSTR "pdRfilsLHarPvuT" IF_SELINUX("c")
  399. extern int remove_file(const char *path, int flags) FAST_FUNC;
  400. /* NB: without FILEUTILS_RECUR in flags, it will basically "cat"
  401. * the source, not copy (unless "source" is a directory).
  402. * This makes "cp /dev/null file" and "install /dev/null file" (!!!)
  403. * work coreutils-compatibly. */
  404. extern int copy_file(const char *source, const char *dest, int flags) FAST_FUNC;
  405. enum {
  406. ACTION_RECURSE = (1 << 0),
  407. ACTION_FOLLOWLINKS = (1 << 1),
  408. ACTION_FOLLOWLINKS_L0 = (1 << 2),
  409. ACTION_DEPTHFIRST = (1 << 3),
  410. /*ACTION_REVERSE = (1 << 4), - unused */
  411. ACTION_QUIET = (1 << 5),
  412. ACTION_DANGLING_OK = (1 << 6),
  413. };
  414. typedef uint8_t recurse_flags_t;
  415. extern int recursive_action(const char *fileName, unsigned flags,
  416. int FAST_FUNC (*fileAction)(const char *fileName, struct stat* statbuf, void* userData, int depth),
  417. int FAST_FUNC (*dirAction)(const char *fileName, struct stat* statbuf, void* userData, int depth),
  418. void* userData, unsigned depth) FAST_FUNC;
  419. extern int device_open(const char *device, int mode) FAST_FUNC;
  420. enum { GETPTY_BUFSIZE = 16 }; /* more than enough for "/dev/ttyXXX" */
  421. extern int xgetpty(char *line) FAST_FUNC;
  422. extern int get_console_fd_or_die(void) FAST_FUNC;
  423. extern void console_make_active(int fd, const int vt_num) FAST_FUNC;
  424. extern char *find_block_device(const char *path) FAST_FUNC;
  425. /* bb_copyfd_XX print read/write errors and return -1 if they occur */
  426. extern off_t bb_copyfd_eof(int fd1, int fd2) FAST_FUNC;
  427. extern off_t bb_copyfd_size(int fd1, int fd2, off_t size) FAST_FUNC;
  428. extern void bb_copyfd_exact_size(int fd1, int fd2, off_t size) FAST_FUNC;
  429. /* "short" copy can be detected by return value < size */
  430. /* this helper yells "short read!" if param is not -1 */
  431. extern void complain_copyfd_and_die(off_t sz) NORETURN FAST_FUNC;
  432. extern char bb_process_escape_sequence(const char **ptr) FAST_FUNC;
  433. char* strcpy_and_process_escape_sequences(char *dst, const char *src) FAST_FUNC;
  434. /* xxxx_strip version can modify its parameter:
  435. * "/" -> "/"
  436. * "abc" -> "abc"
  437. * "abc/def" -> "def"
  438. * "abc/def/" -> "def" !!
  439. */
  440. char *bb_get_last_path_component_strip(char *path) FAST_FUNC;
  441. /* "abc/def/" -> "" and it never modifies 'path' */
  442. char *bb_get_last_path_component_nostrip(const char *path) FAST_FUNC;
  443. /* Simpler version: does not special case "/" string */
  444. const char *bb_basename(const char *name) FAST_FUNC;
  445. /* NB: can violate const-ness (similarly to strchr) */
  446. char *last_char_is(const char *s, int c) FAST_FUNC;
  447. const char* endofname(const char *name) FAST_FUNC;
  448. char *is_prefixed_with(const char *string, const char *key) FAST_FUNC;
  449. char *is_suffixed_with(const char *string, const char *key) FAST_FUNC;
  450. int ndelay_on(int fd) FAST_FUNC;
  451. int ndelay_off(int fd) FAST_FUNC;
  452. void close_on_exec_on(int fd) FAST_FUNC;
  453. void xdup2(int, int) FAST_FUNC;
  454. void xmove_fd(int, int) FAST_FUNC;
  455. DIR *xopendir(const char *path) FAST_FUNC;
  456. DIR *warn_opendir(const char *path) FAST_FUNC;
  457. char *xmalloc_realpath(const char *path) FAST_FUNC RETURNS_MALLOC;
  458. char *xmalloc_realpath_coreutils(const char *path) FAST_FUNC RETURNS_MALLOC;
  459. char *xmalloc_readlink(const char *path) FAST_FUNC RETURNS_MALLOC;
  460. char *xmalloc_readlink_or_warn(const char *path) FAST_FUNC RETURNS_MALLOC;
  461. /* !RETURNS_MALLOC: it's a realloc-like function */
  462. char *xrealloc_getcwd_or_warn(char *cwd) FAST_FUNC;
  463. char *xmalloc_follow_symlinks(const char *path) FAST_FUNC RETURNS_MALLOC;
  464. enum {
  465. /* bb_signals(BB_FATAL_SIGS, handler) catches all signals which
  466. * otherwise would kill us, except for those resulting from bugs:
  467. * SIGSEGV, SIGILL, SIGFPE.
  468. * Other fatal signals not included (TODO?):
  469. * SIGBUS Bus error (bad memory access)
  470. * SIGPOLL Pollable event. Synonym of SIGIO
  471. * SIGPROF Profiling timer expired
  472. * SIGSYS Bad argument to routine
  473. * SIGTRAP Trace/breakpoint trap
  474. *
  475. * The only known arch with some of these sigs not fitting
  476. * into 32 bits is parisc (SIGXCPU=33, SIGXFSZ=34, SIGSTKFLT=36).
  477. * Dance around with long long to guard against that...
  478. */
  479. BB_FATAL_SIGS = (int)(0
  480. + (1LL << SIGHUP)
  481. + (1LL << SIGINT)
  482. + (1LL << SIGTERM)
  483. + (1LL << SIGPIPE) // Write to pipe with no readers
  484. + (1LL << SIGQUIT) // Quit from keyboard
  485. + (1LL << SIGABRT) // Abort signal from abort(3)
  486. + (1LL << SIGALRM) // Timer signal from alarm(2)
  487. + (1LL << SIGVTALRM) // Virtual alarm clock
  488. + (1LL << SIGXCPU) // CPU time limit exceeded
  489. + (1LL << SIGXFSZ) // File size limit exceeded
  490. + (1LL << SIGUSR1) // Yes kids, these are also fatal!
  491. + (1LL << SIGUSR2)
  492. + 0),
  493. };
  494. void bb_signals(int sigs, void (*f)(int)) FAST_FUNC;
  495. /* Unlike signal() and bb_signals, sets handler with sigaction()
  496. * and in a way that while signal handler is run, no other signals
  497. * will be blocked; syscalls will not be restarted: */
  498. void bb_signals_recursive_norestart(int sigs, void (*f)(int)) FAST_FUNC;
  499. /* syscalls like read() will be interrupted with EINTR: */
  500. void signal_no_SA_RESTART_empty_mask(int sig, void (*handler)(int)) FAST_FUNC;
  501. /* syscalls like read() won't be interrupted (though select/poll will be): */
  502. void signal_SA_RESTART_empty_mask(int sig, void (*handler)(int)) FAST_FUNC;
  503. void wait_for_any_sig(void) FAST_FUNC;
  504. void kill_myself_with_sig(int sig) NORETURN FAST_FUNC;
  505. void sig_block(int sig) FAST_FUNC;
  506. void sig_unblock(int sig) FAST_FUNC;
  507. /* Will do sigaction(signum, act, NULL): */
  508. int sigaction_set(int sig, const struct sigaction *act) FAST_FUNC;
  509. /* SIG_BLOCK/SIG_UNBLOCK all signals: */
  510. int sigprocmask_allsigs(int how) FAST_FUNC;
  511. /* Standard handler which just records signo */
  512. extern smallint bb_got_signal;
  513. void record_signo(int signo); /* not FAST_FUNC! */
  514. void xsetgid(gid_t gid) FAST_FUNC;
  515. void xsetuid(uid_t uid) FAST_FUNC;
  516. void xsetegid(gid_t egid) FAST_FUNC;
  517. void xseteuid(uid_t euid) FAST_FUNC;
  518. void xchdir(const char *path) FAST_FUNC;
  519. void xfchdir(int fd) FAST_FUNC;
  520. void xchroot(const char *path) FAST_FUNC;
  521. void xsetenv(const char *key, const char *value) FAST_FUNC;
  522. void bb_unsetenv(const char *key) FAST_FUNC;
  523. void bb_unsetenv_and_free(char *key) FAST_FUNC;
  524. void xunlink(const char *pathname) FAST_FUNC;
  525. void xstat(const char *pathname, struct stat *buf) FAST_FUNC;
  526. void xfstat(int fd, struct stat *buf, const char *errmsg) FAST_FUNC;
  527. int open3_or_warn(const char *pathname, int flags, int mode) FAST_FUNC;
  528. int open_or_warn(const char *pathname, int flags) FAST_FUNC;
  529. int xopen3(const char *pathname, int flags, int mode) FAST_FUNC;
  530. int xopen(const char *pathname, int flags) FAST_FUNC;
  531. int xopen_nonblocking(const char *pathname) FAST_FUNC;
  532. int xopen_as_uid_gid(const char *pathname, int flags, uid_t u, gid_t g) FAST_FUNC;
  533. int open_or_warn_stdin(const char *pathname) FAST_FUNC;
  534. int xopen_stdin(const char *pathname) FAST_FUNC;
  535. void xrename(const char *oldpath, const char *newpath) FAST_FUNC;
  536. int rename_or_warn(const char *oldpath, const char *newpath) FAST_FUNC;
  537. off_t xlseek(int fd, off_t offset, int whence) FAST_FUNC;
  538. int xmkstemp(char *template) FAST_FUNC;
  539. off_t fdlength(int fd) FAST_FUNC;
  540. uoff_t FAST_FUNC get_volume_size_in_bytes(int fd,
  541. const char *override,
  542. unsigned override_units,
  543. int extend);
  544. void xpipe(int filedes[2]) FAST_FUNC;
  545. /* In this form code with pipes is much more readable */
  546. struct fd_pair { int rd; int wr; };
  547. #define piped_pair(pair) pipe(&((pair).rd))
  548. #define xpiped_pair(pair) xpipe(&((pair).rd))
  549. /* Useful for having small structure members/global variables */
  550. typedef int8_t socktype_t;
  551. typedef int8_t family_t;
  552. struct BUG_too_small {
  553. char BUG_socktype_t_too_small[(0
  554. | SOCK_STREAM
  555. | SOCK_DGRAM
  556. | SOCK_RDM
  557. | SOCK_SEQPACKET
  558. | SOCK_RAW
  559. ) <= 127 ? 1 : -1];
  560. char BUG_family_t_too_small[(0
  561. | AF_UNSPEC
  562. | AF_INET
  563. | AF_INET6
  564. | AF_UNIX
  565. #ifdef AF_PACKET
  566. | AF_PACKET
  567. #endif
  568. #ifdef AF_NETLINK
  569. | AF_NETLINK
  570. #endif
  571. /* | AF_DECnet */
  572. /* | AF_IPX */
  573. ) <= 127 ? 1 : -1];
  574. };
  575. void parse_datestr(const char *date_str, struct tm *ptm) FAST_FUNC;
  576. time_t validate_tm_time(const char *date_str, struct tm *ptm) FAST_FUNC;
  577. char *strftime_HHMMSS(char *buf, unsigned len, time_t *tp) FAST_FUNC;
  578. char *strftime_YYYYMMDDHHMMSS(char *buf, unsigned len, time_t *tp) FAST_FUNC;
  579. int xsocket(int domain, int type, int protocol) FAST_FUNC;
  580. void xbind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen) FAST_FUNC;
  581. void xlisten(int s, int backlog) FAST_FUNC;
  582. void xconnect(int s, const struct sockaddr *s_addr, socklen_t addrlen) FAST_FUNC;
  583. ssize_t xsendto(int s, const void *buf, size_t len, const struct sockaddr *to,
  584. socklen_t tolen) FAST_FUNC;
  585. int setsockopt_int(int fd, int level, int optname, int optval) FAST_FUNC;
  586. int setsockopt_1(int fd, int level, int optname) FAST_FUNC;
  587. int setsockopt_SOL_SOCKET_int(int fd, int optname, int optval) FAST_FUNC;
  588. int setsockopt_SOL_SOCKET_1(int fd, int optname) FAST_FUNC;
  589. /* SO_REUSEADDR allows a server to rebind to an address that is already
  590. * "in use" by old connections to e.g. previous server instance which is
  591. * killed or crashed. Without it bind will fail until all such connections
  592. * time out. Linux does not allow multiple live binds on same ip:port
  593. * regardless of SO_REUSEADDR (unlike some other flavors of Unix).
  594. * Turn it on before you call bind(). */
  595. void setsockopt_reuseaddr(int fd) FAST_FUNC; /* On Linux this never fails. */
  596. int setsockopt_keepalive(int fd) FAST_FUNC;
  597. int setsockopt_broadcast(int fd) FAST_FUNC;
  598. int setsockopt_bindtodevice(int fd, const char *iface) FAST_FUNC;
  599. int bb_getsockname(int sockfd, void *addr, socklen_t addrlen) FAST_FUNC;
  600. /* NB: returns port in host byte order */
  601. unsigned bb_lookup_port(const char *port, const char *protocol, unsigned default_port) FAST_FUNC;
  602. #if ENABLE_FEATURE_ETC_SERVICES
  603. # define bb_lookup_std_port(portstr, protocol, portnum) bb_lookup_port(portstr, protocol, portnum)
  604. #else
  605. # define bb_lookup_std_port(portstr, protocol, portnum) (portnum)
  606. #endif
  607. typedef struct len_and_sockaddr {
  608. socklen_t len;
  609. union {
  610. struct sockaddr sa;
  611. struct sockaddr_in sin;
  612. #if ENABLE_FEATURE_IPV6
  613. struct sockaddr_in6 sin6;
  614. #endif
  615. } u;
  616. } len_and_sockaddr;
  617. enum {
  618. LSA_LEN_SIZE = offsetof(len_and_sockaddr, u),
  619. LSA_SIZEOF_SA = sizeof(
  620. union {
  621. struct sockaddr sa;
  622. struct sockaddr_in sin;
  623. #if ENABLE_FEATURE_IPV6
  624. struct sockaddr_in6 sin6;
  625. #endif
  626. }
  627. )
  628. };
  629. /* Create stream socket, and allocate suitable lsa.
  630. * (lsa of correct size and lsa->sa.sa_family (AF_INET/AF_INET6))
  631. * af == AF_UNSPEC will result in trying to create IPv6 socket,
  632. * and if kernel doesn't support it, fall back to IPv4.
  633. * This is useful if you plan to bind to resulting local lsa.
  634. */
  635. int xsocket_type(len_and_sockaddr **lsap, int af, int sock_type) FAST_FUNC;
  636. int xsocket_stream(len_and_sockaddr **lsap) FAST_FUNC;
  637. /* Create server socket bound to bindaddr:port. bindaddr can be NULL,
  638. * numeric IP ("N.N.N.N") or numeric IPv6 address,
  639. * and can have ":PORT" suffix (for IPv6 use "[X:X:...:X]:PORT").
  640. * Only if there is no suffix, port argument is used */
  641. /* NB: these set SO_REUSEADDR before bind */
  642. int create_and_bind_stream_or_die(const char *bindaddr, int port) FAST_FUNC;
  643. int create_and_bind_dgram_or_die(const char *bindaddr, int port) FAST_FUNC;
  644. /* Create client TCP socket connected to peer:port. Peer cannot be NULL.
  645. * Peer can be numeric IP ("N.N.N.N"), numeric IPv6 address or hostname,
  646. * and can have ":PORT" suffix (for IPv6 use "[X:X:...:X]:PORT").
  647. * If there is no suffix, port argument is used */
  648. int create_and_connect_stream_or_die(const char *peer, int port) FAST_FUNC;
  649. /* Connect to peer identified by lsa */
  650. int xconnect_stream(const len_and_sockaddr *lsa) FAST_FUNC;
  651. /* Get local address of bound or accepted socket */
  652. len_and_sockaddr *get_sock_lsa(int fd) FAST_FUNC RETURNS_MALLOC;
  653. /* Get remote address of connected or accepted socket */
  654. len_and_sockaddr *get_peer_lsa(int fd) FAST_FUNC RETURNS_MALLOC;
  655. /* Return malloc'ed len_and_sockaddr with socket address of host:port
  656. * Currently will return IPv4 or IPv6 sockaddrs only
  657. * (depending on host), but in theory nothing prevents e.g.
  658. * UNIX socket address being returned, IPX sockaddr etc...
  659. * On error does bb_error_msg and returns NULL */
  660. len_and_sockaddr* host2sockaddr(const char *host, int port) FAST_FUNC RETURNS_MALLOC;
  661. /* Version which dies on error */
  662. len_and_sockaddr* xhost2sockaddr(const char *host, int port) FAST_FUNC RETURNS_MALLOC;
  663. len_and_sockaddr* xdotted2sockaddr(const char *host, int port) FAST_FUNC RETURNS_MALLOC;
  664. /* Same, useful if you want to force family (e.g. IPv6) */
  665. #if !ENABLE_FEATURE_IPV6
  666. #define host_and_af2sockaddr(host, port, af) host2sockaddr((host), (port))
  667. #define xhost_and_af2sockaddr(host, port, af) xhost2sockaddr((host), (port))
  668. #else
  669. len_and_sockaddr* host_and_af2sockaddr(const char *host, int port, sa_family_t af) FAST_FUNC RETURNS_MALLOC;
  670. len_and_sockaddr* xhost_and_af2sockaddr(const char *host, int port, sa_family_t af) FAST_FUNC RETURNS_MALLOC;
  671. #endif
  672. /* Assign sin[6]_port member if the socket is an AF_INET[6] one,
  673. * otherwise no-op. Useful for ftp.
  674. * NB: does NOT do htons() internally, just direct assignment. */
  675. void set_nport(struct sockaddr *sa, unsigned port) FAST_FUNC;
  676. /* Retrieve sin[6]_port or return -1 for non-INET[6] lsa's */
  677. int get_nport(const struct sockaddr *sa) FAST_FUNC;
  678. /* Reverse DNS. Returns NULL on failure. */
  679. char* xmalloc_sockaddr2host(const struct sockaddr *sa) FAST_FUNC RETURNS_MALLOC;
  680. /* This one doesn't append :PORTNUM */
  681. char* xmalloc_sockaddr2host_noport(const struct sockaddr *sa) FAST_FUNC RETURNS_MALLOC;
  682. /* This one also doesn't fall back to dotted IP (returns NULL) */
  683. char* xmalloc_sockaddr2hostonly_noport(const struct sockaddr *sa) FAST_FUNC RETURNS_MALLOC;
  684. /* inet_[ap]ton on steroids */
  685. char* xmalloc_sockaddr2dotted(const struct sockaddr *sa) FAST_FUNC RETURNS_MALLOC;
  686. char* xmalloc_sockaddr2dotted_noport(const struct sockaddr *sa) FAST_FUNC RETURNS_MALLOC;
  687. // "old" (ipv4 only) API
  688. // users: traceroute.c hostname.c - use _list_ of all IPs
  689. struct hostent *xgethostbyname(const char *name) FAST_FUNC;
  690. // Also mount.c and inetd.c are using gethostbyname(),
  691. // + inet_common.c has additional IPv4-only stuff
  692. #define TLS_MAX_MAC_SIZE 32
  693. #define TLS_MAX_KEY_SIZE 32
  694. struct tls_handshake_data; /* opaque */
  695. typedef struct tls_state {
  696. int ofd;
  697. int ifd;
  698. unsigned min_encrypted_len_on_read;
  699. uint16_t cipher_id;
  700. uint8_t encrypt_on_write;
  701. unsigned MAC_size;
  702. unsigned key_size;
  703. uint8_t *outbuf;
  704. int outbuf_size;
  705. int inbuf_size;
  706. int ofs_to_buffered;
  707. int buffered_size;
  708. uint8_t *inbuf;
  709. struct tls_handshake_data *hsd;
  710. // RFC 5246
  711. // sequence number
  712. // Each connection state contains a sequence number, which is
  713. // maintained separately for read and write states. The sequence
  714. // number MUST be set to zero whenever a connection state is made the
  715. // active state. Sequence numbers are of type uint64 and may not
  716. // exceed 2^64-1.
  717. /*uint64_t read_seq64_be;*/
  718. uint64_t write_seq64_be;
  719. uint8_t *client_write_key;
  720. uint8_t *server_write_key;
  721. uint8_t client_write_MAC_key[TLS_MAX_MAC_SIZE];
  722. uint8_t server_write_MAC_k__[TLS_MAX_MAC_SIZE];
  723. uint8_t client_write_k__[TLS_MAX_KEY_SIZE];
  724. uint8_t server_write_k__[TLS_MAX_KEY_SIZE];
  725. } tls_state_t;
  726. static inline tls_state_t *new_tls_state(void)
  727. {
  728. tls_state_t *tls = xzalloc(sizeof(*tls));
  729. return tls;
  730. }
  731. void tls_handshake(tls_state_t *tls, const char *sni) FAST_FUNC;
  732. #define TLSLOOP_EXIT_ON_LOCAL_EOF (1 << 0)
  733. void tls_run_copy_loop(tls_state_t *tls, unsigned flags) FAST_FUNC;
  734. void socket_want_pktinfo(int fd) FAST_FUNC;
  735. ssize_t send_to_from(int fd, void *buf, size_t len, int flags,
  736. const struct sockaddr *to,
  737. const struct sockaddr *from,
  738. socklen_t tolen) FAST_FUNC;
  739. ssize_t recv_from_to(int fd, void *buf, size_t len, int flags,
  740. struct sockaddr *from,
  741. struct sockaddr *to,
  742. socklen_t sa_size) FAST_FUNC;
  743. uint16_t inet_cksum(uint16_t *addr, int len) FAST_FUNC;
  744. int parse_pasv_epsv(char *buf) FAST_FUNC;
  745. /* 0 if argv[0] is NULL: */
  746. unsigned string_array_len(char **argv) FAST_FUNC;
  747. void overlapping_strcpy(char *dst, const char *src) FAST_FUNC;
  748. char *safe_strncpy(char *dst, const char *src, size_t size) FAST_FUNC;
  749. char *strncpy_IFNAMSIZ(char *dst, const char *src) FAST_FUNC;
  750. unsigned count_strstr(const char *str, const char *sub) FAST_FUNC;
  751. char *xmalloc_substitute_string(const char *src, int count, const char *sub, const char *repl) FAST_FUNC;
  752. /* Guaranteed to NOT be a macro (smallest code). Saves nearly 2k on uclibc.
  753. * But potentially slow, don't use in one-billion-times loops */
  754. int bb_putchar(int ch) FAST_FUNC;
  755. /* Note: does not use stdio, writes to fd 2 directly */
  756. int bb_putchar_stderr(char ch) FAST_FUNC;
  757. char *xasprintf(const char *format, ...) __attribute__ ((format(printf, 1, 2))) FAST_FUNC RETURNS_MALLOC;
  758. char *auto_string(char *str) FAST_FUNC;
  759. // gcc-4.1.1 still isn't good enough at optimizing it
  760. // (+200 bytes compared to macro)
  761. //static ALWAYS_INLINE
  762. //int LONE_DASH(const char *s) { return s[0] == '-' && !s[1]; }
  763. //static ALWAYS_INLINE
  764. //int NOT_LONE_DASH(const char *s) { return s[0] != '-' || s[1]; }
  765. #define LONE_DASH(s) ((s)[0] == '-' && !(s)[1])
  766. #define NOT_LONE_DASH(s) ((s)[0] != '-' || (s)[1])
  767. #define LONE_CHAR(s,c) ((s)[0] == (c) && !(s)[1])
  768. #define NOT_LONE_CHAR(s,c) ((s)[0] != (c) || (s)[1])
  769. #define DOT_OR_DOTDOT(s) ((s)[0] == '.' && (!(s)[1] || ((s)[1] == '.' && !(s)[2])))
  770. typedef struct uni_stat_t {
  771. unsigned byte_count;
  772. unsigned unicode_count;
  773. unsigned unicode_width;
  774. } uni_stat_t;
  775. /* Returns a string with unprintable chars replaced by '?' or
  776. * SUBST_WCHAR. This function is unicode-aware. */
  777. const char* FAST_FUNC printable_string(const char *str);
  778. const char* FAST_FUNC printable_string2(uni_stat_t *stats, const char *str);
  779. /* Prints unprintable char ch as ^C or M-c to file
  780. * (M-c is used only if ch is ORed with PRINTABLE_META),
  781. * else it is printed as-is (except for ch = 0x9b) */
  782. enum { PRINTABLE_META = 0x100 };
  783. void fputc_printable(int ch, FILE *file) FAST_FUNC;
  784. /* Return a string that is the printable representation of character ch.
  785. * Buffer must hold at least four characters. */
  786. enum {
  787. VISIBLE_ENDLINE = 1 << 0,
  788. VISIBLE_SHOW_TABS = 1 << 1,
  789. };
  790. void visible(unsigned ch, char *buf, int flags) FAST_FUNC;
  791. extern ssize_t safe_read(int fd, void *buf, size_t count) FAST_FUNC;
  792. extern ssize_t nonblock_immune_read(int fd, void *buf, size_t count) FAST_FUNC;
  793. // NB: will return short read on error, not -1,
  794. // if some data was read before error occurred
  795. extern ssize_t full_read(int fd, void *buf, size_t count) FAST_FUNC;
  796. extern void xread(int fd, void *buf, size_t count) FAST_FUNC;
  797. extern unsigned char xread_char(int fd) FAST_FUNC;
  798. extern ssize_t read_close(int fd, void *buf, size_t maxsz) FAST_FUNC;
  799. extern ssize_t open_read_close(const char *filename, void *buf, size_t maxsz) FAST_FUNC;
  800. // Reads one line a-la fgets (but doesn't save terminating '\n').
  801. // Reads byte-by-byte. Useful when it is important to not read ahead.
  802. // Bytes are appended to pfx (which must be malloced, or NULL).
  803. extern char *xmalloc_reads(int fd, size_t *maxsz_p) FAST_FUNC;
  804. /* Reads block up to *maxsz_p (default: INT_MAX - 4095) */
  805. extern void *xmalloc_read(int fd, size_t *maxsz_p) FAST_FUNC RETURNS_MALLOC;
  806. /* Returns NULL if file can't be opened (default max size: INT_MAX - 4095) */
  807. extern void *xmalloc_open_read_close(const char *filename, size_t *maxsz_p) FAST_FUNC RETURNS_MALLOC;
  808. /* Never returns NULL */
  809. extern void *xmalloc_xopen_read_close(const char *filename, size_t *maxsz_p) FAST_FUNC RETURNS_MALLOC;
  810. #if defined(ARG_MAX) && (ARG_MAX >= 60*1024 || !defined(_SC_ARG_MAX))
  811. /* Use _constant_ maximum if: defined && (big enough || no variable one exists) */
  812. # define bb_arg_max() ((unsigned)ARG_MAX)
  813. #elif defined(_SC_ARG_MAX)
  814. /* Else use variable one (a bit more expensive) */
  815. unsigned bb_arg_max(void) FAST_FUNC;
  816. #else
  817. /* If all else fails */
  818. # define bb_arg_max() ((unsigned)(32 * 1024))
  819. #endif
  820. unsigned bb_clk_tck(void) FAST_FUNC;
  821. #define SEAMLESS_COMPRESSION (0 \
  822. || ENABLE_FEATURE_SEAMLESS_XZ \
  823. || ENABLE_FEATURE_SEAMLESS_LZMA \
  824. || ENABLE_FEATURE_SEAMLESS_BZ2 \
  825. || ENABLE_FEATURE_SEAMLESS_GZ \
  826. || ENABLE_FEATURE_SEAMLESS_Z)
  827. #if SEAMLESS_COMPRESSION
  828. /* Autodetects gzip/bzip2 formats. fd may be in the middle of the file! */
  829. int setup_unzip_on_fd(int fd, int fail_if_not_compressed) FAST_FUNC;
  830. /* Autodetects .gz etc */
  831. extern int open_zipped(const char *fname, int fail_if_not_compressed) FAST_FUNC;
  832. extern void *xmalloc_open_zipped_read_close(const char *fname, size_t *maxsz_p) FAST_FUNC RETURNS_MALLOC;
  833. #else
  834. # define setup_unzip_on_fd(...) (0)
  835. # define open_zipped(fname, fail_if_not_compressed) open((fname), O_RDONLY);
  836. # define xmalloc_open_zipped_read_close(fname, maxsz_p) xmalloc_open_read_close((fname), (maxsz_p))
  837. #endif
  838. /* lzma has no signature, need a little helper. NB: exist only for ENABLE_FEATURE_SEAMLESS_LZMA=y */
  839. void setup_lzma_on_fd(int fd) FAST_FUNC;
  840. extern ssize_t safe_write(int fd, const void *buf, size_t count) FAST_FUNC;
  841. // NB: will return short write on error, not -1,
  842. // if some data was written before error occurred
  843. extern ssize_t full_write(int fd, const void *buf, size_t count) FAST_FUNC;
  844. extern void xwrite(int fd, const void *buf, size_t count) FAST_FUNC;
  845. extern void xwrite_str(int fd, const char *str) FAST_FUNC;
  846. extern ssize_t full_write1_str(const char *str) FAST_FUNC;
  847. extern ssize_t full_write2_str(const char *str) FAST_FUNC;
  848. extern void xopen_xwrite_close(const char* file, const char *str) FAST_FUNC;
  849. /* Close fd, but check for failures (some types of write errors) */
  850. extern void xclose(int fd) FAST_FUNC;
  851. /* Reads and prints to stdout till eof, then closes FILE. Exits on error: */
  852. extern void xprint_and_close_file(FILE *file) FAST_FUNC;
  853. /* Reads a line from a text file, up to a newline or NUL byte, inclusive.
  854. * Returns malloc'ed char*. If end is NULL '\n' isn't considered
  855. * end of line. If end isn't NULL, length of the chunk is stored in it.
  856. * Returns NULL if EOF/error.
  857. */
  858. extern char *bb_get_chunk_from_file(FILE *file, size_t *end) FAST_FUNC;
  859. /* Reads up to (and including) TERMINATING_STRING: */
  860. extern char *xmalloc_fgets_str(FILE *file, const char *terminating_string) FAST_FUNC RETURNS_MALLOC;
  861. /* Same, with limited max size, and returns the length (excluding NUL): */
  862. extern char *xmalloc_fgets_str_len(FILE *file, const char *terminating_string, size_t *maxsz_p) FAST_FUNC RETURNS_MALLOC;
  863. /* Chops off TERMINATING_STRING from the end: */
  864. extern char *xmalloc_fgetline_str(FILE *file, const char *terminating_string) FAST_FUNC RETURNS_MALLOC;
  865. /* Reads up to (and including) "\n" or NUL byte: */
  866. extern char *xmalloc_fgets(FILE *file) FAST_FUNC RETURNS_MALLOC;
  867. /* Chops off '\n' from the end, unlike fgets: */
  868. extern char *xmalloc_fgetline(FILE *file) FAST_FUNC RETURNS_MALLOC;
  869. /* Same, but doesn't try to conserve space (may have some slack after the end) */
  870. /* extern char *xmalloc_fgetline_fast(FILE *file) FAST_FUNC RETURNS_MALLOC; */
  871. void die_if_ferror(FILE *file, const char *msg) FAST_FUNC;
  872. void die_if_ferror_stdout(void) FAST_FUNC;
  873. int fflush_all(void) FAST_FUNC;
  874. void fflush_stdout_and_exit(int retval) NORETURN FAST_FUNC;
  875. int fclose_if_not_stdin(FILE *file) FAST_FUNC;
  876. FILE* xfopen(const char *filename, const char *mode) FAST_FUNC;
  877. /* Prints warning to stderr and returns NULL on failure: */
  878. FILE* fopen_or_warn(const char *filename, const char *mode) FAST_FUNC;
  879. /* "Opens" stdin if filename is special, else just opens file: */
  880. FILE* xfopen_stdin(const char *filename) FAST_FUNC;
  881. FILE* fopen_or_warn_stdin(const char *filename) FAST_FUNC;
  882. FILE* fopen_for_read(const char *path) FAST_FUNC;
  883. FILE* xfopen_for_read(const char *path) FAST_FUNC;
  884. FILE* fopen_for_write(const char *path) FAST_FUNC;
  885. FILE* xfopen_for_write(const char *path) FAST_FUNC;
  886. FILE* xfdopen_for_read(int fd) FAST_FUNC;
  887. FILE* xfdopen_for_write(int fd) FAST_FUNC;
  888. int bb_pstrcmp(const void *a, const void *b) /* not FAST_FUNC! */;
  889. void qsort_string_vector(char **sv, unsigned count) FAST_FUNC;
  890. /* Wrapper which restarts poll on EINTR or ENOMEM.
  891. * On other errors complains [perror("poll")] and returns.
  892. * Warning! May take (much) longer than timeout_ms to return!
  893. * If this is a problem, use bare poll and open-code EINTR/ENOMEM handling */
  894. int safe_poll(struct pollfd *ufds, nfds_t nfds, int timeout_ms) FAST_FUNC;
  895. char *safe_gethostname(void) FAST_FUNC;
  896. /* Convert each alpha char in str to lower-case */
  897. char* str_tolower(char *str) FAST_FUNC;
  898. char *utoa(unsigned n) FAST_FUNC;
  899. char *itoa(int n) FAST_FUNC;
  900. /* Returns a pointer past the formatted number, does NOT null-terminate */
  901. char *utoa_to_buf(unsigned n, char *buf, unsigned buflen) FAST_FUNC;
  902. char *itoa_to_buf(int n, char *buf, unsigned buflen) FAST_FUNC;
  903. /* Intelligent formatters of bignums */
  904. char *smart_ulltoa4(unsigned long long ul, char buf[4], const char *scale) FAST_FUNC;
  905. char *smart_ulltoa5(unsigned long long ul, char buf[5], const char *scale) FAST_FUNC;
  906. /* If block_size == 0, display size without fractional part,
  907. * else display (size * block_size) with one decimal digit.
  908. * If display_unit == 0, show value no bigger than 1024 with suffix (K,M,G...),
  909. * else divide by display_unit and do not use suffix. */
  910. #define HUMAN_READABLE_MAX_WIDTH 7 /* "1024.0G" */
  911. #define HUMAN_READABLE_MAX_WIDTH_STR "7"
  912. //TODO: provide pointer to buf (avoid statics)?
  913. const char *make_human_readable_str(unsigned long long size,
  914. unsigned long block_size, unsigned long display_unit) FAST_FUNC;
  915. /* Put a string of hex bytes ("1b2e66fe"...), return advanced pointer */
  916. char *bin2hex(char *dst, const char *src, int count) FAST_FUNC;
  917. /* Reverse */
  918. char* hex2bin(char *dst, const char *src, int count) FAST_FUNC;
  919. /* Generate a UUID */
  920. void generate_uuid(uint8_t *buf) FAST_FUNC;
  921. /* Last element is marked by mult == 0 */
  922. struct suffix_mult {
  923. char suffix[4];
  924. unsigned mult;
  925. };
  926. extern const struct suffix_mult bkm_suffixes[];
  927. #define km_suffixes (bkm_suffixes + 1)
  928. extern const struct suffix_mult cwbkMG_suffixes[];
  929. #define kMG_suffixes (cwbkMG_suffixes + 3)
  930. extern const struct suffix_mult kmg_i_suffixes[];
  931. #include "xatonum.h"
  932. /* Specialized: */
  933. /* Using xatoi() instead of naive atoi() is not always convenient -
  934. * in many places people want *non-negative* values, but store them
  935. * in signed int. Therefore we need this one:
  936. * dies if input is not in [0, INT_MAX] range. Also will reject '-0' etc.
  937. * It should really be named xatoi_nonnegative (since it allows 0),
  938. * but that would be too long.
  939. */
  940. int xatoi_positive(const char *numstr) FAST_FUNC;
  941. /* Useful for reading port numbers */
  942. uint16_t xatou16(const char *numstr) FAST_FUNC;
  943. #if ENABLE_FLOAT_DURATION
  944. typedef double duration_t;
  945. void sleep_for_duration(duration_t duration) FAST_FUNC;
  946. #else
  947. typedef unsigned duration_t;
  948. #define sleep_for_duration(duration) sleep(duration)
  949. #endif
  950. duration_t parse_duration_str(char *str) FAST_FUNC;
  951. /* These parse entries in /etc/passwd and /etc/group. This is desirable
  952. * for BusyBox since we want to avoid using the glibc NSS stuff, which
  953. * increases target size and is often not needed on embedded systems. */
  954. long xuname2uid(const char *name) FAST_FUNC;
  955. long xgroup2gid(const char *name) FAST_FUNC;
  956. /* wrapper: allows string to contain numeric uid or gid */
  957. unsigned long get_ug_id(const char *s, long FAST_FUNC (*xname2id)(const char *)) FAST_FUNC;
  958. struct bb_uidgid_t {
  959. uid_t uid;
  960. gid_t gid;
  961. };
  962. /* always sets uid and gid; returns 0 on failure */
  963. int get_uidgid(struct bb_uidgid_t*, const char*) FAST_FUNC;
  964. /* always sets uid and gid; exits on failure */
  965. void xget_uidgid(struct bb_uidgid_t*, const char*) FAST_FUNC;
  966. /* chown-like handling of "user[:[group]" */
  967. void parse_chown_usergroup_or_die(struct bb_uidgid_t *u, char *user_group) FAST_FUNC;
  968. struct passwd* xgetpwnam(const char *name) FAST_FUNC;
  969. struct group* xgetgrnam(const char *name) FAST_FUNC;
  970. struct passwd* xgetpwuid(uid_t uid) FAST_FUNC;
  971. struct group* xgetgrgid(gid_t gid) FAST_FUNC;
  972. char* xuid2uname(uid_t uid) FAST_FUNC;
  973. char* xgid2group(gid_t gid) FAST_FUNC;
  974. char* uid2uname(uid_t uid) FAST_FUNC;
  975. char* gid2group(gid_t gid) FAST_FUNC;
  976. char* uid2uname_utoa(uid_t uid) FAST_FUNC;
  977. char* gid2group_utoa(gid_t gid) FAST_FUNC;
  978. /* versions which cache results (useful for ps, ls etc) */
  979. const char* get_cached_username(uid_t uid) FAST_FUNC;
  980. const char* get_cached_groupname(gid_t gid) FAST_FUNC;
  981. void clear_username_cache(void) FAST_FUNC;
  982. /* internally usernames are saved in fixed-sized char[] buffers */
  983. enum { USERNAME_MAX_SIZE = 32 - sizeof(uid_t) };
  984. #if ENABLE_FEATURE_CHECK_NAMES
  985. void die_if_bad_username(const char* name) FAST_FUNC;
  986. #else
  987. #define die_if_bad_username(name) ((void)(name))
  988. #endif
  989. /*
  990. * Returns (-1) terminated malloced result of getgroups().
  991. * Reallocs group_array (useful for repeated calls).
  992. * ngroups is an initial size of array. It is rounded up to 32 for realloc.
  993. * ngroups is updated on return.
  994. * ngroups can be NULL: bb_getgroups(NULL, NULL) is valid usage.
  995. * Dies on errors (on Linux, only xrealloc can cause this, not internal getgroups call).
  996. */
  997. gid_t *bb_getgroups(int *ngroups, gid_t *group_array) FAST_FUNC;
  998. #if ENABLE_FEATURE_UTMP
  999. void FAST_FUNC write_new_utmp(pid_t pid, int new_type, const char *tty_name, const char *username, const char *hostname);
  1000. void FAST_FUNC update_utmp(pid_t pid, int new_type, const char *tty_name, const char *username, const char *hostname);
  1001. void FAST_FUNC update_utmp_DEAD_PROCESS(pid_t pid);
  1002. #else
  1003. # define write_new_utmp(pid, new_type, tty_name, username, hostname) ((void)0)
  1004. # define update_utmp(pid, new_type, tty_name, username, hostname) ((void)0)
  1005. # define update_utmp_DEAD_PROCESS(pid) ((void)0)
  1006. #endif
  1007. int file_is_executable(const char *name) FAST_FUNC;
  1008. char *find_executable(const char *filename, char **PATHp) FAST_FUNC;
  1009. int executable_exists(const char *filename) FAST_FUNC;
  1010. /* BB_EXECxx always execs (it's not doing NOFORK/NOEXEC stuff),
  1011. * but it may exec busybox and call applet instead of searching PATH.
  1012. */
  1013. #if ENABLE_FEATURE_PREFER_APPLETS
  1014. int BB_EXECVP(const char *file, char *const argv[]) FAST_FUNC;
  1015. #define BB_EXECLP(prog,cmd,...) \
  1016. do { \
  1017. if (find_applet_by_name(prog) >= 0) \
  1018. execlp(bb_busybox_exec_path, cmd, __VA_ARGS__); \
  1019. execlp(prog, cmd, __VA_ARGS__); \
  1020. } while (0)
  1021. #else
  1022. #define BB_EXECVP(prog,cmd) execvp(prog,cmd)
  1023. #define BB_EXECLP(prog,cmd,...) execlp(prog,cmd,__VA_ARGS__)
  1024. #endif
  1025. void BB_EXECVP_or_die(char **argv) NORETURN FAST_FUNC;
  1026. void exec_prog_or_SHELL(char **argv) NORETURN FAST_FUNC;
  1027. /* xvfork() can't be a _function_, return after vfork in child mangles stack
  1028. * in the parent. It must be a macro. */
  1029. #define xvfork() \
  1030. ({ \
  1031. pid_t bb__xvfork_pid = vfork(); \
  1032. if (bb__xvfork_pid < 0) \
  1033. bb_perror_msg_and_die("vfork"); \
  1034. bb__xvfork_pid; \
  1035. })
  1036. #if BB_MMU
  1037. pid_t xfork(void) FAST_FUNC;
  1038. #endif
  1039. void xvfork_parent_waits_and_exits(void) FAST_FUNC;
  1040. /* NOMMU friendy fork+exec: */
  1041. pid_t spawn(char **argv) FAST_FUNC;
  1042. pid_t xspawn(char **argv) FAST_FUNC;
  1043. pid_t safe_waitpid(pid_t pid, int *wstat, int options) FAST_FUNC;
  1044. pid_t wait_any_nohang(int *wstat) FAST_FUNC;
  1045. /* wait4pid: unlike waitpid, waits ONLY for one process.
  1046. * Returns sig + 0x180 if child is killed by signal.
  1047. * It's safe to pass negative 'pids' from failed [v]fork -
  1048. * wait4pid will return -1 (and will not clobber [v]fork's errno).
  1049. * IOW: rc = wait4pid(spawn(argv));
  1050. * if (rc < 0) bb_perror_msg("%s", argv[0]);
  1051. * if (rc > 0) bb_error_msg("exit code: %d", rc & 0xff);
  1052. */
  1053. int wait4pid(pid_t pid) FAST_FUNC;
  1054. int wait_for_exitstatus(pid_t pid) FAST_FUNC;
  1055. /************************************************************************/
  1056. /* spawn_and_wait/run_nofork_applet/run_applet_no_and_exit need to work */
  1057. /* carefully together to reinit some global state while not disturbing */
  1058. /* other. Be careful if you change them. Consult docs/nofork_noexec.txt */
  1059. /************************************************************************/
  1060. /* Same as wait4pid(spawn(argv)), but with NOFORK/NOEXEC if configured: */
  1061. int spawn_and_wait(char **argv) FAST_FUNC;
  1062. /* Does NOT check that applet is NOFORK, just blindly runs it */
  1063. int run_nofork_applet(int applet_no, char **argv) FAST_FUNC;
  1064. void run_noexec_applet_and_exit(int a, const char *name, char **argv) NORETURN FAST_FUNC;
  1065. #ifndef BUILD_INDIVIDUAL
  1066. int find_applet_by_name(const char *name) FAST_FUNC;
  1067. void run_applet_no_and_exit(int a, const char *name, char **argv) NORETURN FAST_FUNC;
  1068. #endif
  1069. #if defined(__linux__)
  1070. void set_task_comm(const char *comm) FAST_FUNC;
  1071. #else
  1072. # define set_task_comm(name) ((void)0)
  1073. #endif
  1074. /* Helpers for daemonization.
  1075. *
  1076. * bb_daemonize(flags) = daemonize, does not compile on NOMMU
  1077. *
  1078. * bb_daemonize_or_rexec(flags, argv) = daemonizes on MMU (and ignores argv),
  1079. * rexec's itself on NOMMU with argv passed as command line.
  1080. * Thus bb_daemonize_or_rexec may cause your <applet>_main() to be re-executed
  1081. * from the start. (It will detect it and not reexec again second time).
  1082. * You have to audit carefully that you don't do something twice as a result
  1083. * (opening files/sockets, parsing config files etc...)!
  1084. *
  1085. * Both of the above will redirect fd 0,1,2 to /dev/null and drop ctty
  1086. * (will do setsid()).
  1087. *
  1088. * fork_or_rexec(argv) = bare-bones fork on MMU,
  1089. * "vfork + re-exec ourself" on NOMMU. No fd redirection, no setsid().
  1090. * On MMU ignores argv.
  1091. *
  1092. * Helper for network daemons in foreground mode:
  1093. *
  1094. * bb_sanitize_stdio() = make sure that fd 0,1,2 are opened by opening them
  1095. * to /dev/null if they are not.
  1096. */
  1097. enum {
  1098. DAEMON_CHDIR_ROOT = 1,
  1099. DAEMON_DEVNULL_STDIO = 2,
  1100. DAEMON_CLOSE_EXTRA_FDS = 4,
  1101. DAEMON_ONLY_SANITIZE = 8, /* internal use */
  1102. DAEMON_DOUBLE_FORK = 16, /* double fork to avoid controlling tty */
  1103. };
  1104. #if BB_MMU
  1105. enum { re_execed = 0 };
  1106. # define fork_or_rexec(argv) xfork()
  1107. # define bb_daemonize_or_rexec(flags, argv) bb_daemonize_or_rexec(flags)
  1108. # define bb_daemonize(flags) bb_daemonize_or_rexec(flags, bogus)
  1109. #else
  1110. extern bool re_execed;
  1111. /* Note: re_exec() and fork_or_rexec() do argv[0][0] |= 0x80 on NOMMU!
  1112. * _Parent_ needs to undo it if it doesn't want to have argv[0] mangled.
  1113. */
  1114. void re_exec(char **argv) NORETURN FAST_FUNC;
  1115. pid_t fork_or_rexec(char **argv) FAST_FUNC;
  1116. int BUG_fork_is_unavailable_on_nommu(void) FAST_FUNC;
  1117. int BUG_daemon_is_unavailable_on_nommu(void) FAST_FUNC;
  1118. void BUG_bb_daemonize_is_unavailable_on_nommu(void) FAST_FUNC;
  1119. # define fork() BUG_fork_is_unavailable_on_nommu()
  1120. # define xfork() BUG_fork_is_unavailable_on_nommu()
  1121. # define daemon(a,b) BUG_daemon_is_unavailable_on_nommu()
  1122. # define bb_daemonize(a) BUG_bb_daemonize_is_unavailable_on_nommu()
  1123. #endif
  1124. void bb_daemonize_or_rexec(int flags, char **argv) FAST_FUNC;
  1125. void bb_sanitize_stdio(void) FAST_FUNC;
  1126. #define bb_daemon_helper(arg) bb_daemonize_or_rexec((arg) | DAEMON_ONLY_SANITIZE, NULL)
  1127. /* Clear dangerous stuff, set PATH. Return 1 if was run by different user. */
  1128. int sanitize_env_if_suid(void) FAST_FUNC;
  1129. /* For top, ps. Some argv[i] are replaced by malloced "-opt" strings */
  1130. void make_all_argv_opts(char **argv) FAST_FUNC;
  1131. char* single_argv(char **argv) FAST_FUNC;
  1132. extern const char *const bb_argv_dash[]; /* { "-", NULL } */
  1133. extern uint32_t option_mask32;
  1134. uint32_t getopt32(char **argv, const char *applet_opts, ...) FAST_FUNC;
  1135. # define No_argument "\0"
  1136. # define Required_argument "\001"
  1137. # define Optional_argument "\002"
  1138. #if ENABLE_LONG_OPTS
  1139. uint32_t getopt32long(char **argv, const char *optstring, const char *longopts, ...) FAST_FUNC;
  1140. #else
  1141. #define getopt32long(argv,optstring,longopts,...) \
  1142. getopt32(argv,optstring,##__VA_ARGS__)
  1143. #endif
  1144. /* BSD-derived getopt() functions require that optind be set to 1 in
  1145. * order to reset getopt() state. This used to be generally accepted
  1146. * way of resetting getopt(). However, glibc's getopt()
  1147. * has additional getopt() state beyond optind (specifically, glibc
  1148. * extensions such as '+' and '-' at the start of the string), and requires
  1149. * that optind be set to zero to reset its state. BSD-derived versions
  1150. * of getopt() misbehaved if optind is set to 0 in order to reset getopt(),
  1151. * and glibc's getopt() used to coredump if optind is set 1 in order
  1152. * to reset getopt().
  1153. * Then BSD introduced additional variable "optreset" which should be
  1154. * set to 1 in order to reset getopt(). Sigh. Standards, anyone?
  1155. *
  1156. * By ~2008, OpenBSD 3.4 was changed to survive glibc-like optind = 0
  1157. * (to interpret it as if optreset was set).
  1158. */
  1159. #if 1 /*def __GLIBC__*/
  1160. #define GETOPT_RESET() (optind = 0)
  1161. #else /* BSD style */
  1162. #define GETOPT_RESET() (optind = 1)
  1163. #endif
  1164. /* Having next pointer as a first member allows easy creation
  1165. * of "llist-compatible" structs, and using llist_FOO functions
  1166. * on them.
  1167. */
  1168. typedef struct llist_t {
  1169. struct llist_t *link;
  1170. char *data;
  1171. } llist_t;
  1172. void llist_add_to(llist_t **old_head, void *data) FAST_FUNC;
  1173. void llist_add_to_end(llist_t **list_head, void *data) FAST_FUNC;
  1174. void *llist_pop(llist_t **elm) FAST_FUNC;
  1175. void llist_unlink(llist_t **head, llist_t *elm) FAST_FUNC;
  1176. void llist_free(llist_t *elm, void (*freeit)(void *data)) FAST_FUNC;
  1177. llist_t *llist_rev(llist_t *list) FAST_FUNC;
  1178. llist_t *llist_find_str(llist_t *first, const char *str) FAST_FUNC;
  1179. /* BTW, surprisingly, changing API to
  1180. * llist_t *llist_add_to(llist_t *old_head, void *data)
  1181. * etc does not result in smaller code... */
  1182. /* start_stop_daemon and udhcpc are special - they want
  1183. * to create pidfiles regardless of FEATURE_PIDFILE */
  1184. #if ENABLE_FEATURE_PIDFILE || defined(WANT_PIDFILE)
  1185. /* True only if we created pidfile which is *file*, not /dev/null etc */
  1186. extern smallint wrote_pidfile;
  1187. void write_pidfile(const char *path) FAST_FUNC;
  1188. #define remove_pidfile(path) do { if (wrote_pidfile) unlink(path); } while (0)
  1189. #else
  1190. enum { wrote_pidfile = 0 };
  1191. #define write_pidfile(path) ((void)0)
  1192. #define remove_pidfile(path) ((void)0)
  1193. #endif
  1194. enum {
  1195. LOGMODE_NONE = 0,
  1196. LOGMODE_STDIO = (1 << 0),
  1197. LOGMODE_SYSLOG = (1 << 1) * ENABLE_FEATURE_SYSLOG,
  1198. LOGMODE_BOTH = LOGMODE_SYSLOG + LOGMODE_STDIO,
  1199. };
  1200. extern const char *msg_eol;
  1201. extern smallint syslog_level;
  1202. extern smallint logmode;
  1203. extern uint8_t xfunc_error_retval;
  1204. extern void (*die_func)(void);
  1205. void xfunc_die(void) NORETURN FAST_FUNC;
  1206. void bb_show_usage(void) NORETURN FAST_FUNC;
  1207. void bb_error_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2))) FAST_FUNC;
  1208. void bb_error_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2))) FAST_FUNC;
  1209. void bb_perror_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2))) FAST_FUNC;
  1210. void bb_simple_perror_msg(const char *s) FAST_FUNC;
  1211. void bb_perror_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2))) FAST_FUNC;
  1212. void bb_simple_perror_msg_and_die(const char *s) NORETURN FAST_FUNC;
  1213. void bb_herror_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2))) FAST_FUNC;
  1214. void bb_herror_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2))) FAST_FUNC;
  1215. void bb_perror_nomsg_and_die(void) NORETURN FAST_FUNC;
  1216. void bb_perror_nomsg(void) FAST_FUNC;
  1217. void bb_verror_msg(const char *s, va_list p, const char *strerr) FAST_FUNC;
  1218. void bb_die_memory_exhausted(void) NORETURN FAST_FUNC;
  1219. void bb_logenv_override(void) FAST_FUNC;
  1220. /* We need to export XXX_main from libbusybox
  1221. * only if we build "individual" binaries
  1222. */
  1223. #if ENABLE_FEATURE_INDIVIDUAL
  1224. #define MAIN_EXTERNALLY_VISIBLE EXTERNALLY_VISIBLE
  1225. #else
  1226. #define MAIN_EXTERNALLY_VISIBLE
  1227. #endif
  1228. /* Applets which are useful from another applets */
  1229. int bb_cat(char** argv) FAST_FUNC;
  1230. /* If shell needs them, they exist even if not enabled as applets */
  1231. int echo_main(int argc, char** argv) IF_ECHO(MAIN_EXTERNALLY_VISIBLE);
  1232. int printf_main(int argc, char **argv) IF_PRINTF(MAIN_EXTERNALLY_VISIBLE);
  1233. int test_main(int argc, char **argv)
  1234. #if ENABLE_TEST || ENABLE_TEST1 || ENABLE_TEST2
  1235. MAIN_EXTERNALLY_VISIBLE
  1236. #endif
  1237. ;
  1238. int kill_main(int argc, char **argv)
  1239. #if ENABLE_KILL || ENABLE_KILLALL || ENABLE_KILLALL5
  1240. MAIN_EXTERNALLY_VISIBLE
  1241. #endif
  1242. ;
  1243. /* Similar, but used by chgrp, not shell */
  1244. int chown_main(int argc, char **argv) IF_CHOWN(MAIN_EXTERNALLY_VISIBLE);
  1245. /* Used by ftpd */
  1246. int ls_main(int argc, char **argv) IF_LS(MAIN_EXTERNALLY_VISIBLE);
  1247. /* Don't need IF_xxx() guard for these */
  1248. int gunzip_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
  1249. int bunzip2_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
  1250. #if ENABLE_ROUTE
  1251. void bb_displayroutes(int noresolve, int netstatfmt) FAST_FUNC;
  1252. #endif
  1253. struct number_state {
  1254. unsigned width;
  1255. unsigned start;
  1256. unsigned inc;
  1257. const char *sep;
  1258. const char *empty_str;
  1259. smallint all, nonempty;
  1260. };
  1261. void print_numbered_lines(struct number_state *ns, const char *filename) FAST_FUNC;
  1262. /* Networking */
  1263. /* This structure defines protocol families and their handlers. */
  1264. struct aftype {
  1265. const char *name;
  1266. const char *title;
  1267. int af;
  1268. int alen;
  1269. char* FAST_FUNC (*print)(unsigned char *);
  1270. const char* FAST_FUNC (*sprint)(struct sockaddr *, int numeric);
  1271. int FAST_FUNC (*input)(/*int type,*/ const char *bufp, struct sockaddr *);
  1272. void FAST_FUNC (*herror)(char *text);
  1273. int FAST_FUNC (*rprint)(int options);
  1274. int FAST_FUNC (*rinput)(int typ, int ext, char **argv);
  1275. /* may modify src */
  1276. int FAST_FUNC (*getmask)(char *src, struct sockaddr *mask, char *name);
  1277. };
  1278. /* This structure defines hardware protocols and their handlers. */
  1279. struct hwtype {
  1280. const char *name;
  1281. const char *title;
  1282. int type;
  1283. int alen;
  1284. char* FAST_FUNC (*print)(unsigned char *);
  1285. int FAST_FUNC (*input)(const char *, struct sockaddr *);
  1286. int FAST_FUNC (*activate)(int fd);
  1287. int suppress_null_addr;
  1288. };
  1289. #define IFNAME_SHOW_DOWNED_TOO ((char*)(intptr_t)1)
  1290. int display_interfaces(char *ifname) FAST_FUNC;
  1291. int in_ether(const char *bufp, struct sockaddr *sap) FAST_FUNC;
  1292. #if ENABLE_FEATURE_HWIB
  1293. int in_ib(const char *bufp, struct sockaddr *sap) FAST_FUNC;
  1294. #else
  1295. #define in_ib(a, b) 1 /* fail */
  1296. #endif
  1297. const struct aftype *get_aftype(const char *name) FAST_FUNC;
  1298. const struct hwtype *get_hwtype(const char *name) FAST_FUNC;
  1299. const struct hwtype *get_hwntype(int type) FAST_FUNC;
  1300. extern int fstype_matches(const char *fstype, const char *comma_list) FAST_FUNC;
  1301. #ifdef HAVE_MNTENT_H
  1302. extern struct mntent *find_mount_point(const char *name, int subdir_too) FAST_FUNC;
  1303. #endif
  1304. extern void erase_mtab(const char * name) FAST_FUNC;
  1305. extern unsigned int tty_baud_to_value(speed_t speed) FAST_FUNC;
  1306. extern speed_t tty_value_to_baud(unsigned int value) FAST_FUNC;
  1307. #if ENABLE_DESKTOP
  1308. extern void bb_warn_ignoring_args(char *arg) FAST_FUNC;
  1309. #else
  1310. # define bb_warn_ignoring_args(arg) ((void)0)
  1311. #endif
  1312. extern int get_linux_version_code(void) FAST_FUNC;
  1313. extern char *query_loop(const char *device) FAST_FUNC;
  1314. extern int del_loop(const char *device) FAST_FUNC;
  1315. /*
  1316. * If *devname is not NULL, use that name, otherwise try to find free one,
  1317. * malloc and return it in *devname.
  1318. * return value is the opened fd to the loop device, or < on error
  1319. */
  1320. extern int set_loop(char **devname, const char *file, unsigned long long offset, unsigned flags) FAST_FUNC;
  1321. /* These constants match linux/loop.h (without BB_ prefix): */
  1322. #define BB_LO_FLAGS_READ_ONLY 1
  1323. #define BB_LO_FLAGS_AUTOCLEAR 4
  1324. /* Returns malloced str */
  1325. char *bb_ask_noecho(int fd, int timeout, const char *prompt) FAST_FUNC;
  1326. /* Like bb_ask_noecho, but asks on stdin with no timeout. */
  1327. char *bb_ask_noecho_stdin(const char *prompt) FAST_FUNC;
  1328. int bb_ask_y_confirmation_FILE(FILE *fp) FAST_FUNC;
  1329. int bb_ask_y_confirmation(void) FAST_FUNC;
  1330. /* Returns -1 if input is invalid. current_mode is a base for e.g. "u+rw" */
  1331. int bb_parse_mode(const char* s, unsigned cur_mode) FAST_FUNC;
  1332. /*
  1333. * Config file parser
  1334. */
  1335. enum {
  1336. PARSE_COLLAPSE = 0x00010000, // treat consecutive delimiters as one
  1337. PARSE_TRIM = 0x00020000, // trim leading and trailing delimiters
  1338. // TODO: COLLAPSE and TRIM seem to always go in pair
  1339. PARSE_GREEDY = 0x00040000, // last token takes entire remainder of the line
  1340. PARSE_MIN_DIE = 0x00100000, // die if < min tokens found
  1341. // keep a copy of current line
  1342. PARSE_KEEP_COPY = 0x00200000 * ENABLE_FEATURE_CROND_D,
  1343. PARSE_EOL_COMMENTS = 0x00400000, // comments are recognized even if they aren't the first char
  1344. PARSE_ALT_COMMENTS = 0x00800000, // delim[0] and delim[1] are two different allowed comment chars
  1345. // (so far, delim[0] will only work as comment char for full-line comment)
  1346. // (IOW: it works as if PARSE_EOL_COMMENTS is not set. sysctl applet is okay with this)
  1347. PARSE_WS_COMMENTS = 0x01000000, // comments are recognized even if there is whitespace before
  1348. // ("line start><space><tab><space>#comment" is also comment, not only "line start>#comment")
  1349. // NORMAL is:
  1350. // * remove leading and trailing delimiters and collapse
  1351. // multiple delimiters into one
  1352. // * warn and continue if less than mintokens delimiters found
  1353. // * grab everything into last token
  1354. // * comments are recognized even if they aren't the first char
  1355. PARSE_NORMAL = PARSE_COLLAPSE | PARSE_TRIM | PARSE_GREEDY | PARSE_EOL_COMMENTS,
  1356. };
  1357. typedef struct parser_t {
  1358. FILE *fp;
  1359. char *data;
  1360. char *line, *nline;
  1361. size_t line_alloc, nline_alloc;
  1362. int lineno;
  1363. } parser_t;
  1364. parser_t* config_open(const char *filename) FAST_FUNC;
  1365. parser_t* config_open2(const char *filename, FILE* FAST_FUNC (*fopen_func)(const char *path)) FAST_FUNC;
  1366. /* delims[0] is a comment char (use '\0' to disable), the rest are token delimiters */
  1367. int config_read(parser_t *parser, char **tokens, unsigned flags, const char *delims) FAST_FUNC;
  1368. #define config_read(parser, tokens, max, min, str, flags) \
  1369. config_read(parser, tokens, ((flags) | (((min) & 0xFF) << 8) | ((max) & 0xFF)), str)
  1370. void config_close(parser_t *parser) FAST_FUNC;
  1371. /* Concatenate path and filename to new allocated buffer.
  1372. * Add "/" only as needed (no duplicate "//" are produced).
  1373. * If path is NULL, it is assumed to be "/".
  1374. * filename should not be NULL. */
  1375. char *concat_path_file(const char *path, const char *filename) FAST_FUNC;
  1376. /* Returns NULL on . and .. */
  1377. char *concat_subpath_file(const char *path, const char *filename) FAST_FUNC;
  1378. int bb_make_directory(char *path, long mode, int flags) FAST_FUNC;
  1379. int get_signum(const char *name) FAST_FUNC;
  1380. const char *get_signame(int number) FAST_FUNC;
  1381. void print_signames(void) FAST_FUNC;
  1382. char *bb_simplify_path(const char *path) FAST_FUNC;
  1383. /* Returns ptr to NUL */
  1384. char *bb_simplify_abs_path_inplace(char *path) FAST_FUNC;
  1385. #ifndef LOGIN_FAIL_DELAY
  1386. #define LOGIN_FAIL_DELAY 3
  1387. #endif
  1388. extern void bb_do_delay(int seconds) FAST_FUNC;
  1389. extern void change_identity(const struct passwd *pw) FAST_FUNC;
  1390. extern void run_shell(const char *shell, int loginshell, const char **args) NORETURN FAST_FUNC;
  1391. /* Returns $SHELL, getpwuid(getuid())->pw_shell, or DEFAULT_SHELL.
  1392. * Note that getpwuid result might need xstrdup'ing
  1393. * if there is a possibility of intervening getpwxxx() calls.
  1394. */
  1395. const char *get_shell_name(void) FAST_FUNC;
  1396. #if ENABLE_FEATURE_SETPRIV_CAPABILITIES || ENABLE_RUN_INIT
  1397. unsigned cap_name_to_number(const char *cap) FAST_FUNC;
  1398. void printf_cap(const char *pfx, unsigned cap_no) FAST_FUNC;
  1399. void drop_capability(int cap_ordinal) FAST_FUNC;
  1400. /* Structures inside "struct caps" are Linux-specific and libcap-specific: */
  1401. #define DEFINE_STRUCT_CAPS \
  1402. struct caps { \
  1403. struct __user_cap_header_struct header; \
  1404. unsigned u32s; \
  1405. struct __user_cap_data_struct data[2]; \
  1406. }
  1407. void getcaps(void *caps) FAST_FUNC;
  1408. #endif
  1409. #if ENABLE_SELINUX
  1410. extern void renew_current_security_context(void) FAST_FUNC;
  1411. extern void set_current_security_context(security_context_t sid) FAST_FUNC;
  1412. extern context_t set_security_context_component(security_context_t cur_context,
  1413. char *user, char *role, char *type, char *range) FAST_FUNC;
  1414. extern void setfscreatecon_or_die(security_context_t scontext) FAST_FUNC;
  1415. extern void selinux_preserve_fcontext(int fdesc) FAST_FUNC;
  1416. #else
  1417. #define selinux_preserve_fcontext(fdesc) ((void)0)
  1418. #endif
  1419. extern void selinux_or_die(void) FAST_FUNC;
  1420. /* setup_environment:
  1421. * if chdir pw->pw_dir: ok: else if to_tmp == 1: goto /tmp else: goto / or die
  1422. * if clear_env = 1: cd(pw->pw_dir), clear environment, then set
  1423. * TERM=(old value)
  1424. * USER=pw->pw_name, LOGNAME=pw->pw_name
  1425. * PATH=bb_default_[root_]path
  1426. * HOME=pw->pw_dir
  1427. * SHELL=shell
  1428. * else if change_env = 1:
  1429. * if not root (if pw->pw_uid != 0):
  1430. * USER=pw->pw_name, LOGNAME=pw->pw_name
  1431. * HOME=pw->pw_dir
  1432. * SHELL=shell
  1433. * else does nothing
  1434. *
  1435. * NB: CHANGEENV and CLEARENV use setenv() - this leaks memory!
  1436. * If setup_environment() is used is vforked child, this leaks memory _in parent too_!
  1437. */
  1438. #define SETUP_ENV_CHANGEENV (1 << 0)
  1439. #define SETUP_ENV_CLEARENV (1 << 1)
  1440. #define SETUP_ENV_TO_TMP (1 << 2)
  1441. #define SETUP_ENV_NO_CHDIR (1 << 4)
  1442. void setup_environment(const char *shell, int flags, const struct passwd *pw) FAST_FUNC;
  1443. void nuke_str(char *str) FAST_FUNC;
  1444. #if ENABLE_FEATURE_SECURETTY && !ENABLE_PAM
  1445. int is_tty_secure(const char *short_tty) FAST_FUNC;
  1446. #else
  1447. static ALWAYS_INLINE int is_tty_secure(const char *short_tty UNUSED_PARAM) { return 1; }
  1448. #endif
  1449. #define CHECKPASS_PW_HAS_EMPTY_PASSWORD 2
  1450. int check_password(const struct passwd *pw, const char *plaintext) FAST_FUNC;
  1451. int ask_and_check_password_extended(const struct passwd *pw, int timeout, const char *prompt) FAST_FUNC;
  1452. int ask_and_check_password(const struct passwd *pw) FAST_FUNC;
  1453. /* Returns a malloced string */
  1454. #if !ENABLE_USE_BB_CRYPT
  1455. #define pw_encrypt(clear, salt, cleanup) pw_encrypt(clear, salt)
  1456. #endif
  1457. extern char *pw_encrypt(const char *clear, const char *salt, int cleanup) FAST_FUNC;
  1458. extern int obscure(const char *old, const char *newval, const struct passwd *pwdp) FAST_FUNC;
  1459. /*
  1460. * rnd is additional random input. New one is returned.
  1461. * Useful if you call crypt_make_salt many times in a row:
  1462. * rnd = crypt_make_salt(buf1, 4, 0);
  1463. * rnd = crypt_make_salt(buf2, 4, rnd);
  1464. * rnd = crypt_make_salt(buf3, 4, rnd);
  1465. * (otherwise we risk having same salt generated)
  1466. */
  1467. extern int crypt_make_salt(char *p, int cnt /*, int rnd*/) FAST_FUNC;
  1468. /* "$N$" + sha_salt_16_bytes + NUL */
  1469. #define MAX_PW_SALT_LEN (3 + 16 + 1)
  1470. extern char* crypt_make_pw_salt(char p[MAX_PW_SALT_LEN], const char *algo) FAST_FUNC;
  1471. /* Returns number of lines changed, or -1 on error */
  1472. #if !(ENABLE_FEATURE_ADDUSER_TO_GROUP || ENABLE_FEATURE_DEL_USER_FROM_GROUP)
  1473. #define update_passwd(filename, username, data, member) \
  1474. update_passwd(filename, username, data)
  1475. #endif
  1476. extern int update_passwd(const char *filename,
  1477. const char *username,
  1478. const char *data,
  1479. const char *member) FAST_FUNC;
  1480. int index_in_str_array(const char *const string_array[], const char *key) FAST_FUNC;
  1481. int index_in_strings(const char *strings, const char *key) FAST_FUNC;
  1482. int index_in_substr_array(const char *const string_array[], const char *key) FAST_FUNC;
  1483. int index_in_substrings(const char *strings, const char *key) FAST_FUNC;
  1484. const char *nth_string(const char *strings, int n) FAST_FUNC;
  1485. extern void print_login_issue(const char *issue_file, const char *tty) FAST_FUNC;
  1486. extern void print_login_prompt(void) FAST_FUNC;
  1487. char *xmalloc_ttyname(int fd) FAST_FUNC RETURNS_MALLOC;
  1488. /* NB: typically you want to pass fd 0, not 1. Think 'applet | grep something' */
  1489. int get_terminal_width_height(int fd, unsigned *width, unsigned *height) FAST_FUNC;
  1490. int get_terminal_width(int fd) FAST_FUNC;
  1491. int tcsetattr_stdin_TCSANOW(const struct termios *tp) FAST_FUNC;
  1492. #define TERMIOS_CLEAR_ISIG (1 << 0)
  1493. #define TERMIOS_RAW_CRNL_INPUT (1 << 1)
  1494. #define TERMIOS_RAW_CRNL_OUTPUT (1 << 2)
  1495. #define TERMIOS_RAW_CRNL (TERMIOS_RAW_CRNL_INPUT|TERMIOS_RAW_CRNL_OUTPUT)
  1496. #define TERMIOS_RAW_INPUT (1 << 3)
  1497. int get_termios_and_make_raw(int fd, struct termios *newterm, struct termios *oldterm, int flags) FAST_FUNC;
  1498. int set_termios_to_raw(int fd, struct termios *oldterm, int flags) FAST_FUNC;
  1499. /* NB: "unsigned request" is crucial! "int request" will break some arches! */
  1500. int ioctl_or_perror(int fd, unsigned request, void *argp, const char *fmt,...) __attribute__ ((format (printf, 4, 5))) FAST_FUNC;
  1501. int ioctl_or_perror_and_die(int fd, unsigned request, void *argp, const char *fmt,...) __attribute__ ((format (printf, 4, 5))) FAST_FUNC;
  1502. #if ENABLE_IOCTL_HEX2STR_ERROR
  1503. int bb_ioctl_or_warn(int fd, unsigned request, void *argp, const char *ioctl_name) FAST_FUNC;
  1504. int bb_xioctl(int fd, unsigned request, void *argp, const char *ioctl_name) FAST_FUNC;
  1505. #define ioctl_or_warn(fd,request,argp) bb_ioctl_or_warn(fd,request,argp,#request)
  1506. #define xioctl(fd,request,argp) bb_xioctl(fd,request,argp,#request)
  1507. #else
  1508. int bb_ioctl_or_warn(int fd, unsigned request, void *argp) FAST_FUNC;
  1509. int bb_xioctl(int fd, unsigned request, void *argp) FAST_FUNC;
  1510. #define ioctl_or_warn(fd,request,argp) bb_ioctl_or_warn(fd,request,argp)
  1511. #define xioctl(fd,request,argp) bb_xioctl(fd,request,argp)
  1512. #endif
  1513. char *is_in_ino_dev_hashtable(const struct stat *statbuf) FAST_FUNC;
  1514. void add_to_ino_dev_hashtable(const struct stat *statbuf, const char *name) FAST_FUNC;
  1515. void reset_ino_dev_hashtable(void) FAST_FUNC;
  1516. #ifdef __GLIBC__
  1517. /* At least glibc has horrendously large inline for this, so wrap it */
  1518. unsigned long long bb_makedev(unsigned major, unsigned minor) FAST_FUNC;
  1519. #undef makedev
  1520. #define makedev(a,b) bb_makedev(a,b)
  1521. #endif
  1522. /* "Keycodes" that report an escape sequence.
  1523. * We use something which fits into signed char,
  1524. * yet doesn't represent any valid Unicode character.
  1525. * Also, -1 is reserved for error indication and we don't use it. */
  1526. enum {
  1527. KEYCODE_UP = -2,
  1528. KEYCODE_DOWN = -3,
  1529. KEYCODE_RIGHT = -4,
  1530. KEYCODE_LEFT = -5,
  1531. KEYCODE_HOME = -6,
  1532. KEYCODE_END = -7,
  1533. KEYCODE_INSERT = -8,
  1534. KEYCODE_DELETE = -9,
  1535. KEYCODE_PAGEUP = -10,
  1536. KEYCODE_PAGEDOWN = -11,
  1537. KEYCODE_BACKSPACE = -12, /* Used only if Alt/Ctrl/Shifted */
  1538. KEYCODE_D = -13, /* Used only if Alted */
  1539. #if 0
  1540. KEYCODE_FUN1 = ,
  1541. KEYCODE_FUN2 = ,
  1542. KEYCODE_FUN3 = ,
  1543. KEYCODE_FUN4 = ,
  1544. KEYCODE_FUN5 = ,
  1545. KEYCODE_FUN6 = ,
  1546. KEYCODE_FUN7 = ,
  1547. KEYCODE_FUN8 = ,
  1548. KEYCODE_FUN9 = ,
  1549. KEYCODE_FUN10 = ,
  1550. KEYCODE_FUN11 = ,
  1551. KEYCODE_FUN12 = ,
  1552. #endif
  1553. /* ^^^^^ Be sure that last defined value is small enough.
  1554. * Current read_key() code allows going up to -32 (0xfff..fffe0).
  1555. * This gives three upper bits in LSB to play with:
  1556. * KEYCODE_foo values are 0xfff..fffXX, lowest XX bits are: scavvvvv,
  1557. * s=0 if SHIFT, c=0 if CTRL, a=0 if ALT,
  1558. * vvvvv bits are the same for same key regardless of "shift bits".
  1559. */
  1560. //KEYCODE_SHIFT_... = KEYCODE_... & ~0x80,
  1561. KEYCODE_CTRL_RIGHT = KEYCODE_RIGHT & ~0x40,
  1562. KEYCODE_CTRL_LEFT = KEYCODE_LEFT & ~0x40,
  1563. KEYCODE_ALT_RIGHT = KEYCODE_RIGHT & ~0x20,
  1564. KEYCODE_ALT_LEFT = KEYCODE_LEFT & ~0x20,
  1565. KEYCODE_ALT_BACKSPACE = KEYCODE_BACKSPACE & ~0x20,
  1566. KEYCODE_ALT_D = KEYCODE_D & ~0x20,
  1567. KEYCODE_CURSOR_POS = -0x100, /* 0xfff..fff00 */
  1568. /* How long is the longest ESC sequence we know?
  1569. * We want it big enough to be able to contain
  1570. * cursor position sequence "ESC [ 9999 ; 9999 R"
  1571. */
  1572. KEYCODE_BUFFER_SIZE = 16
  1573. };
  1574. /* Note: fd may be in blocking or non-blocking mode, both make sense.
  1575. * For one, less uses non-blocking mode.
  1576. * Only the first read syscall inside read_key may block indefinitely
  1577. * (unless fd is in non-blocking mode),
  1578. * subsequent reads will time out after a few milliseconds.
  1579. * Return of -1 means EOF or error (errno == 0 on EOF).
  1580. * buffer[0] is used as a counter of buffered chars and must be 0
  1581. * on first call.
  1582. * timeout:
  1583. * -2: do not poll(-1) for input - read() it, return on EAGAIN at once
  1584. * -1: poll(-1) (i.e. block even on NONBLOCKed fd)
  1585. * >=0: poll() for TIMEOUT milliseconds, return -1/EAGAIN on timeout
  1586. */
  1587. int64_t read_key(int fd, char *buffer, int timeout) FAST_FUNC;
  1588. void read_key_ungets(char *buffer, const char *str, unsigned len) FAST_FUNC;
  1589. #if ENABLE_FEATURE_EDITING
  1590. /* It's NOT just ENABLEd or disabled. It's a number: */
  1591. # if defined CONFIG_FEATURE_EDITING_HISTORY && CONFIG_FEATURE_EDITING_HISTORY > 0
  1592. # define MAX_HISTORY (CONFIG_FEATURE_EDITING_HISTORY + 0)
  1593. unsigned size_from_HISTFILESIZE(const char *hp) FAST_FUNC;
  1594. # else
  1595. # define MAX_HISTORY 0
  1596. # endif
  1597. typedef struct line_input_t {
  1598. int flags;
  1599. int timeout;
  1600. const char *path_lookup;
  1601. # if MAX_HISTORY
  1602. int cnt_history;
  1603. int cur_history;
  1604. int max_history; /* must never be <= 0 */
  1605. # if ENABLE_FEATURE_EDITING_SAVEHISTORY
  1606. /* meaning of this field depends on FEATURE_EDITING_SAVE_ON_EXIT:
  1607. * if !FEATURE_EDITING_SAVE_ON_EXIT: "how many lines are
  1608. * in on-disk history"
  1609. * if FEATURE_EDITING_SAVE_ON_EXIT: "how many in-memory lines are
  1610. * also in on-disk history (and thus need to be skipped on save)"
  1611. */
  1612. unsigned cnt_history_in_file;
  1613. const char *hist_file;
  1614. # endif
  1615. char *history[MAX_HISTORY + 1];
  1616. # endif
  1617. } line_input_t;
  1618. enum {
  1619. DO_HISTORY = 1 * (MAX_HISTORY > 0),
  1620. TAB_COMPLETION = 2 * ENABLE_FEATURE_TAB_COMPLETION,
  1621. USERNAME_COMPLETION = 4 * ENABLE_FEATURE_USERNAME_COMPLETION,
  1622. VI_MODE = 8 * ENABLE_FEATURE_EDITING_VI,
  1623. WITH_PATH_LOOKUP = 0x10,
  1624. FOR_SHELL = DO_HISTORY | TAB_COMPLETION | USERNAME_COMPLETION,
  1625. };
  1626. line_input_t *new_line_input_t(int flags) FAST_FUNC;
  1627. /* So far static: void free_line_input_t(line_input_t *n) FAST_FUNC; */
  1628. /*
  1629. * maxsize must be >= 2.
  1630. * Returns:
  1631. * -1 on read errors or EOF, or on bare Ctrl-D,
  1632. * 0 on ctrl-C (the line entered is still returned in 'command'),
  1633. * >0 length of input string, including terminating '\n'
  1634. */
  1635. int read_line_input(line_input_t *st, const char *prompt, char *command, int maxsize) FAST_FUNC;
  1636. void show_history(const line_input_t *st) FAST_FUNC;
  1637. # if ENABLE_FEATURE_EDITING_SAVE_ON_EXIT
  1638. void save_history(line_input_t *st);
  1639. # endif
  1640. #else
  1641. #define MAX_HISTORY 0
  1642. int read_line_input(const char* prompt, char* command, int maxsize) FAST_FUNC;
  1643. #define read_line_input(state, prompt, command, maxsize) \
  1644. read_line_input(prompt, command, maxsize)
  1645. #endif
  1646. #ifndef COMM_LEN
  1647. # ifdef TASK_COMM_LEN
  1648. enum { COMM_LEN = TASK_COMM_LEN };
  1649. # else
  1650. /* synchronize with sizeof(task_struct.comm) in /usr/include/linux/sched.h */
  1651. enum { COMM_LEN = 16 };
  1652. # endif
  1653. #endif
  1654. struct smaprec {
  1655. unsigned long mapped_rw;
  1656. unsigned long mapped_ro;
  1657. unsigned long shared_clean;
  1658. unsigned long shared_dirty;
  1659. unsigned long private_clean;
  1660. unsigned long private_dirty;
  1661. unsigned long stack;
  1662. unsigned long smap_pss, smap_swap;
  1663. unsigned long smap_size;
  1664. unsigned long smap_start;
  1665. char smap_mode[5];
  1666. char *smap_name;
  1667. };
  1668. #if !ENABLE_PMAP
  1669. #define procps_read_smaps(pid, total, cb, data) \
  1670. procps_read_smaps(pid, total)
  1671. #endif
  1672. int FAST_FUNC procps_read_smaps(pid_t pid, struct smaprec *total,
  1673. void (*cb)(struct smaprec *, void *), void *data);
  1674. typedef struct procps_status_t {
  1675. DIR *dir;
  1676. IF_FEATURE_SHOW_THREADS(DIR *task_dir;)
  1677. uint8_t shift_pages_to_bytes;
  1678. uint8_t shift_pages_to_kb;
  1679. /* Fields are set to 0/NULL if failed to determine (or not requested) */
  1680. uint16_t argv_len;
  1681. char *argv0;
  1682. char *exe;
  1683. IF_SELINUX(char *context;)
  1684. IF_FEATURE_SHOW_THREADS(unsigned main_thread_pid;)
  1685. /* Everything below must contain no ptrs to malloc'ed data:
  1686. * it is memset(0) for each process in procps_scan() */
  1687. unsigned long vsz, rss; /* we round it to kbytes */
  1688. unsigned long stime, utime;
  1689. unsigned long start_time;
  1690. unsigned pid;
  1691. unsigned ppid;
  1692. unsigned pgid;
  1693. unsigned sid;
  1694. unsigned uid;
  1695. unsigned gid;
  1696. #if ENABLE_FEATURE_PS_ADDITIONAL_COLUMNS
  1697. unsigned ruid;
  1698. unsigned rgid;
  1699. int niceness;
  1700. #endif
  1701. unsigned tty_major,tty_minor;
  1702. #if ENABLE_FEATURE_TOPMEM
  1703. struct smaprec smaps;
  1704. #endif
  1705. char state[4];
  1706. /* basename of executable in exec(2), read from /proc/N/stat
  1707. * (if executable is symlink or script, it is NOT replaced
  1708. * by link target or interpreter name) */
  1709. char comm[COMM_LEN];
  1710. /* user/group? - use passwd/group parsing functions */
  1711. #if ENABLE_FEATURE_TOP_SMP_PROCESS
  1712. int last_seen_on_cpu;
  1713. #endif
  1714. } procps_status_t;
  1715. /* flag bits for procps_scan(xx, flags) calls */
  1716. enum {
  1717. PSSCAN_PID = 1 << 0,
  1718. PSSCAN_PPID = 1 << 1,
  1719. PSSCAN_PGID = 1 << 2,
  1720. PSSCAN_SID = 1 << 3,
  1721. PSSCAN_UIDGID = 1 << 4,
  1722. PSSCAN_COMM = 1 << 5,
  1723. /* PSSCAN_CMD = 1 << 6, - use read_cmdline instead */
  1724. PSSCAN_ARGV0 = 1 << 7,
  1725. PSSCAN_EXE = 1 << 8,
  1726. PSSCAN_STATE = 1 << 9,
  1727. PSSCAN_VSZ = 1 << 10,
  1728. PSSCAN_RSS = 1 << 11,
  1729. PSSCAN_STIME = 1 << 12,
  1730. PSSCAN_UTIME = 1 << 13,
  1731. PSSCAN_TTY = 1 << 14,
  1732. PSSCAN_SMAPS = (1 << 15) * ENABLE_FEATURE_TOPMEM,
  1733. /* NB: used by find_pid_by_name(). Any applet using it
  1734. * needs to be mentioned here. */
  1735. PSSCAN_ARGVN = (1 << 16) * (ENABLE_KILLALL
  1736. || ENABLE_PGREP || ENABLE_PKILL
  1737. || ENABLE_PIDOF
  1738. || ENABLE_SESTATUS
  1739. ),
  1740. PSSCAN_CONTEXT = (1 << 17) * ENABLE_SELINUX,
  1741. PSSCAN_START_TIME = 1 << 18,
  1742. PSSCAN_CPU = (1 << 19) * ENABLE_FEATURE_TOP_SMP_PROCESS,
  1743. PSSCAN_NICE = (1 << 20) * ENABLE_FEATURE_PS_ADDITIONAL_COLUMNS,
  1744. PSSCAN_RUIDGID = (1 << 21) * ENABLE_FEATURE_PS_ADDITIONAL_COLUMNS,
  1745. PSSCAN_TASKS = (1 << 22) * ENABLE_FEATURE_SHOW_THREADS,
  1746. };
  1747. //procps_status_t* alloc_procps_scan(void) FAST_FUNC;
  1748. void free_procps_scan(procps_status_t* sp) FAST_FUNC;
  1749. procps_status_t* procps_scan(procps_status_t* sp, int flags) FAST_FUNC;
  1750. /* Format cmdline (up to col chars) into char buf[size] */
  1751. /* Puts [comm] if cmdline is empty (-> process is a kernel thread) */
  1752. void read_cmdline(char *buf, int size, unsigned pid, const char *comm) FAST_FUNC;
  1753. pid_t *find_pid_by_name(const char* procName) FAST_FUNC;
  1754. pid_t *pidlist_reverse(pid_t *pidList) FAST_FUNC;
  1755. int starts_with_cpu(const char *str) FAST_FUNC;
  1756. unsigned get_cpu_count(void) FAST_FUNC;
  1757. /* Use strict=1 if you process input from untrusted source:
  1758. * it will return NULL on invalid %xx (bad hex chars)
  1759. * and str + 1 if decoded char is / or NUL.
  1760. * In non-strict mode, it always succeeds (returns str),
  1761. * and also it additionally decoded '+' to space.
  1762. */
  1763. char *percent_decode_in_place(char *str, int strict) FAST_FUNC;
  1764. extern const char bb_uuenc_tbl_base64[] ALIGN1;
  1765. extern const char bb_uuenc_tbl_std[] ALIGN1;
  1766. void bb_uuencode(char *store, const void *s, int length, const char *tbl) FAST_FUNC;
  1767. enum {
  1768. BASE64_FLAG_UU_STOP = 0x100,
  1769. /* Sign-extends to a value which never matches fgetc result: */
  1770. BASE64_FLAG_NO_STOP_CHAR = 0x80,
  1771. };
  1772. const char *decode_base64(char **pp_dst, const char *src) FAST_FUNC;
  1773. void read_base64(FILE *src_stream, FILE *dst_stream, int flags) FAST_FUNC;
  1774. typedef struct md5_ctx_t {
  1775. uint8_t wbuffer[64]; /* always correctly aligned for uint64_t */
  1776. void (*process_block)(struct md5_ctx_t*) FAST_FUNC;
  1777. uint64_t total64; /* must be directly before hash[] */
  1778. uint32_t hash[8]; /* 4 elements for md5, 5 for sha1, 8 for sha256 */
  1779. } md5_ctx_t;
  1780. typedef struct md5_ctx_t sha1_ctx_t;
  1781. typedef struct md5_ctx_t sha256_ctx_t;
  1782. typedef struct sha512_ctx_t {
  1783. uint64_t total64[2]; /* must be directly before hash[] */
  1784. uint64_t hash[8];
  1785. uint8_t wbuffer[128]; /* always correctly aligned for uint64_t */
  1786. } sha512_ctx_t;
  1787. typedef struct sha3_ctx_t {
  1788. uint64_t state[25];
  1789. unsigned bytes_queued;
  1790. unsigned input_block_bytes;
  1791. } sha3_ctx_t;
  1792. void md5_begin(md5_ctx_t *ctx) FAST_FUNC;
  1793. void md5_hash(md5_ctx_t *ctx, const void *buffer, size_t len) FAST_FUNC;
  1794. unsigned md5_end(md5_ctx_t *ctx, void *resbuf) FAST_FUNC;
  1795. void sha1_begin(sha1_ctx_t *ctx) FAST_FUNC;
  1796. #define sha1_hash md5_hash
  1797. unsigned sha1_end(sha1_ctx_t *ctx, void *resbuf) FAST_FUNC;
  1798. void sha256_begin(sha256_ctx_t *ctx) FAST_FUNC;
  1799. #define sha256_hash md5_hash
  1800. #define sha256_end sha1_end
  1801. void sha512_begin(sha512_ctx_t *ctx) FAST_FUNC;
  1802. void sha512_hash(sha512_ctx_t *ctx, const void *buffer, size_t len) FAST_FUNC;
  1803. unsigned sha512_end(sha512_ctx_t *ctx, void *resbuf) FAST_FUNC;
  1804. void sha3_begin(sha3_ctx_t *ctx) FAST_FUNC;
  1805. void sha3_hash(sha3_ctx_t *ctx, const void *buffer, size_t len) FAST_FUNC;
  1806. unsigned sha3_end(sha3_ctx_t *ctx, void *resbuf) FAST_FUNC;
  1807. /* TLS benefits from knowing that sha1 and sha256 share these. Give them "agnostic" names too */
  1808. typedef struct md5_ctx_t md5sha_ctx_t;
  1809. #define md5sha_hash md5_hash
  1810. #define sha_end sha1_end
  1811. extern uint32_t *global_crc32_table;
  1812. uint32_t *crc32_filltable(uint32_t *tbl256, int endian) FAST_FUNC;
  1813. uint32_t *crc32_new_table_le(void) FAST_FUNC;
  1814. uint32_t *global_crc32_new_table_le(void) FAST_FUNC;
  1815. uint32_t crc32_block_endian1(uint32_t val, const void *buf, unsigned len, uint32_t *crc_table) FAST_FUNC;
  1816. uint32_t crc32_block_endian0(uint32_t val, const void *buf, unsigned len, uint32_t *crc_table) FAST_FUNC;
  1817. typedef struct masks_labels_t {
  1818. const char *labels;
  1819. const int masks[];
  1820. } masks_labels_t;
  1821. int print_flags_separated(const int *masks, const char *labels,
  1822. int flags, const char *separator) FAST_FUNC;
  1823. int print_flags(const masks_labels_t *ml, int flags) FAST_FUNC;
  1824. typedef struct bb_progress_t {
  1825. unsigned last_size;
  1826. unsigned last_update_sec;
  1827. unsigned last_change_sec;
  1828. unsigned start_sec;
  1829. /*unsigned last_eta;*/
  1830. const char *curfile;
  1831. } bb_progress_t;
  1832. #define is_bb_progress_inited(p) ((p)->curfile != NULL)
  1833. #define bb_progress_free(p) do { \
  1834. if (ENABLE_UNICODE_SUPPORT) free((char*)((p)->curfile)); \
  1835. (p)->curfile = NULL; \
  1836. } while (0)
  1837. void bb_progress_init(bb_progress_t *p, const char *curfile) FAST_FUNC;
  1838. void bb_progress_update(bb_progress_t *p,
  1839. uoff_t beg_range,
  1840. uoff_t transferred,
  1841. uoff_t totalsize) FAST_FUNC;
  1842. unsigned ubi_devnum_from_devname(const char *str) FAST_FUNC;
  1843. int ubi_get_volid_by_name(unsigned ubi_devnum, const char *vol_name) FAST_FUNC;
  1844. extern const char *applet_name;
  1845. /* Some older linkers don't perform string merging, we used to have common strings
  1846. * as global arrays to do it by hand. But:
  1847. * (1) newer linkers do it themselves,
  1848. * (2) however, they DONT merge string constants with global arrays,
  1849. * even if the value is the same (!). Thus global arrays actually
  1850. * increased size a bit: for example, "/etc/passwd" string from libc
  1851. * wasn't merged with bb_path_passwd_file[] array!
  1852. * Therefore now we use #defines.
  1853. */
  1854. /* "BusyBox vN.N.N (timestamp or extra_version)" */
  1855. extern const char bb_banner[] ALIGN1;
  1856. extern const char bb_msg_memory_exhausted[] ALIGN1;
  1857. extern const char bb_msg_invalid_date[] ALIGN1;
  1858. #define bb_msg_read_error "read error"
  1859. #define bb_msg_write_error "write error"
  1860. extern const char bb_msg_unknown[] ALIGN1;
  1861. extern const char bb_msg_can_not_create_raw_socket[] ALIGN1;
  1862. extern const char bb_msg_perm_denied_are_you_root[] ALIGN1;
  1863. extern const char bb_msg_you_must_be_root[] ALIGN1;
  1864. extern const char bb_msg_requires_arg[] ALIGN1;
  1865. extern const char bb_msg_invalid_arg_to[] ALIGN1;
  1866. extern const char bb_msg_standard_input[] ALIGN1;
  1867. extern const char bb_msg_standard_output[] ALIGN1;
  1868. /* NB: (bb_hexdigits_upcase[i] | 0x20) -> lowercase hex digit */
  1869. extern const char bb_hexdigits_upcase[] ALIGN1;
  1870. extern const char bb_path_wtmp_file[] ALIGN1;
  1871. /* Busybox mount uses either /proc/mounts or /etc/mtab to
  1872. * get the list of currently mounted filesystems */
  1873. #define bb_path_mtab_file IF_FEATURE_MTAB_SUPPORT("/etc/mtab")IF_NOT_FEATURE_MTAB_SUPPORT("/proc/mounts")
  1874. #define bb_path_passwd_file _PATH_PASSWD
  1875. #define bb_path_group_file _PATH_GROUP
  1876. #define bb_path_shadow_file _PATH_SHADOW
  1877. #define bb_path_gshadow_file _PATH_GSHADOW
  1878. #define bb_path_motd_file "/etc/motd"
  1879. #define bb_dev_null "/dev/null"
  1880. extern const char bb_busybox_exec_path[] ALIGN1;
  1881. /* allow default system PATH to be extended via CFLAGS */
  1882. #ifndef BB_ADDITIONAL_PATH
  1883. #define BB_ADDITIONAL_PATH ""
  1884. #endif
  1885. #define BB_PATH_ROOT_PATH "PATH=/sbin:/usr/sbin:/bin:/usr/bin" BB_ADDITIONAL_PATH
  1886. extern const char bb_PATH_root_path[] ALIGN1; /* BB_PATH_ROOT_PATH */
  1887. #define bb_default_root_path (bb_PATH_root_path + sizeof("PATH"))
  1888. /* util-linux manpage says /sbin:/bin:/usr/sbin:/usr/bin,
  1889. * but I want to save a few bytes here:
  1890. */
  1891. #define bb_default_path (bb_PATH_root_path + sizeof("PATH=/sbin:/usr/sbin"))
  1892. extern const int const_int_0;
  1893. //extern const int const_int_1;
  1894. /* This struct is deliberately not defined. */
  1895. /* See docs/keep_data_small.txt */
  1896. struct globals;
  1897. /* '*const' ptr makes gcc optimize code much better.
  1898. * Magic prevents ptr_to_globals from going into rodata.
  1899. * If you want to assign a value, use SET_PTR_TO_GLOBALS(x) */
  1900. extern struct globals *const ptr_to_globals;
  1901. /* At least gcc 3.4.6 on mipsel system needs optimization barrier */
  1902. #define barrier() __asm__ __volatile__("":::"memory")
  1903. #define SET_PTR_TO_GLOBALS(x) do { \
  1904. (*(struct globals**)&ptr_to_globals) = (void*)(x); \
  1905. barrier(); \
  1906. } while (0)
  1907. #define FREE_PTR_TO_GLOBALS() do { \
  1908. if (ENABLE_FEATURE_CLEAN_UP) { \
  1909. free(ptr_to_globals); \
  1910. } \
  1911. } while (0)
  1912. /* You can change LIBBB_DEFAULT_LOGIN_SHELL, but don't use it,
  1913. * use bb_default_login_shell and following defines.
  1914. * If you change LIBBB_DEFAULT_LOGIN_SHELL,
  1915. * don't forget to change increment constant. */
  1916. #define LIBBB_DEFAULT_LOGIN_SHELL "-/bin/sh"
  1917. extern const char bb_default_login_shell[] ALIGN1;
  1918. /* "/bin/sh" */
  1919. #define DEFAULT_SHELL (bb_default_login_shell+1)
  1920. /* "sh" */
  1921. #define DEFAULT_SHELL_SHORT_NAME (bb_default_login_shell+6)
  1922. /* The following devices are the same on all systems. */
  1923. #define CURRENT_TTY "/dev/tty"
  1924. #define DEV_CONSOLE "/dev/console"
  1925. #if defined(__FreeBSD_kernel__)
  1926. # define CURRENT_VC CURRENT_TTY
  1927. # define VC_1 "/dev/ttyv0"
  1928. # define VC_2 "/dev/ttyv1"
  1929. # define VC_3 "/dev/ttyv2"
  1930. # define VC_4 "/dev/ttyv3"
  1931. # define VC_5 "/dev/ttyv4"
  1932. # define VC_FORMAT "/dev/ttyv%d"
  1933. #elif defined(__GNU__)
  1934. # define CURRENT_VC CURRENT_TTY
  1935. # define VC_1 "/dev/tty1"
  1936. # define VC_2 "/dev/tty2"
  1937. # define VC_3 "/dev/tty3"
  1938. # define VC_4 "/dev/tty4"
  1939. # define VC_5 "/dev/tty5"
  1940. # define VC_FORMAT "/dev/tty%d"
  1941. #elif ENABLE_FEATURE_DEVFS
  1942. /*Linux, obsolete devfs names */
  1943. # define CURRENT_VC "/dev/vc/0"
  1944. # define VC_1 "/dev/vc/1"
  1945. # define VC_2 "/dev/vc/2"
  1946. # define VC_3 "/dev/vc/3"
  1947. # define VC_4 "/dev/vc/4"
  1948. # define VC_5 "/dev/vc/5"
  1949. # define VC_FORMAT "/dev/vc/%d"
  1950. # define LOOP_FORMAT "/dev/loop/%u"
  1951. # define LOOP_NAMESIZE (sizeof("/dev/loop/") + sizeof(int)*3 + 1)
  1952. # define LOOP_NAME "/dev/loop/"
  1953. # define FB_0 "/dev/fb/0"
  1954. #else
  1955. /*Linux, normal names */
  1956. # define CURRENT_VC "/dev/tty0"
  1957. # define VC_1 "/dev/tty1"
  1958. # define VC_2 "/dev/tty2"
  1959. # define VC_3 "/dev/tty3"
  1960. # define VC_4 "/dev/tty4"
  1961. # define VC_5 "/dev/tty5"
  1962. # define VC_FORMAT "/dev/tty%d"
  1963. # define LOOP_FORMAT "/dev/loop%u"
  1964. # define LOOP_NAMESIZE (sizeof("/dev/loop") + sizeof(int)*3 + 1)
  1965. # define LOOP_NAME "/dev/loop"
  1966. # define FB_0 "/dev/fb0"
  1967. #endif
  1968. // storage helpers for mk*fs utilities
  1969. char BUG_wrong_field_size(void);
  1970. #define STORE_LE(field, value) \
  1971. do { \
  1972. if (sizeof(field) == 4) \
  1973. field = SWAP_LE32((uint32_t)(value)); \
  1974. else if (sizeof(field) == 2) \
  1975. field = SWAP_LE16((uint16_t)(value)); \
  1976. else if (sizeof(field) == 1) \
  1977. field = (uint8_t)(value); \
  1978. else \
  1979. BUG_wrong_field_size(); \
  1980. } while (0)
  1981. #define FETCH_LE32(field) \
  1982. (sizeof(field) == 4 ? SWAP_LE32(field) : BUG_wrong_field_size())
  1983. #define ARRAY_SIZE(x) ((unsigned)(sizeof(x) / sizeof((x)[0])))
  1984. #define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
  1985. /* We redefine ctype macros. Unicode-correct handling of char types
  1986. * can't be done with such byte-oriented operations anyway,
  1987. * we don't lose anything.
  1988. */
  1989. #undef isalnum
  1990. #undef isalpha
  1991. #undef isascii
  1992. #undef isblank
  1993. #undef iscntrl
  1994. #undef isdigit
  1995. #undef isgraph
  1996. #undef islower
  1997. #undef isprint
  1998. #undef ispunct
  1999. #undef isspace
  2000. #undef isupper
  2001. #undef isxdigit
  2002. #undef toupper
  2003. #undef tolower
  2004. /* We save ~500 bytes on isdigit alone.
  2005. * BTW, x86 likes (unsigned char) cast more than (unsigned). */
  2006. /* These work the same for ASCII and Unicode,
  2007. * assuming no one asks "is this a *Unicode* letter?" using isalpha(letter) */
  2008. #define isascii(a) ((unsigned char)(a) <= 0x7f)
  2009. #define isdigit(a) ((unsigned char)((a) - '0') <= 9)
  2010. #define isupper(a) ((unsigned char)((a) - 'A') <= ('Z' - 'A'))
  2011. #define islower(a) ((unsigned char)((a) - 'a') <= ('z' - 'a'))
  2012. #define isalpha(a) ((unsigned char)(((a)|0x20) - 'a') <= ('z' - 'a'))
  2013. #define isblank(a) ({ unsigned char bb__isblank = (a); bb__isblank == ' ' || bb__isblank == '\t'; })
  2014. #define iscntrl(a) ({ unsigned char bb__iscntrl = (a); bb__iscntrl < ' ' || bb__iscntrl == 0x7f; })
  2015. /* In POSIX/C locale isspace is only these chars: "\t\n\v\f\r" and space.
  2016. * "\t\n\v\f\r" happen to have ASCII codes 9,10,11,12,13.
  2017. */
  2018. #define isspace(a) ({ unsigned char bb__isspace = (a) - 9; bb__isspace == (' ' - 9) || bb__isspace <= (13 - 9); })
  2019. // Unsafe wrt NUL: #define ispunct(a) (strchr("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", (a)) != NULL)
  2020. #define ispunct(a) (strchrnul("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", (a))[0])
  2021. // Bigger code: #define isalnum(a) ({ unsigned char bb__isalnum = (a) - '0'; bb__isalnum <= 9 || ((bb__isalnum - ('A' - '0')) & 0xdf) <= 25; })
  2022. #define isalnum(a) bb_ascii_isalnum(a)
  2023. static ALWAYS_INLINE int bb_ascii_isalnum(unsigned char a)
  2024. {
  2025. unsigned char b = a - '0';
  2026. if (b <= 9)
  2027. return (b <= 9);
  2028. b = (a|0x20) - 'a';
  2029. return b <= 'z' - 'a';
  2030. }
  2031. #define isxdigit(a) bb_ascii_isxdigit(a)
  2032. static ALWAYS_INLINE int bb_ascii_isxdigit(unsigned char a)
  2033. {
  2034. unsigned char b = a - '0';
  2035. if (b <= 9)
  2036. return (b <= 9);
  2037. b = (a|0x20) - 'a';
  2038. return b <= 'f' - 'a';
  2039. }
  2040. #define toupper(a) bb_ascii_toupper(a)
  2041. static ALWAYS_INLINE unsigned char bb_ascii_toupper(unsigned char a)
  2042. {
  2043. unsigned char b = a - 'a';
  2044. if (b <= ('z' - 'a'))
  2045. a -= 'a' - 'A';
  2046. return a;
  2047. }
  2048. #define tolower(a) bb_ascii_tolower(a)
  2049. static ALWAYS_INLINE unsigned char bb_ascii_tolower(unsigned char a)
  2050. {
  2051. unsigned char b = a - 'A';
  2052. if (b <= ('Z' - 'A'))
  2053. a += 'a' - 'A';
  2054. return a;
  2055. }
  2056. /* In ASCII and Unicode, these are likely to be very different.
  2057. * Let's prevent ambiguous usage from the start */
  2058. #define isgraph(a) isgraph_is_ambiguous_dont_use(a)
  2059. #define isprint(a) isprint_is_ambiguous_dont_use(a)
  2060. /* NB: must not treat EOF as isgraph or isprint */
  2061. #define isgraph_asciionly(a) ((unsigned)((a) - 0x21) <= 0x7e - 0x21)
  2062. #define isprint_asciionly(a) ((unsigned)((a) - 0x20) <= 0x7e - 0x20)
  2063. /* Simple unit-testing framework */
  2064. typedef void (*bbunit_testfunc)(void);
  2065. struct bbunit_listelem {
  2066. const char* name;
  2067. bbunit_testfunc testfunc;
  2068. };
  2069. void bbunit_registertest(struct bbunit_listelem* test);
  2070. void bbunit_settestfailed(void);
  2071. #define BBUNIT_DEFINE_TEST(NAME) \
  2072. static void bbunit_##NAME##_test(void); \
  2073. static struct bbunit_listelem bbunit_##NAME##_elem = { \
  2074. .name = #NAME, \
  2075. .testfunc = bbunit_##NAME##_test, \
  2076. }; \
  2077. static void INIT_FUNC bbunit_##NAME##_register(void) \
  2078. { \
  2079. bbunit_registertest(&bbunit_##NAME##_elem); \
  2080. } \
  2081. static void bbunit_##NAME##_test(void)
  2082. /*
  2083. * Both 'goto bbunit_end' and 'break' are here only to get rid
  2084. * of compiler warnings.
  2085. */
  2086. #define BBUNIT_ENDTEST \
  2087. do { \
  2088. goto bbunit_end; \
  2089. bbunit_end: \
  2090. break; \
  2091. } while (0)
  2092. #define BBUNIT_PRINTASSERTFAIL \
  2093. do { \
  2094. bb_error_msg( \
  2095. "[ERROR] Assertion failed in file %s, line %d", \
  2096. __FILE__, __LINE__); \
  2097. } while (0)
  2098. #define BBUNIT_ASSERTION_FAILED \
  2099. do { \
  2100. bbunit_settestfailed(); \
  2101. goto bbunit_end; \
  2102. } while (0)
  2103. /*
  2104. * Assertions.
  2105. * For now we only offer assertions which cause tests to fail
  2106. * immediately. In the future 'expects' might be added too -
  2107. * similar to those offered by the gtest framework.
  2108. */
  2109. #define BBUNIT_ASSERT_EQ(EXPECTED, ACTUAL) \
  2110. do { \
  2111. if ((EXPECTED) != (ACTUAL)) { \
  2112. BBUNIT_PRINTASSERTFAIL; \
  2113. bb_error_msg("[ERROR] '%s' isn't equal to '%s'", \
  2114. #EXPECTED, #ACTUAL); \
  2115. BBUNIT_ASSERTION_FAILED; \
  2116. } \
  2117. } while (0)
  2118. #define BBUNIT_ASSERT_NOTEQ(EXPECTED, ACTUAL) \
  2119. do { \
  2120. if ((EXPECTED) == (ACTUAL)) { \
  2121. BBUNIT_PRINTASSERTFAIL; \
  2122. bb_error_msg("[ERROR] '%s' is equal to '%s'", \
  2123. #EXPECTED, #ACTUAL); \
  2124. BBUNIT_ASSERTION_FAILED; \
  2125. } \
  2126. } while (0)
  2127. #define BBUNIT_ASSERT_NOTNULL(PTR) \
  2128. do { \
  2129. if ((PTR) == NULL) { \
  2130. BBUNIT_PRINTASSERTFAIL; \
  2131. bb_error_msg("[ERROR] '%s' is NULL!", #PTR); \
  2132. BBUNIT_ASSERTION_FAILED; \
  2133. } \
  2134. } while (0)
  2135. #define BBUNIT_ASSERT_NULL(PTR) \
  2136. do { \
  2137. if ((PTR) != NULL) { \
  2138. BBUNIT_PRINTASSERTFAIL; \
  2139. bb_error_msg("[ERROR] '%s' is not NULL!", #PTR); \
  2140. BBUNIT_ASSERTION_FAILED; \
  2141. } \
  2142. } while (0)
  2143. #define BBUNIT_ASSERT_FALSE(STATEMENT) \
  2144. do { \
  2145. if ((STATEMENT)) { \
  2146. BBUNIT_PRINTASSERTFAIL; \
  2147. bb_error_msg("[ERROR] Statement '%s' evaluated to true!", \
  2148. #STATEMENT); \
  2149. BBUNIT_ASSERTION_FAILED; \
  2150. } \
  2151. } while (0)
  2152. #define BBUNIT_ASSERT_TRUE(STATEMENT) \
  2153. do { \
  2154. if (!(STATEMENT)) { \
  2155. BBUNIT_PRINTASSERTFAIL; \
  2156. bb_error_msg("[ERROR] Statement '%s' evaluated to false!", \
  2157. #STATEMENT); \
  2158. BBUNIT_ASSERTION_FAILED; \
  2159. } \
  2160. } while (0)
  2161. #define BBUNIT_ASSERT_STREQ(STR1, STR2) \
  2162. do { \
  2163. if (strcmp(STR1, STR2) != 0) { \
  2164. BBUNIT_PRINTASSERTFAIL; \
  2165. bb_error_msg("[ERROR] Strings '%s' and '%s' " \
  2166. "are not the same", STR1, STR2); \
  2167. BBUNIT_ASSERTION_FAILED; \
  2168. } \
  2169. } while (0)
  2170. #define BBUNIT_ASSERT_STRNOTEQ(STR1, STR2) \
  2171. do { \
  2172. if (strcmp(STR1, STR2) == 0) { \
  2173. BBUNIT_PRINTASSERTFAIL; \
  2174. bb_error_msg("[ERROR] Strings '%s' and '%s' " \
  2175. "are the same, but were " \
  2176. "expected to differ", STR1, STR2); \
  2177. BBUNIT_ASSERTION_FAILED; \
  2178. } \
  2179. } while (0)
  2180. POP_SAVED_FUNCTION_VISIBILITY
  2181. #endif