util.h 21 KB

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