util.h 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580
  1. /* Copyright (c) 2003-2004, Roger Dingledine
  2. * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  3. * Copyright (c) 2007-2017, The Tor Project, Inc. */
  4. /* See LICENSE for licensing information */
  5. /**
  6. * \file util.h
  7. * \brief Headers for util.c
  8. **/
  9. #ifndef TOR_UTIL_H
  10. #define TOR_UTIL_H
  11. #include "orconfig.h"
  12. #include "torint.h"
  13. #include "compat.h"
  14. #include "di_ops.h"
  15. #include "testsupport.h"
  16. #include <stdio.h>
  17. #include <stdlib.h>
  18. #ifdef _WIN32
  19. /* for the correct alias to struct stat */
  20. #include <sys/stat.h>
  21. #endif
  22. #include "util_bug.h"
  23. #ifndef O_BINARY
  24. #define O_BINARY 0
  25. #endif
  26. #ifndef O_TEXT
  27. #define O_TEXT 0
  28. #endif
  29. #ifndef O_NOFOLLOW
  30. #define O_NOFOLLOW 0
  31. #endif
  32. /* If we're building with dmalloc, we want all of our memory allocation
  33. * functions to take an extra file/line pair of arguments. If not, not.
  34. * We define DMALLOC_PARAMS to the extra parameters to insert in the
  35. * function prototypes, and DMALLOC_ARGS to the extra arguments to add
  36. * to calls. */
  37. #ifdef USE_DMALLOC
  38. #define DMALLOC_PARAMS , const char *file, const int line
  39. #define DMALLOC_ARGS , SHORT_FILE__, __LINE__
  40. #else
  41. #define DMALLOC_PARAMS
  42. #define DMALLOC_ARGS
  43. #endif /* defined(USE_DMALLOC) */
  44. /* Memory management */
  45. void *tor_malloc_(size_t size DMALLOC_PARAMS) ATTR_MALLOC;
  46. void *tor_malloc_zero_(size_t size DMALLOC_PARAMS) ATTR_MALLOC;
  47. void *tor_calloc_(size_t nmemb, size_t size DMALLOC_PARAMS) ATTR_MALLOC;
  48. void *tor_realloc_(void *ptr, size_t size DMALLOC_PARAMS);
  49. void *tor_reallocarray_(void *ptr, size_t size1, size_t size2 DMALLOC_PARAMS);
  50. char *tor_strdup_(const char *s DMALLOC_PARAMS) ATTR_MALLOC ATTR_NONNULL((1));
  51. char *tor_strndup_(const char *s, size_t n DMALLOC_PARAMS)
  52. ATTR_MALLOC ATTR_NONNULL((1));
  53. void *tor_memdup_(const void *mem, size_t len DMALLOC_PARAMS)
  54. ATTR_MALLOC ATTR_NONNULL((1));
  55. void *tor_memdup_nulterm_(const void *mem, size_t len DMALLOC_PARAMS)
  56. ATTR_MALLOC ATTR_NONNULL((1));
  57. void tor_free_(void *mem);
  58. uint64_t tor_htonll(uint64_t a);
  59. uint64_t tor_ntohll(uint64_t a);
  60. #ifdef USE_DMALLOC
  61. extern int dmalloc_free(const char *file, const int line, void *pnt,
  62. const int func_id);
  63. #define tor_free(p) STMT_BEGIN \
  64. if (PREDICT_LIKELY((p)!=NULL)) { \
  65. dmalloc_free(SHORT_FILE__, __LINE__, (p), 0); \
  66. (p)=NULL; \
  67. } \
  68. STMT_END
  69. #else /* !(defined(USE_DMALLOC)) */
  70. /** Release memory allocated by tor_malloc, tor_realloc, tor_strdup, etc.
  71. * Unlike the free() function, tor_free() will still work on NULL pointers,
  72. * and it sets the pointer value to NULL after freeing it.
  73. *
  74. * This is a macro. If you need a function pointer to release memory from
  75. * tor_malloc(), use tor_free_().
  76. *
  77. * Note that this macro takes the address of the pointer it is going to
  78. * free and clear. If that pointer is stored with a nonstandard
  79. * alignment (eg because of a "packed" pragma) it is not correct to use
  80. * tor_free().
  81. */
  82. #ifdef __GNUC__
  83. #define tor_free(p) STMT_BEGIN \
  84. typeof(&(p)) tor_free__tmpvar = &(p); \
  85. if (PREDICT_LIKELY((*tor_free__tmpvar)!=NULL)) { \
  86. raw_free(*tor_free__tmpvar); \
  87. *tor_free__tmpvar=NULL; \
  88. } \
  89. STMT_END
  90. #else
  91. #define tor_free(p) STMT_BEGIN \
  92. if (PREDICT_LIKELY((p)!=NULL)) { \
  93. raw_free(p); \
  94. (p)=NULL; \
  95. } \
  96. STMT_END
  97. #endif
  98. #endif /* defined(USE_DMALLOC) */
  99. #define tor_malloc(size) tor_malloc_(size DMALLOC_ARGS)
  100. #define tor_malloc_zero(size) tor_malloc_zero_(size DMALLOC_ARGS)
  101. #define tor_calloc(nmemb,size) tor_calloc_(nmemb, size DMALLOC_ARGS)
  102. #define tor_realloc(ptr, size) tor_realloc_(ptr, size DMALLOC_ARGS)
  103. #define tor_reallocarray(ptr, sz1, sz2) \
  104. tor_reallocarray_((ptr), (sz1), (sz2) DMALLOC_ARGS)
  105. #define tor_strdup(s) tor_strdup_(s DMALLOC_ARGS)
  106. #define tor_strndup(s, n) tor_strndup_(s, n DMALLOC_ARGS)
  107. #define tor_memdup(s, n) tor_memdup_(s, n DMALLOC_ARGS)
  108. #define tor_memdup_nulterm(s, n) tor_memdup_nulterm_(s, n DMALLOC_ARGS)
  109. /* Aliases for the underlying system malloc/realloc/free. Only use
  110. * them to indicate "I really want the underlying system function, I know
  111. * what I'm doing." */
  112. #define raw_malloc malloc
  113. #define raw_realloc realloc
  114. #define raw_free free
  115. #define raw_strdup strdup
  116. void tor_log_mallinfo(int severity);
  117. /* Helper macro: free a variable of type 'typename' using freefn, and
  118. * set the variable to NULL.
  119. */
  120. #define FREE_AND_NULL(typename, freefn, var) \
  121. do { \
  122. /* only evaluate (var) once. */ \
  123. typename **tmp__free__ptr ## freefn = &(var); \
  124. freefn(*tmp__free__ptr ## freefn); \
  125. (*tmp__free__ptr ## freefn) = NULL; \
  126. } while (0)
  127. /** Macro: yield a pointer to the field at position <b>off</b> within the
  128. * structure <b>st</b>. Example:
  129. * <pre>
  130. * struct a { int foo; int bar; } x;
  131. * off_t bar_offset = offsetof(struct a, bar);
  132. * int *bar_p = STRUCT_VAR_P(&x, bar_offset);
  133. * *bar_p = 3;
  134. * </pre>
  135. */
  136. #define STRUCT_VAR_P(st, off) ((void*) ( ((char*)(st)) + (off) ) )
  137. /** Macro: yield a pointer to an enclosing structure given a pointer to
  138. * a substructure at offset <b>off</b>. Example:
  139. * <pre>
  140. * struct base { ... };
  141. * struct subtype { int x; struct base b; } x;
  142. * struct base *bp = &x.base;
  143. * struct *sp = SUBTYPE_P(bp, struct subtype, b);
  144. * </pre>
  145. */
  146. #define SUBTYPE_P(p, subtype, basemember) \
  147. ((void*) ( ((char*)(p)) - offsetof(subtype, basemember) ))
  148. /* Logic */
  149. /** Macro: true if two values have the same boolean value. */
  150. #define bool_eq(a,b) (!(a)==!(b))
  151. /** Macro: true if two values have different boolean values. */
  152. #define bool_neq(a,b) (!(a)!=!(b))
  153. /* Math functions */
  154. double tor_mathlog(double d) ATTR_CONST;
  155. long tor_lround(double d) ATTR_CONST;
  156. int64_t tor_llround(double d) ATTR_CONST;
  157. int tor_log2(uint64_t u64) ATTR_CONST;
  158. uint64_t round_to_power_of_2(uint64_t u64);
  159. unsigned round_to_next_multiple_of(unsigned number, unsigned divisor);
  160. uint32_t round_uint32_to_next_multiple_of(uint32_t number, uint32_t divisor);
  161. uint64_t round_uint64_to_next_multiple_of(uint64_t number, uint64_t divisor);
  162. int64_t sample_laplace_distribution(double mu, double b, double p);
  163. int64_t add_laplace_noise(int64_t signal, double random, double delta_f,
  164. double epsilon);
  165. int n_bits_set_u8(uint8_t v);
  166. int64_t clamp_double_to_int64(double number);
  167. void simplify_fraction64(uint64_t *numer, uint64_t *denom);
  168. /* Compute the CEIL of <b>a</b> divided by <b>b</b>, for nonnegative <b>a</b>
  169. * and positive <b>b</b>. Works on integer types only. Not defined if a+(b-1)
  170. * can overflow. */
  171. #define CEIL_DIV(a,b) (((a)+((b)-1))/(b))
  172. /* Return <b>v</b> if it's between <b>min</b> and <b>max</b>. Otherwise
  173. * return <b>min</b> if <b>v</b> is smaller than <b>min</b>, or <b>max</b> if
  174. * <b>b</b> is larger than <b>max</b>.
  175. *
  176. * Requires that <b>min</b> is no more than <b>max</b>. May evaluate any of
  177. * its arguments more than once! */
  178. #define CLAMP(min,v,max) \
  179. ( ((v) < (min)) ? (min) : \
  180. ((v) > (max)) ? (max) : \
  181. (v) )
  182. /* String manipulation */
  183. /** Allowable characters in a hexadecimal string. */
  184. #define HEX_CHARACTERS "0123456789ABCDEFabcdef"
  185. void tor_strlower(char *s) ATTR_NONNULL((1));
  186. void tor_strupper(char *s) ATTR_NONNULL((1));
  187. int tor_strisprint(const char *s) ATTR_NONNULL((1));
  188. int tor_strisnonupper(const char *s) ATTR_NONNULL((1));
  189. int tor_strisspace(const char *s);
  190. int strcmp_opt(const char *s1, const char *s2);
  191. int strcmpstart(const char *s1, const char *s2) ATTR_NONNULL((1,2));
  192. int strcmp_len(const char *s1, const char *s2, size_t len) ATTR_NONNULL((1,2));
  193. int strcasecmpstart(const char *s1, const char *s2) ATTR_NONNULL((1,2));
  194. int strcmpend(const char *s1, const char *s2) ATTR_NONNULL((1,2));
  195. int strcasecmpend(const char *s1, const char *s2) ATTR_NONNULL((1,2));
  196. int fast_memcmpstart(const void *mem, size_t memlen, const char *prefix);
  197. void tor_strstrip(char *s, const char *strip) ATTR_NONNULL((1,2));
  198. long tor_parse_long(const char *s, int base, long min,
  199. long max, int *ok, char **next);
  200. unsigned long tor_parse_ulong(const char *s, int base, unsigned long min,
  201. unsigned long max, int *ok, char **next);
  202. double tor_parse_double(const char *s, double min, double max, int *ok,
  203. char **next);
  204. uint64_t tor_parse_uint64(const char *s, int base, uint64_t min,
  205. uint64_t max, int *ok, char **next);
  206. const char *hex_str(const char *from, size_t fromlen) ATTR_NONNULL((1));
  207. const char *eat_whitespace(const char *s);
  208. const char *eat_whitespace_eos(const char *s, const char *eos);
  209. const char *eat_whitespace_no_nl(const char *s);
  210. const char *eat_whitespace_eos_no_nl(const char *s, const char *eos);
  211. const char *find_whitespace(const char *s);
  212. const char *find_whitespace_eos(const char *s, const char *eos);
  213. const char *find_str_at_start_of_line(const char *haystack,
  214. const char *needle);
  215. int string_is_C_identifier(const char *string);
  216. int string_is_key_value(int severity, const char *string);
  217. int string_is_valid_dest(const char *string);
  218. int string_is_valid_nonrfc_hostname(const char *string);
  219. int string_is_valid_ipv4_address(const char *string);
  220. int string_is_valid_ipv6_address(const char *string);
  221. int tor_mem_is_zero(const char *mem, size_t len);
  222. int tor_digest_is_zero(const char *digest);
  223. int tor_digest256_is_zero(const char *digest);
  224. char *esc_for_log(const char *string) ATTR_MALLOC;
  225. char *esc_for_log_len(const char *chars, size_t n) ATTR_MALLOC;
  226. const char *escaped(const char *string);
  227. char *tor_escape_str_for_pt_args(const char *string,
  228. const char *chars_to_escape);
  229. struct smartlist_t;
  230. int tor_vsscanf(const char *buf, const char *pattern, va_list ap) \
  231. CHECK_SCANF(2, 0);
  232. int tor_sscanf(const char *buf, const char *pattern, ...)
  233. CHECK_SCANF(2, 3);
  234. void smartlist_add_asprintf(struct smartlist_t *sl, const char *pattern, ...)
  235. CHECK_PRINTF(2, 3);
  236. void smartlist_add_vasprintf(struct smartlist_t *sl, const char *pattern,
  237. va_list args)
  238. CHECK_PRINTF(2, 0);
  239. void smartlist_add_strdup(struct smartlist_t *sl, const char *string);
  240. /* Time helpers */
  241. long tv_udiff(const struct timeval *start, const struct timeval *end);
  242. long tv_mdiff(const struct timeval *start, const struct timeval *end);
  243. int64_t tv_to_msec(const struct timeval *tv);
  244. int tor_timegm(const struct tm *tm, time_t *time_out);
  245. #define RFC1123_TIME_LEN 29
  246. void format_rfc1123_time(char *buf, time_t t);
  247. int parse_rfc1123_time(const char *buf, time_t *t);
  248. #define ISO_TIME_LEN 19
  249. #define ISO_TIME_USEC_LEN (ISO_TIME_LEN+7)
  250. void format_local_iso_time(char *buf, time_t t);
  251. void format_iso_time(char *buf, time_t t);
  252. void format_iso_time_nospace(char *buf, time_t t);
  253. void format_iso_time_nospace_usec(char *buf, const struct timeval *tv);
  254. int parse_iso_time_(const char *cp, time_t *t, int strict, int nospace);
  255. int parse_iso_time(const char *buf, time_t *t);
  256. int parse_iso_time_nospace(const char *cp, time_t *t);
  257. int parse_http_time(const char *buf, struct tm *tm);
  258. int format_time_interval(char *out, size_t out_len, long interval);
  259. /* Cached time */
  260. #ifdef TIME_IS_FAST
  261. #define approx_time() time(NULL)
  262. #define update_approx_time(t) STMT_NIL
  263. #else
  264. time_t approx_time(void);
  265. void update_approx_time(time_t now);
  266. #endif /* defined(TIME_IS_FAST) */
  267. /* Rate-limiter */
  268. /** A ratelim_t remembers how often an event is occurring, and how often
  269. * it's allowed to occur. Typical usage is something like:
  270. *
  271. <pre>
  272. if (possibly_very_frequent_event()) {
  273. const int INTERVAL = 300;
  274. static ratelim_t warning_limit = RATELIM_INIT(INTERVAL);
  275. char *m;
  276. if ((m = rate_limit_log(&warning_limit, approx_time()))) {
  277. log_warn(LD_GENERAL, "The event occurred!%s", m);
  278. tor_free(m);
  279. }
  280. }
  281. </pre>
  282. As a convenience wrapper for logging, you can replace the above with:
  283. <pre>
  284. if (possibly_very_frequent_event()) {
  285. static ratelim_t warning_limit = RATELIM_INIT(300);
  286. log_fn_ratelim(&warning_limit, LOG_WARN, LD_GENERAL,
  287. "The event occurred!");
  288. }
  289. </pre>
  290. */
  291. typedef struct ratelim_t {
  292. int rate;
  293. time_t last_allowed;
  294. int n_calls_since_last_time;
  295. } ratelim_t;
  296. #define RATELIM_INIT(r) { (r), 0, 0 }
  297. #define RATELIM_TOOMANY (16*1000*1000)
  298. char *rate_limit_log(ratelim_t *lim, time_t now);
  299. /* File helpers */
  300. ssize_t write_all(tor_socket_t fd, const char *buf, size_t count,int isSocket);
  301. ssize_t read_all(tor_socket_t fd, char *buf, size_t count, int isSocket);
  302. /** Status of an I/O stream. */
  303. enum stream_status {
  304. IO_STREAM_OKAY,
  305. IO_STREAM_EAGAIN,
  306. IO_STREAM_TERM,
  307. IO_STREAM_CLOSED
  308. };
  309. const char *stream_status_to_string(enum stream_status stream_status);
  310. enum stream_status get_string_from_pipe(int fd, char *buf, size_t count);
  311. MOCK_DECL(int,tor_unlink,(const char *pathname));
  312. /** Return values from file_status(); see that function's documentation
  313. * for details. */
  314. typedef enum { FN_ERROR, FN_NOENT, FN_FILE, FN_DIR, FN_EMPTY } file_status_t;
  315. file_status_t file_status(const char *filename);
  316. /** Possible behaviors for check_private_dir() on encountering a nonexistent
  317. * directory; see that function's documentation for details. */
  318. typedef unsigned int cpd_check_t;
  319. #define CPD_NONE 0
  320. #define CPD_CREATE (1u << 0)
  321. #define CPD_CHECK (1u << 1)
  322. #define CPD_GROUP_OK (1u << 2)
  323. #define CPD_GROUP_READ (1u << 3)
  324. #define CPD_CHECK_MODE_ONLY (1u << 4)
  325. #define CPD_RELAX_DIRMODE_CHECK (1u << 5)
  326. MOCK_DECL(int, check_private_dir,
  327. (const char *dirname, cpd_check_t check,
  328. const char *effective_user));
  329. #define OPEN_FLAGS_REPLACE (O_WRONLY|O_CREAT|O_TRUNC)
  330. #define OPEN_FLAGS_APPEND (O_WRONLY|O_CREAT|O_APPEND)
  331. #define OPEN_FLAGS_DONT_REPLACE (O_CREAT|O_EXCL|O_APPEND|O_WRONLY)
  332. typedef struct open_file_t open_file_t;
  333. int start_writing_to_file(const char *fname, int open_flags, int mode,
  334. open_file_t **data_out);
  335. FILE *start_writing_to_stdio_file(const char *fname, int open_flags, int mode,
  336. open_file_t **data_out);
  337. FILE *fdopen_file(open_file_t *file_data);
  338. int finish_writing_to_file(open_file_t *file_data);
  339. int abort_writing_to_file(open_file_t *file_data);
  340. MOCK_DECL(int,
  341. write_str_to_file,(const char *fname, const char *str, int bin));
  342. MOCK_DECL(int,
  343. write_bytes_to_file,(const char *fname, const char *str, size_t len,
  344. int bin));
  345. /** An ad-hoc type to hold a string of characters and a count; used by
  346. * write_chunks_to_file. */
  347. typedef struct sized_chunk_t {
  348. const char *bytes;
  349. size_t len;
  350. } sized_chunk_t;
  351. int write_chunks_to_file(const char *fname, const struct smartlist_t *chunks,
  352. int bin, int no_tempfile);
  353. int append_bytes_to_file(const char *fname, const char *str, size_t len,
  354. int bin);
  355. int write_bytes_to_new_file(const char *fname, const char *str, size_t len,
  356. int bin);
  357. /** Flag for read_file_to_str: open the file in binary mode. */
  358. #define RFTS_BIN 1
  359. /** Flag for read_file_to_str: it's okay if the file doesn't exist. */
  360. #define RFTS_IGNORE_MISSING 2
  361. #ifndef _WIN32
  362. struct stat;
  363. #endif
  364. MOCK_DECL_ATTR(char *, read_file_to_str,
  365. (const char *filename, int flags, struct stat *stat_out),
  366. ATTR_MALLOC);
  367. char *read_file_to_str_until_eof(int fd, size_t max_bytes_to_read,
  368. size_t *sz_out)
  369. ATTR_MALLOC;
  370. const char *unescape_string(const char *s, char **result, size_t *size_out);
  371. char *get_unquoted_path(const char *path);
  372. char *expand_filename(const char *filename);
  373. MOCK_DECL(struct smartlist_t *, tor_listdir, (const char *dirname));
  374. int path_is_relative(const char *filename);
  375. /* Process helpers */
  376. void start_daemon(void);
  377. void finish_daemon(const char *desired_cwd);
  378. int write_pidfile(const char *filename);
  379. /* Port forwarding */
  380. void tor_check_port_forwarding(const char *filename,
  381. struct smartlist_t *ports_to_forward,
  382. time_t now);
  383. void tor_disable_spawning_background_processes(void);
  384. typedef struct process_handle_t process_handle_t;
  385. typedef struct process_environment_t process_environment_t;
  386. int tor_spawn_background(const char *const filename, const char **argv,
  387. process_environment_t *env,
  388. process_handle_t **process_handle_out);
  389. #define SPAWN_ERROR_MESSAGE "ERR: Failed to spawn background process - code "
  390. #ifdef _WIN32
  391. HANDLE load_windows_system_library(const TCHAR *library_name);
  392. #endif
  393. int environment_variable_names_equal(const char *s1, const char *s2);
  394. /* DOCDOC process_environment_t */
  395. struct process_environment_t {
  396. /** A pointer to a sorted empty-string-terminated sequence of
  397. * NUL-terminated strings of the form "NAME=VALUE". */
  398. char *windows_environment_block;
  399. /** A pointer to a NULL-terminated array of pointers to
  400. * NUL-terminated strings of the form "NAME=VALUE". */
  401. char **unixoid_environment_block;
  402. };
  403. process_environment_t *process_environment_make(struct smartlist_t *env_vars);
  404. void process_environment_free_(process_environment_t *env);
  405. #define process_environment_free(env) \
  406. FREE_AND_NULL(process_environment_t, process_environment_free_, (env))
  407. struct smartlist_t *get_current_process_environment_variables(void);
  408. void set_environment_variable_in_smartlist(struct smartlist_t *env_vars,
  409. const char *new_var,
  410. void (*free_old)(void*),
  411. int free_p);
  412. /* Values of process_handle_t.status. PROCESS_STATUS_NOTRUNNING must be
  413. * 0 because tor_check_port_forwarding depends on this being the initial
  414. * statue of the static instance of process_handle_t */
  415. #define PROCESS_STATUS_NOTRUNNING 0
  416. #define PROCESS_STATUS_RUNNING 1
  417. #define PROCESS_STATUS_ERROR -1
  418. #ifdef UTIL_PRIVATE
  419. struct waitpid_callback_t;
  420. /** Structure to represent the state of a process with which Tor is
  421. * communicating. The contents of this structure are private to util.c */
  422. struct process_handle_t {
  423. /** One of the PROCESS_STATUS_* values */
  424. int status;
  425. #ifdef _WIN32
  426. HANDLE stdin_pipe;
  427. HANDLE stdout_pipe;
  428. HANDLE stderr_pipe;
  429. PROCESS_INFORMATION pid;
  430. #else /* !(defined(_WIN32)) */
  431. int stdin_pipe;
  432. int stdout_pipe;
  433. int stderr_pipe;
  434. pid_t pid;
  435. /** If the process has not given us a SIGCHLD yet, this has the
  436. * waitpid_callback_t that gets invoked once it has. Otherwise this
  437. * contains NULL. */
  438. struct waitpid_callback_t *waitpid_cb;
  439. /** The exit status reported by waitpid. */
  440. int waitpid_exit_status;
  441. #endif /* defined(_WIN32) */
  442. };
  443. #endif /* defined(UTIL_PRIVATE) */
  444. /* Return values of tor_get_exit_code() */
  445. #define PROCESS_EXIT_RUNNING 1
  446. #define PROCESS_EXIT_EXITED 0
  447. #define PROCESS_EXIT_ERROR -1
  448. int tor_get_exit_code(process_handle_t *process_handle,
  449. int block, int *exit_code);
  450. int tor_split_lines(struct smartlist_t *sl, char *buf, int len);
  451. #ifdef _WIN32
  452. ssize_t tor_read_all_handle(HANDLE h, char *buf, size_t count,
  453. const process_handle_t *process);
  454. #else
  455. ssize_t tor_read_all_handle(int fd, char *buf, size_t count,
  456. const process_handle_t *process,
  457. int *eof);
  458. #endif /* defined(_WIN32) */
  459. ssize_t tor_read_all_from_process_stdout(
  460. const process_handle_t *process_handle, char *buf, size_t count);
  461. ssize_t tor_read_all_from_process_stderr(
  462. const process_handle_t *process_handle, char *buf, size_t count);
  463. char *tor_join_win_cmdline(const char *argv[]);
  464. int tor_process_get_pid(process_handle_t *process_handle);
  465. #ifdef _WIN32
  466. HANDLE tor_process_get_stdout_pipe(process_handle_t *process_handle);
  467. #else
  468. int tor_process_get_stdout_pipe(process_handle_t *process_handle);
  469. #endif
  470. #ifdef _WIN32
  471. MOCK_DECL(struct smartlist_t *,
  472. tor_get_lines_from_handle,(HANDLE *handle,
  473. enum stream_status *stream_status));
  474. #else
  475. MOCK_DECL(struct smartlist_t *,
  476. tor_get_lines_from_handle,(int fd,
  477. enum stream_status *stream_status));
  478. #endif /* defined(_WIN32) */
  479. int
  480. tor_terminate_process(process_handle_t *process_handle);
  481. MOCK_DECL(void,
  482. tor_process_handle_destroy,(process_handle_t *process_handle,
  483. int also_terminate_process));
  484. /* ===== Insecure rng */
  485. typedef struct tor_weak_rng_t {
  486. uint32_t state;
  487. } tor_weak_rng_t;
  488. #define TOR_WEAK_RNG_INIT {383745623}
  489. #define TOR_WEAK_RANDOM_MAX (INT_MAX)
  490. void tor_init_weak_random(tor_weak_rng_t *weak_rng, unsigned seed);
  491. int32_t tor_weak_random(tor_weak_rng_t *weak_rng);
  492. int32_t tor_weak_random_range(tor_weak_rng_t *rng, int32_t top);
  493. /** Randomly return true according to <b>rng</b> with probability 1 in
  494. * <b>n</b> */
  495. #define tor_weak_random_one_in_n(rng, n) (0==tor_weak_random_range((rng),(n)))
  496. int format_hex_number_sigsafe(unsigned long x, char *buf, int max_len);
  497. int format_dec_number_sigsafe(unsigned long x, char *buf, int max_len);
  498. #ifdef UTIL_PRIVATE
  499. /* Prototypes for private functions only used by util.c (and unit tests) */
  500. #ifndef _WIN32
  501. STATIC int format_helper_exit_status(unsigned char child_state,
  502. int saved_errno, char *hex_errno);
  503. /* Space for hex values of child state, a slash, saved_errno (with
  504. leading minus) and newline (no null) */
  505. #define HEX_ERRNO_SIZE (sizeof(char) * 2 + 1 + \
  506. 1 + sizeof(int) * 2 + 1)
  507. #endif /* !defined(_WIN32) */
  508. #endif /* defined(UTIL_PRIVATE) */
  509. int size_mul_check(const size_t x, const size_t y);
  510. #define ARRAY_LENGTH(x) ((sizeof(x)) / sizeof(x[0]))
  511. #endif /* !defined(TOR_UTIL_H) */