1 /* Copyright (c) 2003, Roger Dingledine
2 * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
3 * Copyright (c) 2007-2011, The Tor Project, Inc. */
4 /* See LICENSE for licensing information */
8 * \brief Common functions for strings, IO, network, data structures,
12 /* This is required on rh7 to make strptime not complain.
21 #include "container.h"
38 #ifdef HAVE_NETINET_IN_H
39 #include <netinet/in.h>
41 #ifdef HAVE_ARPA_INET_H
42 #include <arpa/inet.h>
47 #ifdef HAVE_SYS_SOCKET_H
48 #include <sys/socket.h>
50 #ifdef HAVE_SYS_TIME_H
56 #ifdef HAVE_SYS_STAT_H
59 #ifdef HAVE_SYS_FCNTL_H
60 #include <sys/fcntl.h>
68 #ifdef HAVE_MALLOC_MALLOC_H
69 #include <malloc/malloc.h>
73 /* OpenBSD has a malloc.h, but for our purposes, it only exists in order to
74 * scold us for being so stupid as to autodetect its presence. To be fair,
75 * they've done this since 1996, when autoconf was only 5 years old. */
79 #ifdef HAVE_MALLOC_NP_H
80 #include <malloc_np.h>
89 /* Macro to pass the extra dmalloc args to another function. */
90 #define DMALLOC_FN_ARGS , file, line
92 #if defined(HAVE_DMALLOC_STRDUP)
93 /* the dmalloc_strdup should be fine as defined */
94 #elif defined(HAVE_DMALLOC_STRNDUP)
95 #define dmalloc_strdup(file, line, string, xalloc_b) \
96 dmalloc_strndup(file, line, (string), -1, xalloc_b)
98 #error "No dmalloc_strdup or equivalent"
101 #else /* not using dmalloc */
103 #define DMALLOC_FN_ARGS
106 /** Allocate a chunk of <b>size</b> bytes of memory, and return a pointer to
107 * result. On error, log and terminate the process. (Same as malloc(size),
108 * but never returns NULL.)
110 * <b>file</b> and <b>line</b> are used if dmalloc is enabled, and
114 _tor_malloc(size_t size DMALLOC_PARAMS
)
118 tor_assert(size
< SIZE_T_CEILING
);
120 #ifndef MALLOC_ZERO_WORKS
121 /* Some libc mallocs don't work when size==0. Override them. */
128 result
= dmalloc_malloc(file
, line
, size
, DMALLOC_FUNC_MALLOC
, 0, 0);
130 result
= malloc(size
);
133 if (PREDICT_UNLIKELY(result
== NULL
)) {
134 log_err(LD_MM
,"Out of memory on malloc(). Dying.");
135 /* If these functions die within a worker process, they won't call
136 * spawn_exit, but that's ok, since the parent will run out of memory soon
143 /** Allocate a chunk of <b>size</b> bytes of memory, fill the memory with
144 * zero bytes, and return a pointer to the result. Log and terminate
145 * the process on error. (Same as calloc(size,1), but never returns NULL.)
148 _tor_malloc_zero(size_t size DMALLOC_PARAMS
)
150 /* You may ask yourself, "wouldn't it be smart to use calloc instead of
151 * malloc+memset? Perhaps libc's calloc knows some nifty optimization trick
152 * we don't!" Indeed it does, but its optimizations are only a big win when
153 * we're allocating something very big (it knows if it just got the memory
154 * from the OS in a pre-zeroed state). We don't want to use tor_malloc_zero
155 * for big stuff, so we don't bother with calloc. */
156 void *result
= _tor_malloc(size DMALLOC_FN_ARGS
);
157 memset(result
, 0, size
);
161 /** Change the size of the memory block pointed to by <b>ptr</b> to <b>size</b>
162 * bytes long; return the new memory block. On error, log and
163 * terminate. (Like realloc(ptr,size), but never returns NULL.)
166 _tor_realloc(void *ptr
, size_t size DMALLOC_PARAMS
)
170 tor_assert(size
< SIZE_T_CEILING
);
173 result
= dmalloc_realloc(file
, line
, ptr
, size
, DMALLOC_FUNC_REALLOC
, 0);
175 result
= realloc(ptr
, size
);
178 if (PREDICT_UNLIKELY(result
== NULL
)) {
179 log_err(LD_MM
,"Out of memory on realloc(). Dying.");
185 /** Return a newly allocated copy of the NUL-terminated string s. On
186 * error, log and terminate. (Like strdup(s), but never returns
190 _tor_strdup(const char *s DMALLOC_PARAMS
)
196 dup
= dmalloc_strdup(file
, line
, s
, 0);
200 if (PREDICT_UNLIKELY(dup
== NULL
)) {
201 log_err(LD_MM
,"Out of memory on strdup(). Dying.");
207 /** Allocate and return a new string containing the first <b>n</b>
208 * characters of <b>s</b>. If <b>s</b> is longer than <b>n</b>
209 * characters, only the first <b>n</b> are copied. The result is
210 * always NUL-terminated. (Like strndup(s,n), but never returns
214 _tor_strndup(const char *s
, size_t n DMALLOC_PARAMS
)
218 tor_assert(n
< SIZE_T_CEILING
);
219 dup
= _tor_malloc((n
+1) DMALLOC_FN_ARGS
);
220 /* Performance note: Ordinarily we prefer strlcpy to strncpy. But
221 * this function gets called a whole lot, and platform strncpy is
222 * much faster than strlcpy when strlen(s) is much longer than n.
229 /** Allocate a chunk of <b>len</b> bytes, with the same contents as the
230 * <b>len</b> bytes starting at <b>mem</b>. */
232 _tor_memdup(const void *mem
, size_t len DMALLOC_PARAMS
)
235 tor_assert(len
< SIZE_T_CEILING
);
237 dup
= _tor_malloc(len DMALLOC_FN_ARGS
);
238 memcpy(dup
, mem
, len
);
242 /** Helper for places that need to take a function pointer to the right
243 * spelling of "free()". */
250 #if defined(HAVE_MALLOC_GOOD_SIZE) && !defined(HAVE_MALLOC_GOOD_SIZE_PROTOTYPE)
251 /* Some version of Mac OSX have malloc_good_size in their libc, but not
252 * actually defined in malloc/malloc.h. We detect this and work around it by
255 extern size_t malloc_good_size(size_t size
);
258 /** Allocate and return a chunk of memory of size at least *<b>size</b>, using
259 * the same resources we would use to malloc *<b>sizep</b>. Set *<b>sizep</b>
260 * to the number of usable bytes in the chunk of memory. */
262 _tor_malloc_roundup(size_t *sizep DMALLOC_PARAMS
)
264 #ifdef HAVE_MALLOC_GOOD_SIZE
265 tor_assert(*sizep
< SIZE_T_CEILING
);
266 *sizep
= malloc_good_size(*sizep
);
267 return _tor_malloc(*sizep DMALLOC_FN_ARGS
);
268 #elif 0 && defined(HAVE_MALLOC_USABLE_SIZE) && !defined(USE_DMALLOC)
269 /* Never use malloc_usable_size(); it makes valgrind really unhappy,
270 * and doesn't win much in terms of usable space where it exists. */
272 tor_assert(*sizep
< SIZE_T_CEILING
);
273 result
= _tor_malloc(*sizep DMALLOC_FN_ARGS
);
274 *sizep
= malloc_usable_size(result
);
277 return _tor_malloc(*sizep DMALLOC_FN_ARGS
);
281 /** Call the platform malloc info function, and dump the results to the log at
282 * level <b>severity</b>. If no such function exists, do nothing. */
284 tor_log_mallinfo(int severity
)
288 memset(&mi
, 0, sizeof(mi
));
291 "mallinfo() said: arena=%d, ordblks=%d, smblks=%d, hblks=%d, "
292 "hblkhd=%d, usmblks=%d, fsmblks=%d, uordblks=%d, fordblks=%d, "
294 mi
.arena
, mi
.ordblks
, mi
.smblks
, mi
.hblks
,
295 mi
.hblkhd
, mi
.usmblks
, mi
.fsmblks
, mi
.uordblks
, mi
.fordblks
,
301 dmalloc_log_changed(0, /* Since the program started. */
302 1, /* Log info about non-freed pointers. */
303 0, /* Do not log info about freed pointers. */
304 0 /* Do not log individual pointers. */
313 /** Returns floor(log2(u64)). If u64 is 0, (incorrectly) returns 0. */
315 tor_log2(uint64_t u64
)
318 if (u64
>= (U64_LITERAL(1)<<32)) {
322 if (u64
>= (U64_LITERAL(1)<<16)) {
326 if (u64
>= (U64_LITERAL(1)<<8)) {
330 if (u64
>= (U64_LITERAL(1)<<4)) {
334 if (u64
>= (U64_LITERAL(1)<<2)) {
338 if (u64
>= (U64_LITERAL(1)<<1)) {
345 /** Return the power of 2 closest to <b>u64</b>. */
347 round_to_power_of_2(uint64_t u64
)
349 int lg2
= tor_log2(u64
);
350 uint64_t low
= U64_LITERAL(1) << lg2
, high
= U64_LITERAL(1) << (lg2
+1);
351 if (high
- u64
< u64
- low
)
358 * String manipulation
361 /** Remove from the string <b>s</b> every character which appears in
364 tor_strstrip(char *s
, const char *strip
)
368 if (strchr(strip
, *read
)) {
377 /** Return a pointer to a NUL-terminated hexadecimal string encoding
378 * the first <b>fromlen</b> bytes of <b>from</b>. (fromlen must be \<= 32.) The
379 * result does not need to be deallocated, but repeated calls to
380 * hex_str will trash old results.
383 hex_str(const char *from
, size_t fromlen
)
386 if (fromlen
>(sizeof(buf
)-1)/2)
387 fromlen
= (sizeof(buf
)-1)/2;
388 base16_encode(buf
,sizeof(buf
),from
,fromlen
);
392 /** Convert all alphabetic characters in the nul-terminated string <b>s</b> to
395 tor_strlower(char *s
)
398 *s
= TOR_TOLOWER(*s
);
403 /** Convert all alphabetic characters in the nul-terminated string <b>s</b> to
406 tor_strupper(char *s
)
409 *s
= TOR_TOUPPER(*s
);
414 /** Return 1 if every character in <b>s</b> is printable, else return 0.
417 tor_strisprint(const char *s
)
420 if (!TOR_ISPRINT(*s
))
427 /** Return 1 if no character in <b>s</b> is uppercase, else return 0.
430 tor_strisnonupper(const char *s
)
440 /** Compares the first strlen(s2) characters of s1 with s2. Returns as for
444 strcmpstart(const char *s1
, const char *s2
)
446 size_t n
= strlen(s2
);
447 return strncmp(s1
, s2
, n
);
450 /** Compare the s1_len-byte string <b>s1</b> with <b>s2</b>,
451 * without depending on a terminating nul in s1. Sorting order is first by
452 * length, then lexically; return values are as for strcmp.
455 strcmp_len(const char *s1
, const char *s2
, size_t s1_len
)
457 size_t s2_len
= strlen(s2
);
462 return memcmp(s1
, s2
, s2_len
);
465 /** Compares the first strlen(s2) characters of s1 with s2. Returns as for
469 strcasecmpstart(const char *s1
, const char *s2
)
471 size_t n
= strlen(s2
);
472 return strncasecmp(s1
, s2
, n
);
475 /** Compares the last strlen(s2) characters of s1 with s2. Returns as for
479 strcmpend(const char *s1
, const char *s2
)
481 size_t n1
= strlen(s1
), n2
= strlen(s2
);
483 return strcmp(s1
,s2
);
485 return strncmp(s1
+(n1
-n2
), s2
, n2
);
488 /** Compares the last strlen(s2) characters of s1 with s2. Returns as for
492 strcasecmpend(const char *s1
, const char *s2
)
494 size_t n1
= strlen(s1
), n2
= strlen(s2
);
495 if (n2
>n1
) /* then they can't be the same; figure out which is bigger */
496 return strcasecmp(s1
,s2
);
498 return strncasecmp(s1
+(n1
-n2
), s2
, n2
);
501 /** Compare the value of the string <b>prefix</b> with the start of the
502 * <b>memlen</b>-byte memory chunk at <b>mem</b>. Return as for strcmp.
504 * [As memcmp(mem, prefix, strlen(prefix)) but returns -1 if memlen is less
505 * than strlen(prefix).]
508 memcmpstart(const void *mem
, size_t memlen
,
511 size_t plen
= strlen(prefix
);
514 return memcmp(mem
, prefix
, plen
);
517 /** Return a pointer to the first char of s that is not whitespace and
518 * not a comment, or to the terminating NUL if no such character exists.
521 eat_whitespace(const char *s
)
538 while (*s
&& *s
!= '\n')
544 /** Return a pointer to the first char of s that is not whitespace and
545 * not a comment, or to the terminating NUL if no such character exists.
548 eat_whitespace_eos(const char *s
, const char *eos
)
551 tor_assert(eos
&& s
<= eos
);
566 while (s
< eos
&& *s
&& *s
!= '\n')
573 /** Return a pointer to the first char of s that is not a space or a tab
574 * or a \\r, or to the terminating NUL if no such character exists. */
576 eat_whitespace_no_nl(const char *s
)
578 while (*s
== ' ' || *s
== '\t' || *s
== '\r')
583 /** As eat_whitespace_no_nl, but stop at <b>eos</b> whether we have
584 * found a non-whitespace character or not. */
586 eat_whitespace_eos_no_nl(const char *s
, const char *eos
)
588 while (s
< eos
&& (*s
== ' ' || *s
== '\t' || *s
== '\r'))
593 /** Return a pointer to the first char of s that is whitespace or <b>#</b>,
594 * or to the terminating NUL if no such character exists.
597 find_whitespace(const char *s
)
616 /** As find_whitespace, but stop at <b>eos</b> whether we have found a
617 * whitespace or not. */
619 find_whitespace_eos(const char *s
, const char *eos
)
639 /** Return true iff the 'len' bytes at 'mem' are all zero. */
641 tor_mem_is_zero(const char *mem
, size_t len
)
643 static const char ZERO
[] = {
644 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
646 while (len
>= sizeof(ZERO
)) {
647 if (memcmp(mem
, ZERO
, sizeof(ZERO
)))
652 /* Deal with leftover bytes. */
654 return ! memcmp(mem
, ZERO
, len
);
659 /** Return true iff the DIGEST_LEN bytes in digest are all zero. */
661 tor_digest_is_zero(const char *digest
)
663 return tor_mem_is_zero(digest
, DIGEST_LEN
);
666 /* Helper: common code to check whether the result of a strtol or strtoul or
667 * strtoll is correct. */
668 #define CHECK_STRTOX_RESULT() \
669 /* Was at least one character converted? */ \
672 /* Were there unexpected unconverted characters? */ \
673 if (!next && *endptr) \
675 /* Is r within limits? */ \
676 if (r < min || r > max) \
679 if (next) *next = endptr; \
683 if (next) *next = endptr; \
686 /** Extract a long from the start of s, in the given numeric base. If
687 * there is unconverted data and next is provided, set *next to the
688 * first unconverted character. An error has occurred if no characters
689 * are converted; or if there are unconverted characters and next is NULL; or
690 * if the parsed value is not between min and max. When no error occurs,
691 * return the parsed value and set *ok (if provided) to 1. When an error
692 * occurs, return 0 and set *ok (if provided) to 0.
695 tor_parse_long(const char *s
, int base
, long min
, long max
,
696 int *ok
, char **next
)
701 r
= strtol(s
, &endptr
, base
);
702 CHECK_STRTOX_RESULT();
705 /** As tor_parse_long(), but return an unsigned long. */
707 tor_parse_ulong(const char *s
, int base
, unsigned long min
,
708 unsigned long max
, int *ok
, char **next
)
713 r
= strtoul(s
, &endptr
, base
);
714 CHECK_STRTOX_RESULT();
717 /** As tor_parse_log, but return a unit64_t. Only base 10 is guaranteed to
720 tor_parse_uint64(const char *s
, int base
, uint64_t min
,
721 uint64_t max
, int *ok
, char **next
)
727 r
= (uint64_t)strtoull(s
, &endptr
, base
);
728 #elif defined(MS_WINDOWS)
729 #if defined(_MSC_VER) && _MSC_VER < 1300
730 tor_assert(base
<= 10);
731 r
= (uint64_t)_atoi64(s
);
733 while (TOR_ISSPACE(*endptr
)) endptr
++;
734 while (TOR_ISDIGIT(*endptr
)) endptr
++;
736 r
= (uint64_t)_strtoui64(s
, &endptr
, base
);
738 #elif SIZEOF_LONG == 8
739 r
= (uint64_t)strtoul(s
, &endptr
, base
);
741 #error "I don't know how to parse 64-bit numbers."
744 CHECK_STRTOX_RESULT();
747 /** Encode the <b>srclen</b> bytes at <b>src</b> in a NUL-terminated,
748 * uppercase hexadecimal string; store it in the <b>destlen</b>-byte buffer
752 base16_encode(char *dest
, size_t destlen
, const char *src
, size_t srclen
)
757 tor_assert(destlen
>= srclen
*2+1);
758 tor_assert(destlen
< SIZE_T_CEILING
);
763 *cp
++ = "0123456789ABCDEF"[ (*(const uint8_t*)src
) >> 4 ];
764 *cp
++ = "0123456789ABCDEF"[ (*(const uint8_t*)src
) & 0xf ];
770 /** Helper: given a hex digit, return its value, or -1 if it isn't hex. */
772 _hex_decode_digit(char c
)
785 case 'A': case 'a': return 10;
786 case 'B': case 'b': return 11;
787 case 'C': case 'c': return 12;
788 case 'D': case 'd': return 13;
789 case 'E': case 'e': return 14;
790 case 'F': case 'f': return 15;
796 /** Helper: given a hex digit, return its value, or -1 if it isn't hex. */
798 hex_decode_digit(char c
)
800 return _hex_decode_digit(c
);
803 /** Given a hexadecimal string of <b>srclen</b> bytes in <b>src</b>, decode it
804 * and store the result in the <b>destlen</b>-byte buffer at <b>dest</b>.
805 * Return 0 on success, -1 on failure. */
807 base16_decode(char *dest
, size_t destlen
, const char *src
, size_t srclen
)
812 if ((srclen
% 2) != 0)
814 if (destlen
< srclen
/2 || destlen
> SIZE_T_CEILING
)
818 v1
= _hex_decode_digit(*src
);
819 v2
= _hex_decode_digit(*(src
+1));
822 *(uint8_t*)dest
= (v1
<<4)|v2
;
829 /** Allocate and return a new string representing the contents of <b>s</b>,
830 * surrounded by quotes and using standard C escapes.
832 * Generally, we use this for logging values that come in over the network to
833 * keep them from tricking users, and for sending certain values to the
836 * We trust values from the resolver, OS, configuration file, and command line
837 * to not be maliciously ill-formed. We validate incoming routerdescs and
838 * SOCKS requests and addresses from BEGIN cells as they're parsed;
839 * afterwards, we trust them as non-malicious.
842 esc_for_log(const char *s
)
848 return tor_strdup("");
851 for (cp
= s
; *cp
; ++cp
) {
859 if (TOR_ISPRINT(*cp
) && ((uint8_t)*cp
)<127)
867 result
= outp
= tor_malloc(len
);
869 for (cp
= s
; *cp
; ++cp
) {
890 if (TOR_ISPRINT(*cp
) && ((uint8_t)*cp
)<127) {
893 tor_snprintf(outp
, 5, "\\%03o", (int)(uint8_t) *cp
);
906 /** Allocate and return a new string representing the contents of <b>s</b>,
907 * surrounded by quotes and using standard C escapes.
909 * THIS FUNCTION IS NOT REENTRANT. Don't call it from outside the main
910 * thread. Also, each call invalidates the last-returned value, so don't
911 * try log_warn(LD_GENERAL, "%s %s", escaped(a), escaped(b));
914 escaped(const char *s
)
916 static char *_escaped_val
= NULL
;
918 tor_free(_escaped_val
);
921 _escaped_val
= esc_for_log(s
);
928 /** Rudimentary string wrapping code: given a un-wrapped <b>string</b> (no
929 * newlines!), break the string into newline-terminated lines of no more than
930 * <b>width</b> characters long (not counting newline) and insert them into
931 * <b>out</b> in order. Precede the first line with prefix0, and subsequent
932 * lines with prefixRest.
934 /* This uses a stupid greedy wrapping algorithm right now:
936 * - Try to fit as much stuff as possible, but break on a space.
937 * - If the first "word" of the line will extend beyond the allowable
938 * width, break the word at the end of the width.
941 wrap_string(smartlist_t
*out
, const char *string
, size_t width
,
942 const char *prefix0
, const char *prefixRest
)
944 size_t p0Len
, pRestLen
, pCurLen
;
945 const char *eos
, *prefixCur
;
954 p0Len
= strlen(prefix0
);
955 pRestLen
= strlen(prefixRest
);
956 tor_assert(width
> p0Len
&& width
> pRestLen
);
957 eos
= strchr(string
, '\0');
962 while ((eos
-string
)+pCurLen
> width
) {
963 const char *eol
= string
+ width
- pCurLen
;
964 while (eol
> string
&& *eol
!= ' ')
966 /* eol is now the last space that can fit, or the start of the string. */
968 size_t line_len
= (eol
-string
) + pCurLen
+ 2;
969 char *line
= tor_malloc(line_len
);
970 memcpy(line
, prefixCur
, pCurLen
);
971 memcpy(line
+pCurLen
, string
, eol
-string
);
972 line
[line_len
-2] = '\n';
973 line
[line_len
-1] = '\0';
974 smartlist_add(out
, line
);
977 size_t line_len
= width
+ 2;
978 char *line
= tor_malloc(line_len
);
979 memcpy(line
, prefixCur
, pCurLen
);
980 memcpy(line
+pCurLen
, string
, width
- pCurLen
);
981 line
[line_len
-2] = '\n';
982 line
[line_len
-1] = '\0';
983 smartlist_add(out
, line
);
984 string
+= width
-pCurLen
;
986 prefixCur
= prefixRest
;
991 size_t line_len
= (eos
-string
) + pCurLen
+ 2;
992 char *line
= tor_malloc(line_len
);
993 memcpy(line
, prefixCur
, pCurLen
);
994 memcpy(line
+pCurLen
, string
, eos
-string
);
995 line
[line_len
-2] = '\n';
996 line
[line_len
-1] = '\0';
997 smartlist_add(out
, line
);
1005 /** Return the number of microseconds elapsed between *start and *end.
1008 tv_udiff(const struct timeval
*start
, const struct timeval
*end
)
1011 long secdiff
= end
->tv_sec
- start
->tv_sec
;
1013 if (labs(secdiff
+1) > LONG_MAX
/1000000) {
1014 log_warn(LD_GENERAL
, "comparing times too far apart.");
1018 udiff
= secdiff
*1000000L + (end
->tv_usec
- start
->tv_usec
);
1022 /** Yield true iff <b>y</b> is a leap-year. */
1023 #define IS_LEAPYEAR(y) (!(y % 4) && ((y % 100) || !(y % 400)))
1024 /** Helper: Return the number of leap-days between Jan 1, y1 and Jan 1, y2. */
1026 n_leapdays(int y1
, int y2
)
1030 return (y2
/4 - y1
/4) - (y2
/100 - y1
/100) + (y2
/400 - y1
/400);
1032 /** Number of days per month in non-leap year; used by tor_timegm. */
1033 static const int days_per_month
[] =
1034 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
1036 /** Return a time_t given a struct tm. The result is given in GMT, and
1037 * does not account for leap seconds.
1040 tor_timegm(struct tm
*tm
)
1042 /* This is a pretty ironclad timegm implementation, snarfed from Python2.2.
1043 * It's way more brute-force than fiddling with tzset().
1045 time_t year
, days
, hours
, minutes
, seconds
;
1047 year
= tm
->tm_year
+ 1900;
1048 if (year
< 1970 || tm
->tm_mon
< 0 || tm
->tm_mon
> 11) {
1049 log_warn(LD_BUG
, "Out-of-range argument to tor_timegm");
1052 tor_assert(year
< INT_MAX
);
1053 days
= 365 * (year
-1970) + n_leapdays(1970,(int)year
);
1054 for (i
= 0; i
< tm
->tm_mon
; ++i
)
1055 days
+= days_per_month
[i
];
1056 if (tm
->tm_mon
> 1 && IS_LEAPYEAR(year
))
1058 days
+= tm
->tm_mday
- 1;
1059 hours
= days
*24 + tm
->tm_hour
;
1061 minutes
= hours
*60 + tm
->tm_min
;
1062 seconds
= minutes
*60 + tm
->tm_sec
;
1066 /* strftime is locale-specific, so we need to replace those parts */
1068 /** A c-locale array of 3-letter names of weekdays, starting with Sun. */
1069 static const char *WEEKDAY_NAMES
[] =
1070 { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
1071 /** A c-locale array of 3-letter names of months, starting with Jan. */
1072 static const char *MONTH_NAMES
[] =
1073 { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
1074 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
1076 /** Set <b>buf</b> to the RFC1123 encoding of the GMT value of <b>t</b>.
1077 * The buffer must be at least RFC1123_TIME_LEN+1 bytes long.
1079 * (RFC1123 format is Fri, 29 Sep 2006 15:54:20 GMT)
1082 format_rfc1123_time(char *buf
, time_t t
)
1086 tor_gmtime_r(&t
, &tm
);
1088 strftime(buf
, RFC1123_TIME_LEN
+1, "___, %d ___ %Y %H:%M:%S GMT", &tm
);
1089 tor_assert(tm
.tm_wday
>= 0);
1090 tor_assert(tm
.tm_wday
<= 6);
1091 memcpy(buf
, WEEKDAY_NAMES
[tm
.tm_wday
], 3);
1092 tor_assert(tm
.tm_wday
>= 0);
1093 tor_assert(tm
.tm_mon
<= 11);
1094 memcpy(buf
+8, MONTH_NAMES
[tm
.tm_mon
], 3);
1097 /** Parse the the RFC1123 encoding of some time (in GMT) from <b>buf</b>,
1098 * and store the result in *<b>t</b>.
1100 * Return 0 on success, -1 on failure.
1103 parse_rfc1123_time(const char *buf
, time_t *t
)
1109 unsigned tm_mday
, tm_year
, tm_hour
, tm_min
, tm_sec
;
1111 if (strlen(buf
) != RFC1123_TIME_LEN
)
1113 memset(&tm
, 0, sizeof(tm
));
1114 if (tor_sscanf(buf
, "%3s, %2u %3s %u %2u:%2u:%2u GMT", weekday
,
1115 &tm_mday
, month
, &tm_year
, &tm_hour
,
1116 &tm_min
, &tm_sec
) < 7) {
1117 char *esc
= esc_for_log(buf
);
1118 log_warn(LD_GENERAL
, "Got invalid RFC1123 time %s", esc
);
1122 if (tm_mday
> 31 || tm_hour
> 23 || tm_min
> 59 || tm_sec
> 61) {
1123 char *esc
= esc_for_log(buf
);
1124 log_warn(LD_GENERAL
, "Got invalid RFC1123 time %s", esc
);
1128 tm
.tm_mday
= (int)tm_mday
;
1129 tm
.tm_year
= (int)tm_year
;
1130 tm
.tm_hour
= (int)tm_hour
;
1131 tm
.tm_min
= (int)tm_min
;
1132 tm
.tm_sec
= (int)tm_sec
;
1135 for (i
= 0; i
< 12; ++i
) {
1136 if (!strcmp(month
, MONTH_NAMES
[i
])) {
1142 char *esc
= esc_for_log(buf
);
1143 log_warn(LD_GENERAL
, "Got invalid RFC1123 time %s: No such month", esc
);
1149 if (tm
.tm_year
< 1970) {
1150 char *esc
= esc_for_log(buf
);
1151 log_warn(LD_GENERAL
,
1152 "Got invalid RFC1123 time %s. (Before 1970)", esc
);
1158 *t
= tor_timegm(&tm
);
1162 /** Set <b>buf</b> to the ISO8601 encoding of the local value of <b>t</b>.
1163 * The buffer must be at least ISO_TIME_LEN+1 bytes long.
1165 * (ISO8601 format is 2006-10-29 10:57:20)
1168 format_local_iso_time(char *buf
, time_t t
)
1171 strftime(buf
, ISO_TIME_LEN
+1, "%Y-%m-%d %H:%M:%S", tor_localtime_r(&t
, &tm
));
1174 /** Set <b>buf</b> to the ISO8601 encoding of the GMT value of <b>t</b>.
1175 * The buffer must be at least ISO_TIME_LEN+1 bytes long.
1178 format_iso_time(char *buf
, time_t t
)
1181 strftime(buf
, ISO_TIME_LEN
+1, "%Y-%m-%d %H:%M:%S", tor_gmtime_r(&t
, &tm
));
1184 /** Given an ISO-formatted UTC time value (after the epoch) in <b>cp</b>,
1185 * parse it and store its value in *<b>t</b>. Return 0 on success, -1 on
1186 * failure. Ignore extraneous stuff in <b>cp</b> separated by whitespace from
1187 * the end of the time string. */
1189 parse_iso_time(const char *cp
, time_t *t
)
1192 unsigned int year
=0, month
=0, day
=0, hour
=100, minute
=100, second
=100;
1193 if (tor_sscanf(cp
, "%u-%2u-%2u %2u:%2u:%2u", &year
, &month
,
1194 &day
, &hour
, &minute
, &second
) < 6) {
1195 char *esc
= esc_for_log(cp
);
1196 log_warn(LD_GENERAL
, "ISO time %s was unparseable", esc
);
1200 if (year
< 1970 || month
< 1 || month
> 12 || day
< 1 || day
> 31 ||
1201 hour
> 23 || minute
> 59 || second
> 61) {
1202 char *esc
= esc_for_log(cp
);
1203 log_warn(LD_GENERAL
, "ISO time %s was nonsensical", esc
);
1207 st_tm
.tm_year
= year
-1900;
1208 st_tm
.tm_mon
= month
-1;
1209 st_tm
.tm_mday
= day
;
1210 st_tm
.tm_hour
= hour
;
1211 st_tm
.tm_min
= minute
;
1212 st_tm
.tm_sec
= second
;
1214 if (st_tm
.tm_year
< 70) {
1215 char *esc
= esc_for_log(cp
);
1216 log_warn(LD_GENERAL
, "Got invalid ISO time %s. (Before 1970)", esc
);
1220 *t
= tor_timegm(&st_tm
);
1224 /** Given a <b>date</b> in one of the three formats allowed by HTTP (ugh),
1225 * parse it into <b>tm</b>. Return 0 on success, negative on failure. */
1227 parse_http_time(const char *date
, struct tm
*tm
)
1233 unsigned tm_mday
, tm_year
, tm_hour
, tm_min
, tm_sec
;
1236 memset(tm
, 0, sizeof(*tm
));
1238 /* First, try RFC1123 or RFC850 format: skip the weekday. */
1239 if ((cp
= strchr(date
, ','))) {
1241 if (tor_sscanf(date
, "%2u %3s %4u %2u:%2u:%2u GMT",
1242 &tm_mday
, month
, &tm_year
,
1243 &tm_hour
, &tm_min
, &tm_sec
) == 6) {
1246 } else if (tor_sscanf(date
, "%2u-%3s-%2u %2u:%2u:%2u GMT",
1247 &tm_mday
, month
, &tm_year
,
1248 &tm_hour
, &tm_min
, &tm_sec
) == 6) {
1254 /* No comma; possibly asctime() format. */
1255 if (tor_sscanf(date
, "%3s %3s %2u %2u:%2u:%2u %4u",
1256 wkday
, month
, &tm_mday
,
1257 &tm_hour
, &tm_min
, &tm_sec
, &tm_year
) == 7) {
1263 tm
->tm_mday
= (int)tm_mday
;
1264 tm
->tm_year
= (int)tm_year
;
1265 tm
->tm_hour
= (int)tm_hour
;
1266 tm
->tm_min
= (int)tm_min
;
1267 tm
->tm_sec
= (int)tm_sec
;
1270 /* Okay, now decode the month. */
1271 for (i
= 0; i
< 12; ++i
) {
1272 if (!strcasecmp(MONTH_NAMES
[i
], month
)) {
1277 if (tm
->tm_year
< 0 ||
1278 tm
->tm_mon
< 1 || tm
->tm_mon
> 12 ||
1279 tm
->tm_mday
< 0 || tm
->tm_mday
> 31 ||
1280 tm
->tm_hour
< 0 || tm
->tm_hour
> 23 ||
1281 tm
->tm_min
< 0 || tm
->tm_min
> 59 ||
1282 tm
->tm_sec
< 0 || tm
->tm_sec
> 61)
1283 return -1; /* Out of range, or bad month. */
1288 /** Given an <b>interval</b> in seconds, try to write it to the
1289 * <b>out_len</b>-byte buffer in <b>out</b> in a human-readable form.
1290 * Return 0 on success, -1 on failure.
1293 format_time_interval(char *out
, size_t out_len
, long interval
)
1295 /* We only report seconds if there's no hours. */
1296 long sec
= 0, min
= 0, hour
= 0, day
= 0;
1298 interval
= -interval
;
1300 if (interval
>= 86400) {
1301 day
= interval
/ 86400;
1304 if (interval
>= 3600) {
1305 hour
= interval
/ 3600;
1308 if (interval
>= 60) {
1309 min
= interval
/ 60;
1315 return tor_snprintf(out
, out_len
, "%ld days, %ld hours, %ld minutes",
1318 return tor_snprintf(out
, out_len
, "%ld hours, %ld minutes", hour
, min
);
1320 return tor_snprintf(out
, out_len
, "%ld minutes, %ld seconds", min
, sec
);
1322 return tor_snprintf(out
, out_len
, "%ld seconds", sec
);
1330 #ifndef TIME_IS_FAST
1331 /** Cached estimate of the current time. Updated around once per second;
1332 * may be a few seconds off if we are really busy. This is a hack to avoid
1333 * calling time(NULL) (which not everybody has optimized) on critical paths.
1335 static time_t cached_approx_time
= 0;
1337 /** Return a cached estimate of the current time from when
1338 * update_approx_time() was last called. This is a hack to avoid calling
1339 * time(NULL) on critical paths: please do not even think of calling it
1344 return cached_approx_time
;
1347 /** Update the cached estimate of the current time. This function SHOULD be
1348 * called once per second, and MUST be called before the first call to
1349 * get_approx_time. */
1351 update_approx_time(time_t now
)
1353 cached_approx_time
= now
;
1359 * XXXX022 Use this consistently or rip most of it out.
1362 /* In a perfect world, everybody would run NTP, and NTP would be perfect, so
1363 * if we wanted to know "Is the current time before time X?" we could just say
1366 * But unfortunately, many users are running Tor in an imperfect world, on
1367 * even more imperfect computers. Hence, we need to track time oddly. We
1368 * model the user's computer as being "skewed" from accurate time by
1369 * -<b>ftime_skew</b> seconds, such that our best guess of the current time is
1370 * time(NULL)+ftime_skew. We also assume that our measurements of time may
1371 * have up to <b>ftime_slop</b> seconds of inaccuracy; IOW, our window of
1372 * estimate for the current time is now + ftime_skew +/- ftime_slop.
1374 /** Our current estimate of our skew, such that we think the current time is
1375 * closest to time(NULL)+ftime_skew. */
1376 static int ftime_skew
= 0;
1377 /** Tolerance during time comparisons, in seconds. */
1378 static int ftime_slop
= 60;
1379 /** Set the largest amount of sloppiness we'll allow in fuzzy time
1382 ftime_set_maximum_sloppiness(int seconds
)
1384 tor_assert(seconds
>= 0);
1385 ftime_slop
= seconds
;
1387 /** Set the amount by which we believe our system clock to differ from
1390 ftime_set_estimated_skew(int seconds
)
1392 ftime_skew
= seconds
;
1396 ftime_get_window(time_t now
, ftime_t
*ft_out
)
1398 ft_out
->earliest
= now
+ ftime_skew
- ftime_slop
;
1399 ft_out
->latest
= now
+ ftime_skew
+ ftime_slop
;
1402 /** Return true iff we think that <b>now</b> might be after <b>when</b>. */
1404 ftime_maybe_after(time_t now
, time_t when
)
1406 /* It may be after when iff the latest possible current time is after when */
1407 return (now
+ ftime_skew
+ ftime_slop
) >= when
;
1409 /** Return true iff we think that <b>now</b> might be before <b>when</b>. */
1411 ftime_maybe_before(time_t now
, time_t when
)
1413 /* It may be before when iff the earliest possible current time is before */
1414 return (now
+ ftime_skew
- ftime_slop
) < when
;
1416 /** Return true if we think that <b>now</b> is definitely after <b>when</b>. */
1418 ftime_definitely_after(time_t now
, time_t when
)
1420 /* It is definitely after when if the earliest time it could be is still
1422 return (now
+ ftime_skew
- ftime_slop
) >= when
;
1424 /** Return true if we think that <b>now</b> is definitely before <b>when</b>.
1427 ftime_definitely_before(time_t now
, time_t when
)
1429 /* It is definitely before when if the latest time it could be is still
1431 return (now
+ ftime_skew
+ ftime_slop
) < when
;
1438 /** Write <b>count</b> bytes from <b>buf</b> to <b>fd</b>. <b>isSocket</b>
1439 * must be 1 if fd was returned by socket() or accept(), and 0 if fd
1440 * was returned by open(). Return the number of bytes written, or -1
1441 * on error. Only use if fd is a blocking fd. */
1443 write_all(int fd
, const char *buf
, size_t count
, int isSocket
)
1447 tor_assert(count
< SSIZE_T_MAX
);
1449 while (written
!= count
) {
1451 result
= tor_socket_send(fd
, buf
+written
, count
-written
, 0);
1453 result
= write(fd
, buf
+written
, count
-written
);
1458 return (ssize_t
)count
;
1461 /** Read from <b>fd</b> to <b>buf</b>, until we get <b>count</b> bytes
1462 * or reach the end of the file. <b>isSocket</b> must be 1 if fd
1463 * was returned by socket() or accept(), and 0 if fd was returned by
1464 * open(). Return the number of bytes read, or -1 on error. Only use
1465 * if fd is a blocking fd. */
1467 read_all(int fd
, char *buf
, size_t count
, int isSocket
)
1472 if (count
> SIZE_T_CEILING
|| count
> SSIZE_T_MAX
)
1475 while (numread
!= count
) {
1477 result
= tor_socket_recv(fd
, buf
+numread
, count
-numread
, 0);
1479 result
= read(fd
, buf
+numread
, count
-numread
);
1482 else if (result
== 0)
1486 return (ssize_t
)numread
;
1490 * Filesystem operations.
1493 /** Clean up <b>name</b> so that we can use it in a call to "stat". On Unix,
1494 * we do nothing. On Windows, we remove a trailing slash, unless the path is
1495 * the root of a disk. */
1497 clean_name_for_stat(char *name
)
1500 size_t len
= strlen(name
);
1503 if (name
[len
-1]=='\\' || name
[len
-1]=='/') {
1504 if (len
== 1 || (len
==3 && name
[1]==':'))
1513 /** Return FN_ERROR if filename can't be read, FN_NOENT if it doesn't
1514 * exist, FN_FILE if it is a regular file, or FN_DIR if it's a
1515 * directory. On FN_ERROR, sets errno. */
1517 file_status(const char *fname
)
1522 f
= tor_strdup(fname
);
1523 clean_name_for_stat(f
);
1527 if (errno
== ENOENT
) {
1532 if (st
.st_mode
& S_IFDIR
)
1534 else if (st
.st_mode
& S_IFREG
)
1540 /** Check whether dirname exists and is private. If yes return 0. If
1541 * it does not exist, and check==CPD_CREATE is set, try to create it
1542 * and return 0 on success. If it does not exist, and
1543 * check==CPD_CHECK, and we think we can create it, return 0. Else
1546 check_private_dir(const char *dirname
, cpd_check_t check
)
1551 tor_assert(dirname
);
1552 f
= tor_strdup(dirname
);
1553 clean_name_for_stat(f
);
1557 if (errno
!= ENOENT
) {
1558 log(LOG_WARN
, LD_FS
, "Directory %s cannot be read: %s", dirname
,
1562 if (check
== CPD_NONE
) {
1563 log(LOG_WARN
, LD_FS
, "Directory %s does not exist.", dirname
);
1565 } else if (check
== CPD_CREATE
) {
1566 log_info(LD_GENERAL
, "Creating directory %s", dirname
);
1570 r
= mkdir(dirname
, 0700);
1573 log(LOG_WARN
, LD_FS
, "Error creating directory %s: %s", dirname
,
1578 /* XXXX In the case where check==CPD_CHECK, we should look at the
1579 * parent directory a little harder. */
1582 if (!(st
.st_mode
& S_IFDIR
)) {
1583 log(LOG_WARN
, LD_FS
, "%s is not a directory", dirname
);
1587 if (st
.st_uid
!= getuid()) {
1588 struct passwd
*pw
= NULL
;
1589 char *process_ownername
= NULL
;
1591 pw
= getpwuid(getuid());
1592 process_ownername
= pw
? tor_strdup(pw
->pw_name
) : tor_strdup("<unknown>");
1594 pw
= getpwuid(st
.st_uid
);
1596 log(LOG_WARN
, LD_FS
, "%s is not owned by this user (%s, %d) but by "
1597 "%s (%d). Perhaps you are running Tor as the wrong user?",
1598 dirname
, process_ownername
, (int)getuid(),
1599 pw
? pw
->pw_name
: "<unknown>", (int)st
.st_uid
);
1601 tor_free(process_ownername
);
1604 if (st
.st_mode
& 0077) {
1605 log(LOG_WARN
, LD_FS
, "Fixing permissions on directory %s", dirname
);
1606 if (chmod(dirname
, 0700)) {
1607 log(LOG_WARN
, LD_FS
, "Could not chmod directory %s: %s", dirname
,
1618 /** Create a file named <b>fname</b> with the contents <b>str</b>. Overwrite
1619 * the previous <b>fname</b> if possible. Return 0 on success, -1 on failure.
1621 * This function replaces the old file atomically, if possible. This
1622 * function, and all other functions in util.c that create files, create them
1626 write_str_to_file(const char *fname
, const char *str
, int bin
)
1629 if (!bin
&& strchr(str
, '\r')) {
1631 "We're writing a text string that already contains a CR.");
1634 return write_bytes_to_file(fname
, str
, strlen(str
), bin
);
1637 /** Represents a file that we're writing to, with support for atomic commit:
1638 * we can write into a a temporary file, and either remove the file on
1639 * failure, or replace the original file on success. */
1640 struct open_file_t
{
1641 char *tempname
; /**< Name of the temporary file. */
1642 char *filename
; /**< Name of the original file. */
1643 int rename_on_close
; /**< Are we using the temporary file or not? */
1644 int fd
; /**< fd for the open file. */
1645 FILE *stdio_file
; /**< stdio wrapper for <b>fd</b>. */
1648 /** Try to start writing to the file in <b>fname</b>, passing the flags
1649 * <b>open_flags</b> to the open() syscall, creating the file (if needed) with
1650 * access value <b>mode</b>. If the O_APPEND flag is set, we append to the
1651 * original file. Otherwise, we open a new temporary file in the same
1652 * directory, and either replace the original or remove the temporary file
1655 * Return the fd for the newly opened file, and store working data in
1656 * *<b>data_out</b>. The caller should not close the fd manually:
1657 * instead, call finish_writing_to_file() or abort_writing_to_file().
1658 * Returns -1 on failure.
1660 * NOTE: When not appending, the flags O_CREAT and O_TRUNC are treated
1661 * as true and the flag O_EXCL is treated as false.
1663 * NOTE: Ordinarily, O_APPEND means "seek to the end of the file before each
1664 * write()". We don't do that.
1667 start_writing_to_file(const char *fname
, int open_flags
, int mode
,
1668 open_file_t
**data_out
)
1670 size_t tempname_len
= strlen(fname
)+16;
1671 open_file_t
*new_file
= tor_malloc_zero(sizeof(open_file_t
));
1672 const char *open_name
;
1676 tor_assert(data_out
);
1677 #if (O_BINARY != 0 && O_TEXT != 0)
1678 tor_assert((open_flags
& (O_BINARY
|O_TEXT
)) != 0);
1681 tor_assert(tempname_len
> strlen(fname
)); /*check for overflow*/
1682 new_file
->filename
= tor_strdup(fname
);
1683 if (open_flags
& O_APPEND
) {
1685 new_file
->rename_on_close
= 0;
1687 open_flags
&= ~O_APPEND
;
1689 open_name
= new_file
->tempname
= tor_malloc(tempname_len
);
1690 if (tor_snprintf(new_file
->tempname
, tempname_len
, "%s.tmp", fname
)<0) {
1691 log(LOG_WARN
, LD_GENERAL
, "Failed to generate filename");
1694 /* We always replace an existing temporary file if there is one. */
1695 open_flags
|= O_CREAT
|O_TRUNC
;
1696 open_flags
&= ~O_EXCL
;
1697 new_file
->rename_on_close
= 1;
1700 if ((new_file
->fd
= open(open_name
, open_flags
, mode
)) < 0) {
1701 log(LOG_WARN
, LD_FS
, "Couldn't open \"%s\" (%s) for writing: %s",
1702 open_name
, fname
, strerror(errno
));
1706 if (tor_fd_seekend(new_file
->fd
) < 0) {
1707 log_warn(LD_FS
, "Couldn't seek to end of file \"%s\": %s", open_name
,
1713 *data_out
= new_file
;
1715 return new_file
->fd
;
1718 if (new_file
->fd
>= 0)
1719 close(new_file
->fd
);
1721 tor_free(new_file
->filename
);
1722 tor_free(new_file
->tempname
);
1727 /** Given <b>file_data</b> from start_writing_to_file(), return a stdio FILE*
1728 * that can be used to write to the same file. The caller should not mix
1729 * stdio calls with non-stdio calls. */
1731 fdopen_file(open_file_t
*file_data
)
1733 tor_assert(file_data
);
1734 if (file_data
->stdio_file
)
1735 return file_data
->stdio_file
;
1736 tor_assert(file_data
->fd
>= 0);
1737 if (!(file_data
->stdio_file
= fdopen(file_data
->fd
, "a"))) {
1738 log_warn(LD_FS
, "Couldn't fdopen \"%s\" [%d]: %s", file_data
->filename
,
1739 file_data
->fd
, strerror(errno
));
1741 return file_data
->stdio_file
;
1744 /** Combines start_writing_to_file with fdopen_file(): arguments are as
1745 * for start_writing_to_file, but */
1747 start_writing_to_stdio_file(const char *fname
, int open_flags
, int mode
,
1748 open_file_t
**data_out
)
1751 if (start_writing_to_file(fname
, open_flags
, mode
, data_out
)<0)
1753 if (!(res
= fdopen_file(*data_out
))) {
1754 abort_writing_to_file(*data_out
);
1760 /** Helper function: close and free the underlying file and memory in
1761 * <b>file_data</b>. If we were writing into a temporary file, then delete
1762 * that file (if abort_write is true) or replaces the target file with
1763 * the temporary file (if abort_write is false). */
1765 finish_writing_to_file_impl(open_file_t
*file_data
, int abort_write
)
1768 tor_assert(file_data
&& file_data
->filename
);
1769 if (file_data
->stdio_file
) {
1770 if (fclose(file_data
->stdio_file
)) {
1771 log_warn(LD_FS
, "Error closing \"%s\": %s", file_data
->filename
,
1773 abort_write
= r
= -1;
1775 } else if (file_data
->fd
>= 0 && close(file_data
->fd
) < 0) {
1776 log_warn(LD_FS
, "Error flushing \"%s\": %s", file_data
->filename
,
1778 abort_write
= r
= -1;
1781 if (file_data
->rename_on_close
) {
1782 tor_assert(file_data
->tempname
&& file_data
->filename
);
1784 unlink(file_data
->tempname
);
1786 tor_assert(strcmp(file_data
->filename
, file_data
->tempname
));
1787 if (replace_file(file_data
->tempname
, file_data
->filename
)) {
1788 log_warn(LD_FS
, "Error replacing \"%s\": %s", file_data
->filename
,
1795 tor_free(file_data
->filename
);
1796 tor_free(file_data
->tempname
);
1797 tor_free(file_data
);
1802 /** Finish writing to <b>file_data</b>: close the file handle, free memory as
1803 * needed, and if using a temporary file, replace the original file with
1804 * the temporary file. */
1806 finish_writing_to_file(open_file_t
*file_data
)
1808 return finish_writing_to_file_impl(file_data
, 0);
1811 /** Finish writing to <b>file_data</b>: close the file handle, free memory as
1812 * needed, and if using a temporary file, delete it. */
1814 abort_writing_to_file(open_file_t
*file_data
)
1816 return finish_writing_to_file_impl(file_data
, 1);
1819 /** Helper: given a set of flags as passed to open(2), open the file
1820 * <b>fname</b> and write all the sized_chunk_t structs in <b>chunks</b> to
1821 * the file. Do so as atomically as possible e.g. by opening temp files and
1824 write_chunks_to_file_impl(const char *fname
, const smartlist_t
*chunks
,
1827 open_file_t
*file
= NULL
;
1830 fd
= start_writing_to_file(fname
, open_flags
, 0600, &file
);
1833 SMARTLIST_FOREACH(chunks
, sized_chunk_t
*, chunk
,
1835 result
= write_all(fd
, chunk
->bytes
, chunk
->len
, 0);
1837 log(LOG_WARN
, LD_FS
, "Error writing to \"%s\": %s", fname
,
1841 tor_assert((size_t)result
== chunk
->len
);
1844 return finish_writing_to_file(file
);
1846 abort_writing_to_file(file
);
1850 /** Given a smartlist of sized_chunk_t, write them atomically to a file
1851 * <b>fname</b>, overwriting or creating the file as necessary. */
1853 write_chunks_to_file(const char *fname
, const smartlist_t
*chunks
, int bin
)
1855 int flags
= OPEN_FLAGS_REPLACE
|(bin
?O_BINARY
:O_TEXT
);
1856 return write_chunks_to_file_impl(fname
, chunks
, flags
);
1859 /** As write_str_to_file, but does not assume a NUL-terminated
1860 * string. Instead, we write <b>len</b> bytes, starting at <b>str</b>. */
1862 write_bytes_to_file(const char *fname
, const char *str
, size_t len
,
1865 int flags
= OPEN_FLAGS_REPLACE
|(bin
?O_BINARY
:O_TEXT
);
1867 sized_chunk_t c
= { str
, len
};
1868 smartlist_t
*chunks
= smartlist_create();
1869 smartlist_add(chunks
, &c
);
1870 r
= write_chunks_to_file_impl(fname
, chunks
, flags
);
1871 smartlist_free(chunks
);
1875 /** As write_bytes_to_file, but if the file already exists, append the bytes
1876 * to the end of the file instead of overwriting it. */
1878 append_bytes_to_file(const char *fname
, const char *str
, size_t len
,
1881 int flags
= OPEN_FLAGS_APPEND
|(bin
?O_BINARY
:O_TEXT
);
1883 sized_chunk_t c
= { str
, len
};
1884 smartlist_t
*chunks
= smartlist_create();
1885 smartlist_add(chunks
, &c
);
1886 r
= write_chunks_to_file_impl(fname
, chunks
, flags
);
1887 smartlist_free(chunks
);
1891 /** Read the contents of <b>filename</b> into a newly allocated
1892 * string; return the string on success or NULL on failure.
1894 * If <b>stat_out</b> is provided, store the result of stat()ing the
1895 * file into <b>stat_out</b>.
1897 * If <b>flags</b> & RFTS_BIN, open the file in binary mode.
1898 * If <b>flags</b> & RFTS_IGNORE_MISSING, don't warn if the file
1902 * This function <em>may</em> return an erroneous result if the file
1903 * is modified while it is running, but must not crash or overflow.
1904 * Right now, the error case occurs when the file length grows between
1905 * the call to stat and the call to read_all: the resulting string will
1909 read_file_to_str(const char *filename
, int flags
, struct stat
*stat_out
)
1911 int fd
; /* router file */
1912 struct stat statbuf
;
1915 int bin
= flags
& RFTS_BIN
;
1917 tor_assert(filename
);
1919 fd
= open(filename
,O_RDONLY
|(bin
?O_BINARY
:O_TEXT
),0);
1921 int severity
= LOG_WARN
;
1922 int save_errno
= errno
;
1923 if (errno
== ENOENT
&& (flags
& RFTS_IGNORE_MISSING
))
1924 severity
= LOG_INFO
;
1925 log_fn(severity
, LD_FS
,"Could not open \"%s\": %s ",filename
,
1931 if (fstat(fd
, &statbuf
)<0) {
1932 int save_errno
= errno
;
1934 log_warn(LD_FS
,"Could not fstat \"%s\".",filename
);
1939 if ((uint64_t)(statbuf
.st_size
)+1 >= SIZE_T_CEILING
)
1942 string
= tor_malloc((size_t)(statbuf
.st_size
+1));
1944 r
= read_all(fd
,string
,(size_t)statbuf
.st_size
,0);
1946 int save_errno
= errno
;
1947 log_warn(LD_FS
,"Error reading from file \"%s\": %s", filename
,
1954 string
[r
] = '\0'; /* NUL-terminate the result. */
1957 if (!bin
&& strchr(string
, '\r')) {
1958 log_debug(LD_FS
, "We didn't convert CRLF to LF as well as we hoped "
1959 "when reading %s. Coping.",
1961 tor_strstrip(string
, "\r");
1965 statbuf
.st_size
= (size_t) r
;
1968 if (r
!= statbuf
.st_size
) {
1969 /* Unless we're using text mode on win32, we'd better have an exact
1970 * match for size. */
1971 int save_errno
= errno
;
1972 log_warn(LD_FS
,"Could read only %d of %ld bytes of file \"%s\".",
1973 (int)r
, (long)statbuf
.st_size
,filename
);
1981 memcpy(stat_out
, &statbuf
, sizeof(struct stat
));
1987 #define TOR_ISODIGIT(c) ('0' <= (c) && (c) <= '7')
1989 /** Given a c-style double-quoted escaped string in <b>s</b>, extract and
1990 * decode its contents into a newly allocated string. On success, assign this
1991 * string to *<b>result</b>, assign its length to <b>size_out</b> (if
1992 * provided), and return a pointer to the position in <b>s</b> immediately
1993 * after the string. On failure, return NULL.
1996 unescape_string(const char *s
, char **result
, size_t *size_out
)
2011 if ((cp
[1] == 'x' || cp
[1] == 'X')
2012 && TOR_ISXDIGIT(cp
[2]) && TOR_ISXDIGIT(cp
[3])) {
2014 } else if (TOR_ISODIGIT(cp
[1])) {
2016 if (TOR_ISODIGIT(*cp
)) ++cp
;
2017 if (TOR_ISODIGIT(*cp
)) ++cp
;
2030 out
= *result
= tor_malloc(cp
-s
+ 1);
2037 if (size_out
) *size_out
= out
- *result
;
2040 tor_fragile_assert();
2046 case 'n': *out
++ = '\n'; cp
+= 2; break;
2047 case 'r': *out
++ = '\r'; cp
+= 2; break;
2048 case 't': *out
++ = '\t'; cp
+= 2; break;
2050 *out
++ = ((hex_decode_digit(cp
[2])<<4) +
2051 hex_decode_digit(cp
[3]));
2054 case '0': case '1': case '2': case '3': case '4': case '5':
2059 if (TOR_ISODIGIT(*cp
)) { n
= n
*8 + *cp
-'0'; cp
++; }
2060 if (TOR_ISODIGIT(*cp
)) { n
= n
*8 + *cp
-'0'; cp
++; }
2061 if (n
> 255) { tor_free(*result
); return NULL
; }
2073 tor_free(*result
); return NULL
;
2082 /** Given a string containing part of a configuration file or similar format,
2083 * advance past comments and whitespace and try to parse a single line. If we
2084 * parse a line successfully, set *<b>key_out</b> to a new string holding the
2085 * key portion and *<b>value_out</b> to a new string holding the value portion
2086 * of the line, and return a pointer to the start of the next line. If we run
2087 * out of data, return a pointer to the end of the string. If we encounter an
2088 * error, return NULL.
2091 parse_config_line_from_str(const char *line
, char **key_out
, char **value_out
)
2093 const char *key
, *val
, *cp
;
2095 tor_assert(key_out
);
2096 tor_assert(value_out
);
2098 *key_out
= *value_out
= NULL
;
2100 /* Skip until the first keyword. */
2102 while (TOR_ISSPACE(*line
))
2105 while (*line
&& *line
!= '\n')
2112 if (!*line
) { /* End of string? */
2113 *key_out
= *value_out
= NULL
;
2117 /* Skip until the next space. */
2119 while (*line
&& !TOR_ISSPACE(*line
) && *line
!= '#')
2121 *key_out
= tor_strndup(key
, line
-key
);
2123 /* Skip until the value. */
2124 while (*line
== ' ' || *line
== '\t')
2129 /* Find the end of the line. */
2130 if (*line
== '\"') {
2131 if (!(line
= unescape_string(line
, value_out
, NULL
)))
2133 while (*line
== ' ' || *line
== '\t')
2135 if (*line
&& *line
!= '#' && *line
!= '\n')
2138 while (*line
&& *line
!= '\n' && *line
!= '#')
2140 if (*line
== '\n') {
2145 while (cp
>val
&& TOR_ISSPACE(*(cp
-1)))
2148 tor_assert(cp
>= val
);
2149 *value_out
= tor_strndup(val
, cp
-val
);
2155 } while (*line
&& *line
!= '\n');
2157 while (TOR_ISSPACE(*line
)) ++line
;
2162 /** Expand any homedir prefix on <b>filename</b>; return a newly allocated
2165 expand_filename(const char *filename
)
2167 tor_assert(filename
);
2168 if (*filename
== '~') {
2170 char *home
, *result
;
2173 if (filename
[1] == '/' || filename
[1] == '\0') {
2174 home
= getenv("HOME");
2176 log_warn(LD_CONFIG
, "Couldn't find $HOME environment variable while "
2177 "expanding \"%s\"", filename
);
2180 home
= tor_strdup(home
);
2181 rest
= strlen(filename
)>=2?(filename
+2):"";
2184 char *username
, *slash
;
2185 slash
= strchr(filename
, '/');
2187 username
= tor_strndup(filename
+1,slash
-filename
-1);
2189 username
= tor_strdup(filename
+1);
2190 if (!(home
= get_user_homedir(username
))) {
2191 log_warn(LD_CONFIG
,"Couldn't get homedir for \"%s\"",username
);
2196 rest
= slash
? (slash
+1) : "";
2198 log_warn(LD_CONFIG
, "Couldn't expend homedir on system without pwd.h");
2199 return tor_strdup(filename
);
2203 /* Remove trailing slash. */
2204 if (strlen(home
)>1 && !strcmpend(home
,PATH_SEPARATOR
)) {
2205 home
[strlen(home
)-1] = '\0';
2207 /* Plus one for /, plus one for NUL.
2208 * Round up to 16 in case we can't do math. */
2209 len
= strlen(home
)+strlen(rest
)+16;
2210 result
= tor_malloc(len
);
2211 tor_snprintf(result
,len
,"%s"PATH_SEPARATOR
"%s",home
,rest
);
2215 return tor_strdup(filename
);
2219 #define MAX_SCANF_WIDTH 9999
2223 digit_to_num(char d
)
2225 int num
= ((int)d
) - (int)'0';
2226 tor_assert(num
<= 9 && num
>= 0);
2232 scan_unsigned(const char **bufp
, unsigned *out
, int width
)
2234 unsigned result
= 0;
2235 int scanned_so_far
= 0;
2236 if (!bufp
|| !*bufp
|| !out
)
2239 width
=MAX_SCANF_WIDTH
;
2241 while (**bufp
&& TOR_ISDIGIT(**bufp
) && scanned_so_far
< width
) {
2242 int digit
= digit_to_num(*(*bufp
)++);
2243 unsigned new_result
= result
* 10 + digit
;
2244 if (new_result
> UINT32_MAX
|| new_result
< result
)
2245 return -1; /* over/underflow. */
2246 result
= new_result
;
2250 if (!scanned_so_far
) /* No actual digits scanned */
2259 scan_string(const char **bufp
, char *out
, int width
)
2261 int scanned_so_far
= 0;
2262 if (!bufp
|| !out
|| width
< 0)
2264 while (**bufp
&& ! TOR_ISSPACE(**bufp
) && scanned_so_far
< width
) {
2265 *out
++ = *(*bufp
)++;
2272 /** Locale-independent, minimal, no-surprises scanf variant, accepting only a
2273 * restricted pattern format. For more info on what it supports, see
2274 * tor_sscanf() documentation. */
2276 tor_vsscanf(const char *buf
, const char *pattern
, va_list ap
)
2281 if (*pattern
!= '%') {
2282 if (*buf
== *pattern
) {
2292 if (TOR_ISDIGIT(*pattern
)) {
2293 width
= digit_to_num(*pattern
++);
2294 while (TOR_ISDIGIT(*pattern
)) {
2296 width
+= digit_to_num(*pattern
++);
2297 if (width
> MAX_SCANF_WIDTH
)
2300 if (!width
) /* No zero-width things. */
2303 if (*pattern
== 'u') {
2304 unsigned *u
= va_arg(ap
, unsigned *);
2307 if (scan_unsigned(&buf
, u
, width
)<0)
2311 } else if (*pattern
== 's') {
2312 char *s
= va_arg(ap
, char *);
2315 if (scan_string(&buf
, s
, width
)<0)
2319 } else if (*pattern
== 'c') {
2320 char *ch
= va_arg(ap
, char *);
2328 } else if (*pattern
== '%') {
2334 return -1; /* Unrecognized pattern component. */
2342 /** Minimal sscanf replacement: parse <b>buf</b> according to <b>pattern</b>
2343 * and store the results in the corresponding argument fields. Differs from
2344 * sscanf in that it: Only handles %u and %Ns. Does not handle arbitrarily
2345 * long widths. %u does not consume any space. Is locale-independent.
2346 * Returns -1 on malformed patterns. */
2348 tor_sscanf(const char *buf
, const char *pattern
, ...)
2352 va_start(ap
, pattern
);
2353 r
= tor_vsscanf(buf
, pattern
, ap
);
2358 /** Return a new list containing the filenames in the directory <b>dirname</b>.
2359 * Return NULL on error or if <b>dirname</b> is not a directory.
2362 tor_listdir(const char *dirname
)
2364 smartlist_t
*result
;
2368 WIN32_FIND_DATA findData
;
2369 size_t pattern_len
= strlen(dirname
)+16;
2370 pattern
= tor_malloc(pattern_len
);
2371 tor_snprintf(pattern
, pattern_len
, "%s\\*", dirname
);
2372 if (INVALID_HANDLE_VALUE
== (handle
= FindFirstFile(pattern
, &findData
))) {
2376 result
= smartlist_create();
2378 if (strcmp(findData
.cFileName
, ".") &&
2379 strcmp(findData
.cFileName
, "..")) {
2380 smartlist_add(result
, tor_strdup(findData
.cFileName
));
2382 if (!FindNextFile(handle
, &findData
)) {
2384 if ((err
= GetLastError()) != ERROR_NO_MORE_FILES
) {
2385 char *errstr
= format_win32_error(err
);
2386 log_warn(LD_FS
, "Error reading directory '%s': %s", dirname
, errstr
);
2397 if (!(d
= opendir(dirname
)))
2400 result
= smartlist_create();
2401 while ((de
= readdir(d
))) {
2402 if (!strcmp(de
->d_name
, ".") ||
2403 !strcmp(de
->d_name
, ".."))
2405 smartlist_add(result
, tor_strdup(de
->d_name
));
2412 /** Return true iff <b>filename</b> is a relative path. */
2414 path_is_relative(const char *filename
)
2416 if (filename
&& filename
[0] == '/')
2419 else if (filename
&& filename
[0] == '\\')
2421 else if (filename
&& strlen(filename
)>3 && TOR_ISALPHA(filename
[0]) &&
2422 filename
[1] == ':' && filename
[2] == '\\')
2434 /* Based on code contributed by christian grothoff */
2435 /** True iff we've called start_daemon(). */
2436 static int start_daemon_called
= 0;
2437 /** True iff we've called finish_daemon(). */
2438 static int finish_daemon_called
= 0;
2439 /** Socketpair used to communicate between parent and child process while
2441 static int daemon_filedes
[2];
2442 /** Start putting the process into daemon mode: fork and drop all resources
2443 * except standard fds. The parent process never returns, but stays around
2444 * until finish_daemon is called. (Note: it's safe to call this more
2445 * than once: calls after the first are ignored.)
2452 if (start_daemon_called
)
2454 start_daemon_called
= 1;
2456 if (pipe(daemon_filedes
)) {
2457 log_err(LD_GENERAL
,"pipe failed; exiting. Error was %s", strerror(errno
));
2462 log_err(LD_GENERAL
,"fork failed. Exiting.");
2465 if (pid
) { /* Parent */
2469 close(daemon_filedes
[1]); /* we only read */
2471 while (0 < read(daemon_filedes
[0], &c
, sizeof(char))) {
2479 exit(1); /* child reported error */
2480 } else { /* Child */
2481 close(daemon_filedes
[0]); /* we only write */
2483 pid
= setsid(); /* Detach from controlling terminal */
2485 * Fork one more time, so the parent (the session group leader) can exit.
2486 * This means that we, as a non-session group leader, can never regain a
2487 * controlling terminal. This part is recommended by Stevens's
2488 * _Advanced Programming in the Unix Environment_.
2493 set_main_thread(); /* We are now the main thread. */
2499 /** Finish putting the process into daemon mode: drop standard fds, and tell
2500 * the parent process to exit. (Note: it's safe to call this more than once:
2501 * calls after the first are ignored. Calls start_daemon first if it hasn't
2502 * been called already.)
2505 finish_daemon(const char *desired_cwd
)
2509 if (finish_daemon_called
)
2511 if (!start_daemon_called
)
2513 finish_daemon_called
= 1;
2517 /* Don't hold the wrong FS mounted */
2518 if (chdir(desired_cwd
) < 0) {
2519 log_err(LD_GENERAL
,"chdir to \"%s\" failed. Exiting.",desired_cwd
);
2523 nullfd
= open("/dev/null", O_RDWR
);
2525 log_err(LD_GENERAL
,"/dev/null can't be opened. Exiting.");
2528 /* close fds linking to invoking terminal, but
2529 * close usual incoming fds, but redirect them somewhere
2530 * useful so the fds don't get reallocated elsewhere.
2532 if (dup2(nullfd
,0) < 0 ||
2533 dup2(nullfd
,1) < 0 ||
2534 dup2(nullfd
,2) < 0) {
2535 log_err(LD_GENERAL
,"dup2 failed. Exiting.");
2540 /* signal success */
2541 if (write(daemon_filedes
[1], &c
, sizeof(char)) != sizeof(char)) {
2542 log_err(LD_GENERAL
,"write failed. Exiting.");
2544 close(daemon_filedes
[1]);
2547 /* defined(MS_WINDOWS) */
2553 finish_daemon(const char *cp
)
2559 /** Write the current process ID, followed by NL, into <b>filename</b>.
2562 write_pidfile(char *filename
)
2566 if ((pidfile
= fopen(filename
, "w")) == NULL
) {
2567 log_warn(LD_FS
, "Unable to open \"%s\" for writing: %s", filename
,
2571 fprintf(pidfile
, "%d\n", (int)_getpid());
2573 fprintf(pidfile
, "%d\n", (int)getpid());