util.h 21 KB

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