1 /* Copyright (c) 2003, Roger Dingledine
2 * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
3 * Copyright (c) 2007-2010, 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
)
171 result
= dmalloc_realloc(file
, line
, ptr
, size
, DMALLOC_FUNC_REALLOC
, 0);
173 result
= realloc(ptr
, size
);
176 if (PREDICT_UNLIKELY(result
== NULL
)) {
177 log_err(LD_MM
,"Out of memory on realloc(). Dying.");
183 /** Return a newly allocated copy of the NUL-terminated string s. On
184 * error, log and terminate. (Like strdup(s), but never returns
188 _tor_strdup(const char *s DMALLOC_PARAMS
)
194 dup
= dmalloc_strdup(file
, line
, s
, 0);
198 if (PREDICT_UNLIKELY(dup
== NULL
)) {
199 log_err(LD_MM
,"Out of memory on strdup(). Dying.");
205 /** Allocate and return a new string containing the first <b>n</b>
206 * characters of <b>s</b>. If <b>s</b> is longer than <b>n</b>
207 * characters, only the first <b>n</b> are copied. The result is
208 * always NUL-terminated. (Like strndup(s,n), but never returns
212 _tor_strndup(const char *s
, size_t n DMALLOC_PARAMS
)
216 tor_assert(n
< SIZE_T_CEILING
);
217 dup
= _tor_malloc((n
+1) DMALLOC_FN_ARGS
);
218 /* Performance note: Ordinarily we prefer strlcpy to strncpy. But
219 * this function gets called a whole lot, and platform strncpy is
220 * much faster than strlcpy when strlen(s) is much longer than n.
227 /** Allocate a chunk of <b>len</b> bytes, with the same contents as the
228 * <b>len</b> bytes starting at <b>mem</b>. */
230 _tor_memdup(const void *mem
, size_t len DMALLOC_PARAMS
)
233 tor_assert(len
< SIZE_T_CEILING
);
235 dup
= _tor_malloc(len DMALLOC_FN_ARGS
);
236 memcpy(dup
, mem
, len
);
240 /** Helper for places that need to take a function pointer to the right
241 * spelling of "free()". */
248 #if defined(HAVE_MALLOC_GOOD_SIZE) && !defined(HAVE_MALLOC_GOOD_SIZE_PROTOTYPE)
249 /* Some version of Mac OSX have malloc_good_size in their libc, but not
250 * actually defined in malloc/malloc.h. We detect this and work around it by
253 extern size_t malloc_good_size(size_t size
);
256 /** Allocate and return a chunk of memory of size at least *<b>size</b>, using
257 * the same resources we would use to malloc *<b>sizep</b>. Set *<b>sizep</b>
258 * to the number of usable bytes in the chunk of memory. */
260 _tor_malloc_roundup(size_t *sizep DMALLOC_PARAMS
)
262 #ifdef HAVE_MALLOC_GOOD_SIZE
263 tor_assert(*sizep
< SIZE_T_CEILING
);
264 *sizep
= malloc_good_size(*sizep
);
265 return _tor_malloc(*sizep DMALLOC_FN_ARGS
);
266 #elif 0 && defined(HAVE_MALLOC_USABLE_SIZE) && !defined(USE_DMALLOC)
267 /* Never use malloc_usable_size(); it makes valgrind really unhappy,
268 * and doesn't win much in terms of usable space where it exists. */
270 tor_assert(*sizep
< SIZE_T_CEILING
);
271 result
= _tor_malloc(*sizep DMALLOC_FN_ARGS
);
272 *sizep
= malloc_usable_size(result
);
275 return _tor_malloc(*sizep DMALLOC_FN_ARGS
);
279 /** Call the platform malloc info function, and dump the results to the log at
280 * level <b>severity</b>. If no such function exists, do nothing. */
282 tor_log_mallinfo(int severity
)
286 memset(&mi
, 0, sizeof(mi
));
289 "mallinfo() said: arena=%d, ordblks=%d, smblks=%d, hblks=%d, "
290 "hblkhd=%d, usmblks=%d, fsmblks=%d, uordblks=%d, fordblks=%d, "
292 mi
.arena
, mi
.ordblks
, mi
.smblks
, mi
.hblks
,
293 mi
.hblkhd
, mi
.usmblks
, mi
.fsmblks
, mi
.uordblks
, mi
.fordblks
,
299 dmalloc_log_changed(0, /* Since the program started. */
300 1, /* Log info about non-freed pointers. */
301 0, /* Do not log info about freed pointers. */
302 0 /* Do not log individual pointers. */
311 /** Returns floor(log2(u64)). If u64 is 0, (incorrectly) returns 0. */
313 tor_log2(uint64_t u64
)
316 if (u64
>= (U64_LITERAL(1)<<32)) {
320 if (u64
>= (U64_LITERAL(1)<<16)) {
324 if (u64
>= (U64_LITERAL(1)<<8)) {
328 if (u64
>= (U64_LITERAL(1)<<4)) {
332 if (u64
>= (U64_LITERAL(1)<<2)) {
336 if (u64
>= (U64_LITERAL(1)<<1)) {
343 /** Return the power of 2 closest to <b>u64</b>. */
345 round_to_power_of_2(uint64_t u64
)
347 int lg2
= tor_log2(u64
);
348 uint64_t low
= U64_LITERAL(1) << lg2
, high
= U64_LITERAL(1) << (lg2
+1);
349 if (high
- u64
< u64
- low
)
356 * String manipulation
359 /** Remove from the string <b>s</b> every character which appears in
362 tor_strstrip(char *s
, const char *strip
)
366 if (strchr(strip
, *read
)) {
375 /** Return a pointer to a NUL-terminated hexadecimal string encoding
376 * the first <b>fromlen</b> bytes of <b>from</b>. (fromlen must be \<= 32.) The
377 * result does not need to be deallocated, but repeated calls to
378 * hex_str will trash old results.
381 hex_str(const char *from
, size_t fromlen
)
384 if (fromlen
>(sizeof(buf
)-1)/2)
385 fromlen
= (sizeof(buf
)-1)/2;
386 base16_encode(buf
,sizeof(buf
),from
,fromlen
);
390 /** Convert all alphabetic characters in the nul-terminated string <b>s</b> to
393 tor_strlower(char *s
)
396 *s
= TOR_TOLOWER(*s
);
401 /** Convert all alphabetic characters in the nul-terminated string <b>s</b> to
404 tor_strupper(char *s
)
407 *s
= TOR_TOUPPER(*s
);
412 /** Return 1 if every character in <b>s</b> is printable, else return 0.
415 tor_strisprint(const char *s
)
418 if (!TOR_ISPRINT(*s
))
425 /** Return 1 if no character in <b>s</b> is uppercase, else return 0.
428 tor_strisnonupper(const char *s
)
438 /** Compares the first strlen(s2) characters of s1 with s2. Returns as for
442 strcmpstart(const char *s1
, const char *s2
)
444 size_t n
= strlen(s2
);
445 return strncmp(s1
, s2
, n
);
448 /** Compare the s1_len-byte string <b>s1</b> with <b>s2</b>,
449 * without depending on a terminating nul in s1. Sorting order is first by
450 * length, then lexically; return values are as for strcmp.
453 strcmp_len(const char *s1
, const char *s2
, size_t s1_len
)
455 size_t s2_len
= strlen(s2
);
460 return memcmp(s1
, s2
, s2_len
);
463 /** Compares the first strlen(s2) characters of s1 with s2. Returns as for
467 strcasecmpstart(const char *s1
, const char *s2
)
469 size_t n
= strlen(s2
);
470 return strncasecmp(s1
, s2
, n
);
473 /** Compares the last strlen(s2) characters of s1 with s2. Returns as for
477 strcmpend(const char *s1
, const char *s2
)
479 size_t n1
= strlen(s1
), n2
= strlen(s2
);
481 return strcmp(s1
,s2
);
483 return strncmp(s1
+(n1
-n2
), s2
, n2
);
486 /** Compares the last strlen(s2) characters of s1 with s2. Returns as for
490 strcasecmpend(const char *s1
, const char *s2
)
492 size_t n1
= strlen(s1
), n2
= strlen(s2
);
493 if (n2
>n1
) /* then they can't be the same; figure out which is bigger */
494 return strcasecmp(s1
,s2
);
496 return strncasecmp(s1
+(n1
-n2
), s2
, n2
);
499 /** Compare the value of the string <b>prefix</b> with the start of the
500 * <b>memlen</b>-byte memory chunk at <b>mem</b>. Return as for strcmp.
502 * [As memcmp(mem, prefix, strlen(prefix)) but returns -1 if memlen is less
503 * than strlen(prefix).]
506 memcmpstart(const void *mem
, size_t memlen
,
509 size_t plen
= strlen(prefix
);
512 return memcmp(mem
, prefix
, plen
);
515 /** Return a pointer to the first char of s that is not whitespace and
516 * not a comment, or to the terminating NUL if no such character exists.
519 eat_whitespace(const char *s
)
536 while (*s
&& *s
!= '\n')
542 /** Return a pointer to the first char of s that is not whitespace and
543 * not a comment, or to the terminating NUL if no such character exists.
546 eat_whitespace_eos(const char *s
, const char *eos
)
549 tor_assert(eos
&& s
<= eos
);
564 while (s
< eos
&& *s
&& *s
!= '\n')
571 /** Return a pointer to the first char of s that is not a space or a tab
572 * or a \\r, or to the terminating NUL if no such character exists. */
574 eat_whitespace_no_nl(const char *s
)
576 while (*s
== ' ' || *s
== '\t' || *s
== '\r')
581 /** As eat_whitespace_no_nl, but stop at <b>eos</b> whether we have
582 * found a non-whitespace character or not. */
584 eat_whitespace_eos_no_nl(const char *s
, const char *eos
)
586 while (s
< eos
&& (*s
== ' ' || *s
== '\t' || *s
== '\r'))
591 /** Return a pointer to the first char of s that is whitespace or <b>#</b>,
592 * or to the terminating NUL if no such character exists.
595 find_whitespace(const char *s
)
614 /** As find_whitespace, but stop at <b>eos</b> whether we have found a
615 * whitespace or not. */
617 find_whitespace_eos(const char *s
, const char *eos
)
637 /** Return true iff the 'len' bytes at 'mem' are all zero. */
639 tor_mem_is_zero(const char *mem
, size_t len
)
641 static const char ZERO
[] = {
642 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,
644 while (len
>= sizeof(ZERO
)) {
645 if (memcmp(mem
, ZERO
, sizeof(ZERO
)))
650 /* Deal with leftover bytes. */
652 return ! memcmp(mem
, ZERO
, len
);
657 /** Return true iff the DIGEST_LEN bytes in digest are all zero. */
659 tor_digest_is_zero(const char *digest
)
661 return tor_mem_is_zero(digest
, DIGEST_LEN
);
664 /* Helper: common code to check whether the result of a strtol or strtoul or
665 * strtoll is correct. */
666 #define CHECK_STRTOX_RESULT() \
667 /* Was at least one character converted? */ \
670 /* Were there unexpected unconverted characters? */ \
671 if (!next && *endptr) \
673 /* Is r within limits? */ \
674 if (r < min || r > max) \
677 if (next) *next = endptr; \
681 if (next) *next = endptr; \
684 /** Extract a long from the start of s, in the given numeric base. If
685 * there is unconverted data and next is provided, set *next to the
686 * first unconverted character. An error has occurred if no characters
687 * are converted; or if there are unconverted characters and next is NULL; or
688 * if the parsed value is not between min and max. When no error occurs,
689 * return the parsed value and set *ok (if provided) to 1. When an error
690 * occurs, return 0 and set *ok (if provided) to 0.
693 tor_parse_long(const char *s
, int base
, long min
, long max
,
694 int *ok
, char **next
)
699 r
= strtol(s
, &endptr
, base
);
700 CHECK_STRTOX_RESULT();
703 /** As tor_parse_long(), but return an unsigned long. */
705 tor_parse_ulong(const char *s
, int base
, unsigned long min
,
706 unsigned long max
, int *ok
, char **next
)
711 r
= strtoul(s
, &endptr
, base
);
712 CHECK_STRTOX_RESULT();
715 /** As tor_parse_log, but return a unit64_t. Only base 10 is guaranteed to
718 tor_parse_uint64(const char *s
, int base
, uint64_t min
,
719 uint64_t max
, int *ok
, char **next
)
725 r
= (uint64_t)strtoull(s
, &endptr
, base
);
726 #elif defined(MS_WINDOWS)
727 #if defined(_MSC_VER) && _MSC_VER < 1300
728 tor_assert(base
<= 10);
729 r
= (uint64_t)_atoi64(s
);
731 while (TOR_ISSPACE(*endptr
)) endptr
++;
732 while (TOR_ISDIGIT(*endptr
)) endptr
++;
734 r
= (uint64_t)_strtoui64(s
, &endptr
, base
);
736 #elif SIZEOF_LONG == 8
737 r
= (uint64_t)strtoul(s
, &endptr
, base
);
739 #error "I don't know how to parse 64-bit numbers."
742 CHECK_STRTOX_RESULT();
745 /** Encode the <b>srclen</b> bytes at <b>src</b> in a NUL-terminated,
746 * uppercase hexadecimal string; store it in the <b>destlen</b>-byte buffer
750 base16_encode(char *dest
, size_t destlen
, const char *src
, size_t srclen
)
755 tor_assert(destlen
>= srclen
*2+1);
756 tor_assert(destlen
< SIZE_T_CEILING
);
761 *cp
++ = "0123456789ABCDEF"[ (*(const uint8_t*)src
) >> 4 ];
762 *cp
++ = "0123456789ABCDEF"[ (*(const uint8_t*)src
) & 0xf ];
768 /** Helper: given a hex digit, return its value, or -1 if it isn't hex. */
770 _hex_decode_digit(char c
)
783 case 'A': case 'a': return 10;
784 case 'B': case 'b': return 11;
785 case 'C': case 'c': return 12;
786 case 'D': case 'd': return 13;
787 case 'E': case 'e': return 14;
788 case 'F': case 'f': return 15;
794 /** Helper: given a hex digit, return its value, or -1 if it isn't hex. */
796 hex_decode_digit(char c
)
798 return _hex_decode_digit(c
);
801 /** Given a hexadecimal string of <b>srclen</b> bytes in <b>src</b>, decode it
802 * and store the result in the <b>destlen</b>-byte buffer at <b>dest</b>.
803 * Return 0 on success, -1 on failure. */
805 base16_decode(char *dest
, size_t destlen
, const char *src
, size_t srclen
)
810 if ((srclen
% 2) != 0)
812 if (destlen
< srclen
/2 || destlen
> SIZE_T_CEILING
)
816 v1
= _hex_decode_digit(*src
);
817 v2
= _hex_decode_digit(*(src
+1));
820 *(uint8_t*)dest
= (v1
<<4)|v2
;
827 /** Allocate and return a new string representing the contents of <b>s</b>,
828 * surrounded by quotes and using standard C escapes.
830 * Generally, we use this for logging values that come in over the network to
831 * keep them from tricking users, and for sending certain values to the
834 * We trust values from the resolver, OS, configuration file, and command line
835 * to not be maliciously ill-formed. We validate incoming routerdescs and
836 * SOCKS requests and addresses from BEGIN cells as they're parsed;
837 * afterwards, we trust them as non-malicious.
840 esc_for_log(const char *s
)
846 return tor_strdup("");
849 for (cp
= s
; *cp
; ++cp
) {
857 if (TOR_ISPRINT(*cp
) && ((uint8_t)*cp
)<127)
865 result
= outp
= tor_malloc(len
);
867 for (cp
= s
; *cp
; ++cp
) {
888 if (TOR_ISPRINT(*cp
) && ((uint8_t)*cp
)<127) {
891 tor_snprintf(outp
, 5, "\\%03o", (int)(uint8_t) *cp
);
904 /** Allocate and return a new string representing the contents of <b>s</b>,
905 * surrounded by quotes and using standard C escapes.
907 * THIS FUNCTION IS NOT REENTRANT. Don't call it from outside the main
908 * thread. Also, each call invalidates the last-returned value, so don't
909 * try log_warn(LD_GENERAL, "%s %s", escaped(a), escaped(b));
912 escaped(const char *s
)
914 static char *_escaped_val
= NULL
;
916 tor_free(_escaped_val
);
919 _escaped_val
= esc_for_log(s
);
926 /** Rudimentary string wrapping code: given a un-wrapped <b>string</b> (no
927 * newlines!), break the string into newline-terminated lines of no more than
928 * <b>width</b> characters long (not counting newline) and insert them into
929 * <b>out</b> in order. Precede the first line with prefix0, and subsequent
930 * lines with prefixRest.
932 /* This uses a stupid greedy wrapping algorithm right now:
934 * - Try to fit as much stuff as possible, but break on a space.
935 * - If the first "word" of the line will extend beyond the allowable
936 * width, break the word at the end of the width.
939 wrap_string(smartlist_t
*out
, const char *string
, size_t width
,
940 const char *prefix0
, const char *prefixRest
)
942 size_t p0Len
, pRestLen
, pCurLen
;
943 const char *eos
, *prefixCur
;
952 p0Len
= strlen(prefix0
);
953 pRestLen
= strlen(prefixRest
);
954 tor_assert(width
> p0Len
&& width
> pRestLen
);
955 eos
= strchr(string
, '\0');
960 while ((eos
-string
)+pCurLen
> width
) {
961 const char *eol
= string
+ width
- pCurLen
;
962 while (eol
> string
&& *eol
!= ' ')
964 /* eol is now the last space that can fit, or the start of the string. */
966 size_t line_len
= (eol
-string
) + pCurLen
+ 2;
967 char *line
= tor_malloc(line_len
);
968 memcpy(line
, prefixCur
, pCurLen
);
969 memcpy(line
+pCurLen
, string
, eol
-string
);
970 line
[line_len
-2] = '\n';
971 line
[line_len
-1] = '\0';
972 smartlist_add(out
, line
);
975 size_t line_len
= width
+ 2;
976 char *line
= tor_malloc(line_len
);
977 memcpy(line
, prefixCur
, pCurLen
);
978 memcpy(line
+pCurLen
, string
, width
- pCurLen
);
979 line
[line_len
-2] = '\n';
980 line
[line_len
-1] = '\0';
981 smartlist_add(out
, line
);
982 string
+= width
-pCurLen
;
984 prefixCur
= prefixRest
;
989 size_t line_len
= (eos
-string
) + pCurLen
+ 2;
990 char *line
= tor_malloc(line_len
);
991 memcpy(line
, prefixCur
, pCurLen
);
992 memcpy(line
+pCurLen
, string
, eos
-string
);
993 line
[line_len
-2] = '\n';
994 line
[line_len
-1] = '\0';
995 smartlist_add(out
, line
);
1003 /** Return the number of microseconds elapsed between *start and *end.
1006 tv_udiff(const struct timeval
*start
, const struct timeval
*end
)
1009 long secdiff
= end
->tv_sec
- start
->tv_sec
;
1011 if (labs(secdiff
+1) > LONG_MAX
/1000000) {
1012 log_warn(LD_GENERAL
, "comparing times too far apart.");
1016 udiff
= secdiff
*1000000L + (end
->tv_usec
- start
->tv_usec
);
1020 /** Yield true iff <b>y</b> is a leap-year. */
1021 #define IS_LEAPYEAR(y) (!(y % 4) && ((y % 100) || !(y % 400)))
1022 /** Helper: Return the number of leap-days between Jan 1, y1 and Jan 1, y2. */
1024 n_leapdays(int y1
, int y2
)
1028 return (y2
/4 - y1
/4) - (y2
/100 - y1
/100) + (y2
/400 - y1
/400);
1030 /** Number of days per month in non-leap year; used by tor_timegm. */
1031 static const int days_per_month
[] =
1032 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
1034 /** Return a time_t given a struct tm. The result is given in GMT, and
1035 * does not account for leap seconds.
1038 tor_timegm(struct tm
*tm
)
1040 /* This is a pretty ironclad timegm implementation, snarfed from Python2.2.
1041 * It's way more brute-force than fiddling with tzset().
1043 time_t year
, days
, hours
, minutes
, seconds
;
1045 year
= tm
->tm_year
+ 1900;
1046 if (year
< 1970 || tm
->tm_mon
< 0 || tm
->tm_mon
> 11) {
1047 log_warn(LD_BUG
, "Out-of-range argument to tor_timegm");
1050 tor_assert(year
< INT_MAX
);
1051 days
= 365 * (year
-1970) + n_leapdays(1970,(int)year
);
1052 for (i
= 0; i
< tm
->tm_mon
; ++i
)
1053 days
+= days_per_month
[i
];
1054 if (tm
->tm_mon
> 1 && IS_LEAPYEAR(year
))
1056 days
+= tm
->tm_mday
- 1;
1057 hours
= days
*24 + tm
->tm_hour
;
1059 minutes
= hours
*60 + tm
->tm_min
;
1060 seconds
= minutes
*60 + tm
->tm_sec
;
1064 /* strftime is locale-specific, so we need to replace those parts */
1066 /** A c-locale array of 3-letter names of weekdays, starting with Sun. */
1067 static const char *WEEKDAY_NAMES
[] =
1068 { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
1069 /** A c-locale array of 3-letter names of months, starting with Jan. */
1070 static const char *MONTH_NAMES
[] =
1071 { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
1072 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
1074 /** Set <b>buf</b> to the RFC1123 encoding of the GMT value of <b>t</b>.
1075 * The buffer must be at least RFC1123_TIME_LEN+1 bytes long.
1077 * (RFC1123 format is Fri, 29 Sep 2006 15:54:20 GMT)
1080 format_rfc1123_time(char *buf
, time_t t
)
1084 tor_gmtime_r(&t
, &tm
);
1086 strftime(buf
, RFC1123_TIME_LEN
+1, "___, %d ___ %Y %H:%M:%S GMT", &tm
);
1087 tor_assert(tm
.tm_wday
>= 0);
1088 tor_assert(tm
.tm_wday
<= 6);
1089 memcpy(buf
, WEEKDAY_NAMES
[tm
.tm_wday
], 3);
1090 tor_assert(tm
.tm_wday
>= 0);
1091 tor_assert(tm
.tm_mon
<= 11);
1092 memcpy(buf
+8, MONTH_NAMES
[tm
.tm_mon
], 3);
1095 /** Parse the the RFC1123 encoding of some time (in GMT) from <b>buf</b>,
1096 * and store the result in *<b>t</b>.
1098 * Return 0 on success, -1 on failure.
1101 parse_rfc1123_time(const char *buf
, time_t *t
)
1107 unsigned tm_mday
, tm_year
, tm_hour
, tm_min
, tm_sec
;
1109 if (strlen(buf
) != RFC1123_TIME_LEN
)
1111 memset(&tm
, 0, sizeof(tm
));
1112 if (tor_sscanf(buf
, "%3s, %2u %3s %u %2u:%2u:%2u GMT", weekday
,
1113 &tm_mday
, month
, &tm_year
, &tm_hour
,
1114 &tm_min
, &tm_sec
) < 7) {
1115 char *esc
= esc_for_log(buf
);
1116 log_warn(LD_GENERAL
, "Got invalid RFC1123 time %s", esc
);
1120 if (tm_mday
> 31 || tm_hour
> 23 || tm_min
> 59 || tm_sec
> 61) {
1121 char *esc
= esc_for_log(buf
);
1122 log_warn(LD_GENERAL
, "Got invalid RFC1123 time %s", esc
);
1126 tm
.tm_mday
= (int)tm_mday
;
1127 tm
.tm_year
= (int)tm_year
;
1128 tm
.tm_hour
= (int)tm_hour
;
1129 tm
.tm_min
= (int)tm_min
;
1130 tm
.tm_sec
= (int)tm_sec
;
1133 for (i
= 0; i
< 12; ++i
) {
1134 if (!strcmp(month
, MONTH_NAMES
[i
])) {
1140 char *esc
= esc_for_log(buf
);
1141 log_warn(LD_GENERAL
, "Got invalid RFC1123 time %s: No such month", esc
);
1147 if (tm
.tm_year
< 1970) {
1148 char *esc
= esc_for_log(buf
);
1149 log_warn(LD_GENERAL
,
1150 "Got invalid RFC1123 time %s. (Before 1970)", esc
);
1156 *t
= tor_timegm(&tm
);
1160 /** Set <b>buf</b> to the ISO8601 encoding of the local value of <b>t</b>.
1161 * The buffer must be at least ISO_TIME_LEN+1 bytes long.
1163 * (ISO8601 format is 2006-10-29 10:57:20)
1166 format_local_iso_time(char *buf
, time_t t
)
1169 strftime(buf
, ISO_TIME_LEN
+1, "%Y-%m-%d %H:%M:%S", tor_localtime_r(&t
, &tm
));
1172 /** Set <b>buf</b> to the ISO8601 encoding of the GMT value of <b>t</b>.
1173 * The buffer must be at least ISO_TIME_LEN+1 bytes long.
1176 format_iso_time(char *buf
, time_t t
)
1179 strftime(buf
, ISO_TIME_LEN
+1, "%Y-%m-%d %H:%M:%S", tor_gmtime_r(&t
, &tm
));
1182 /** Given an ISO-formatted UTC time value (after the epoch) in <b>cp</b>,
1183 * parse it and store its value in *<b>t</b>. Return 0 on success, -1 on
1184 * failure. Ignore extraneous stuff in <b>cp</b> separated by whitespace from
1185 * the end of the time string. */
1187 parse_iso_time(const char *cp
, time_t *t
)
1190 unsigned int year
=0, month
=0, day
=0, hour
=100, minute
=100, second
=100;
1191 if (tor_sscanf(cp
, "%u-%2u-%2u %2u:%2u:%2u", &year
, &month
,
1192 &day
, &hour
, &minute
, &second
) < 6) {
1193 char *esc
= esc_for_log(cp
);
1194 log_warn(LD_GENERAL
, "ISO time %s was unparseable", esc
);
1198 if (year
< 1970 || month
< 1 || month
> 12 || day
< 1 || day
> 31 ||
1199 hour
> 23 || minute
> 59 || second
> 61) {
1200 char *esc
= esc_for_log(cp
);
1201 log_warn(LD_GENERAL
, "ISO time %s was nonsensical", esc
);
1205 st_tm
.tm_year
= year
-1900;
1206 st_tm
.tm_mon
= month
-1;
1207 st_tm
.tm_mday
= day
;
1208 st_tm
.tm_hour
= hour
;
1209 st_tm
.tm_min
= minute
;
1210 st_tm
.tm_sec
= second
;
1212 if (st_tm
.tm_year
< 70) {
1213 char *esc
= esc_for_log(cp
);
1214 log_warn(LD_GENERAL
, "Got invalid ISO time %s. (Before 1970)", esc
);
1218 *t
= tor_timegm(&st_tm
);
1222 /** Given a <b>date</b> in one of the three formats allowed by HTTP (ugh),
1223 * parse it into <b>tm</b>. Return 0 on success, negative on failure. */
1225 parse_http_time(const char *date
, struct tm
*tm
)
1231 unsigned tm_mday
, tm_year
, tm_hour
, tm_min
, tm_sec
;
1234 memset(tm
, 0, sizeof(*tm
));
1236 /* First, try RFC1123 or RFC850 format: skip the weekday. */
1237 if ((cp
= strchr(date
, ','))) {
1239 if (tor_sscanf(date
, "%2u %3s %4u %2u:%2u:%2u GMT",
1240 &tm_mday
, month
, &tm_year
,
1241 &tm_hour
, &tm_min
, &tm_sec
) == 6) {
1244 } else if (tor_sscanf(date
, "%2u-%3s-%2u %2u:%2u:%2u GMT",
1245 &tm_mday
, month
, &tm_year
,
1246 &tm_hour
, &tm_min
, &tm_sec
) == 6) {
1252 /* No comma; possibly asctime() format. */
1253 if (tor_sscanf(date
, "%3s %3s %2u %2u:%2u:%2u %4u",
1254 wkday
, month
, &tm_mday
,
1255 &tm_hour
, &tm_min
, &tm_sec
, &tm_year
) == 7) {
1261 tm
->tm_mday
= (int)tm_mday
;
1262 tm
->tm_year
= (int)tm_year
;
1263 tm
->tm_hour
= (int)tm_hour
;
1264 tm
->tm_min
= (int)tm_min
;
1265 tm
->tm_sec
= (int)tm_sec
;
1268 /* Okay, now decode the month. */
1269 for (i
= 0; i
< 12; ++i
) {
1270 if (!strcasecmp(MONTH_NAMES
[i
], month
)) {
1275 if (tm
->tm_year
< 0 ||
1276 tm
->tm_mon
< 1 || tm
->tm_mon
> 12 ||
1277 tm
->tm_mday
< 0 || tm
->tm_mday
> 31 ||
1278 tm
->tm_hour
< 0 || tm
->tm_hour
> 23 ||
1279 tm
->tm_min
< 0 || tm
->tm_min
> 59 ||
1280 tm
->tm_sec
< 0 || tm
->tm_sec
> 61)
1281 return -1; /* Out of range, or bad month. */
1286 /** Given an <b>interval</b> in seconds, try to write it to the
1287 * <b>out_len</b>-byte buffer in <b>out</b> in a human-readable form.
1288 * Return 0 on success, -1 on failure.
1291 format_time_interval(char *out
, size_t out_len
, long interval
)
1293 /* We only report seconds if there's no hours. */
1294 long sec
= 0, min
= 0, hour
= 0, day
= 0;
1296 interval
= -interval
;
1298 if (interval
>= 86400) {
1299 day
= interval
/ 86400;
1302 if (interval
>= 3600) {
1303 hour
= interval
/ 3600;
1306 if (interval
>= 60) {
1307 min
= interval
/ 60;
1313 return tor_snprintf(out
, out_len
, "%ld days, %ld hours, %ld minutes",
1316 return tor_snprintf(out
, out_len
, "%ld hours, %ld minutes", hour
, min
);
1318 return tor_snprintf(out
, out_len
, "%ld minutes, %ld seconds", min
, sec
);
1320 return tor_snprintf(out
, out_len
, "%ld seconds", sec
);
1328 #ifndef TIME_IS_FAST
1329 /** Cached estimate of the current time. Updated around once per second;
1330 * may be a few seconds off if we are really busy. This is a hack to avoid
1331 * calling time(NULL) (which not everybody has optimized) on critical paths.
1333 static time_t cached_approx_time
= 0;
1335 /** Return a cached estimate of the current time from when
1336 * update_approx_time() was last called. This is a hack to avoid calling
1337 * time(NULL) on critical paths: please do not even think of calling it
1342 return cached_approx_time
;
1345 /** Update the cached estimate of the current time. This function SHOULD be
1346 * called once per second, and MUST be called before the first call to
1347 * get_approx_time. */
1349 update_approx_time(time_t now
)
1351 cached_approx_time
= now
;
1357 * XXXX022 Use this consistently or rip most of it out.
1360 /* In a perfect world, everybody would run NTP, and NTP would be perfect, so
1361 * if we wanted to know "Is the current time before time X?" we could just say
1364 * But unfortunately, many users are running Tor in an imperfect world, on
1365 * even more imperfect computers. Hence, we need to track time oddly. We
1366 * model the user's computer as being "skewed" from accurate time by
1367 * -<b>ftime_skew</b> seconds, such that our best guess of the current time is
1368 * time(NULL)+ftime_skew. We also assume that our measurements of time may
1369 * have up to <b>ftime_slop</b> seconds of inaccuracy; IOW, our window of
1370 * estimate for the current time is now + ftime_skew +/- ftime_slop.
1372 /** Our current estimate of our skew, such that we think the current time is
1373 * closest to time(NULL)+ftime_skew. */
1374 static int ftime_skew
= 0;
1375 /** Tolerance during time comparisons, in seconds. */
1376 static int ftime_slop
= 60;
1377 /** Set the largest amount of sloppiness we'll allow in fuzzy time
1380 ftime_set_maximum_sloppiness(int seconds
)
1382 tor_assert(seconds
>= 0);
1383 ftime_slop
= seconds
;
1385 /** Set the amount by which we believe our system clock to differ from
1388 ftime_set_estimated_skew(int seconds
)
1390 ftime_skew
= seconds
;
1394 ftime_get_window(time_t now
, ftime_t
*ft_out
)
1396 ft_out
->earliest
= now
+ ftime_skew
- ftime_slop
;
1397 ft_out
->latest
= now
+ ftime_skew
+ ftime_slop
;
1400 /** Return true iff we think that <b>now</b> might be after <b>when</b>. */
1402 ftime_maybe_after(time_t now
, time_t when
)
1404 /* It may be after when iff the latest possible current time is after when */
1405 return (now
+ ftime_skew
+ ftime_slop
) >= when
;
1407 /** Return true iff we think that <b>now</b> might be before <b>when</b>. */
1409 ftime_maybe_before(time_t now
, time_t when
)
1411 /* It may be before when iff the earliest possible current time is before */
1412 return (now
+ ftime_skew
- ftime_slop
) < when
;
1414 /** Return true if we think that <b>now</b> is definitely after <b>when</b>. */
1416 ftime_definitely_after(time_t now
, time_t when
)
1418 /* It is definitely after when if the earliest time it could be is still
1420 return (now
+ ftime_skew
- ftime_slop
) >= when
;
1422 /** Return true if we think that <b>now</b> is definitely before <b>when</b>.
1425 ftime_definitely_before(time_t now
, time_t when
)
1427 /* It is definitely before when if the latest time it could be is still
1429 return (now
+ ftime_skew
+ ftime_slop
) < when
;
1436 /** Write <b>count</b> bytes from <b>buf</b> to <b>fd</b>. <b>isSocket</b>
1437 * must be 1 if fd was returned by socket() or accept(), and 0 if fd
1438 * was returned by open(). Return the number of bytes written, or -1
1439 * on error. Only use if fd is a blocking fd. */
1441 write_all(int fd
, const char *buf
, size_t count
, int isSocket
)
1445 tor_assert(count
< SSIZE_T_MAX
);
1447 while (written
!= count
) {
1449 result
= tor_socket_send(fd
, buf
+written
, count
-written
, 0);
1451 result
= write(fd
, buf
+written
, count
-written
);
1456 return (ssize_t
)count
;
1459 /** Read from <b>fd</b> to <b>buf</b>, until we get <b>count</b> bytes
1460 * or reach the end of the file. <b>isSocket</b> must be 1 if fd
1461 * was returned by socket() or accept(), and 0 if fd was returned by
1462 * open(). Return the number of bytes read, or -1 on error. Only use
1463 * if fd is a blocking fd. */
1465 read_all(int fd
, char *buf
, size_t count
, int isSocket
)
1470 if (count
> SIZE_T_CEILING
|| count
> SSIZE_T_MAX
)
1473 while (numread
!= count
) {
1475 result
= tor_socket_recv(fd
, buf
+numread
, count
-numread
, 0);
1477 result
= read(fd
, buf
+numread
, count
-numread
);
1480 else if (result
== 0)
1484 return (ssize_t
)numread
;
1488 * Filesystem operations.
1491 /** Clean up <b>name</b> so that we can use it in a call to "stat". On Unix,
1492 * we do nothing. On Windows, we remove a trailing slash, unless the path is
1493 * the root of a disk. */
1495 clean_name_for_stat(char *name
)
1498 size_t len
= strlen(name
);
1501 if (name
[len
-1]=='\\' || name
[len
-1]=='/') {
1502 if (len
== 1 || (len
==3 && name
[1]==':'))
1511 /** Return FN_ERROR if filename can't be read, FN_NOENT if it doesn't
1512 * exist, FN_FILE if it is a regular file, or FN_DIR if it's a
1513 * directory. On FN_ERROR, sets errno. */
1515 file_status(const char *fname
)
1520 f
= tor_strdup(fname
);
1521 clean_name_for_stat(f
);
1525 if (errno
== ENOENT
) {
1530 if (st
.st_mode
& S_IFDIR
)
1532 else if (st
.st_mode
& S_IFREG
)
1538 /** Check whether dirname exists and is private. If yes return 0. If
1539 * it does not exist, and check==CPD_CREATE is set, try to create it
1540 * and return 0 on success. If it does not exist, and
1541 * check==CPD_CHECK, and we think we can create it, return 0. Else
1544 check_private_dir(const char *dirname
, cpd_check_t check
)
1549 tor_assert(dirname
);
1550 f
= tor_strdup(dirname
);
1551 clean_name_for_stat(f
);
1555 if (errno
!= ENOENT
) {
1556 log(LOG_WARN
, LD_FS
, "Directory %s cannot be read: %s", dirname
,
1560 if (check
== CPD_NONE
) {
1561 log(LOG_WARN
, LD_FS
, "Directory %s does not exist.", dirname
);
1563 } else if (check
== CPD_CREATE
) {
1564 log_info(LD_GENERAL
, "Creating directory %s", dirname
);
1568 r
= mkdir(dirname
, 0700);
1571 log(LOG_WARN
, LD_FS
, "Error creating directory %s: %s", dirname
,
1576 /* XXXX In the case where check==CPD_CHECK, we should look at the
1577 * parent directory a little harder. */
1580 if (!(st
.st_mode
& S_IFDIR
)) {
1581 log(LOG_WARN
, LD_FS
, "%s is not a directory", dirname
);
1585 if (st
.st_uid
!= getuid()) {
1586 struct passwd
*pw
= NULL
;
1587 char *process_ownername
= NULL
;
1589 pw
= getpwuid(getuid());
1590 process_ownername
= pw
? tor_strdup(pw
->pw_name
) : tor_strdup("<unknown>");
1592 pw
= getpwuid(st
.st_uid
);
1594 log(LOG_WARN
, LD_FS
, "%s is not owned by this user (%s, %d) but by "
1595 "%s (%d). Perhaps you are running Tor as the wrong user?",
1596 dirname
, process_ownername
, (int)getuid(),
1597 pw
? pw
->pw_name
: "<unknown>", (int)st
.st_uid
);
1599 tor_free(process_ownername
);
1602 if (st
.st_mode
& 0077) {
1603 log(LOG_WARN
, LD_FS
, "Fixing permissions on directory %s", dirname
);
1604 if (chmod(dirname
, 0700)) {
1605 log(LOG_WARN
, LD_FS
, "Could not chmod directory %s: %s", dirname
,
1616 /** Create a file named <b>fname</b> with the contents <b>str</b>. Overwrite
1617 * the previous <b>fname</b> if possible. Return 0 on success, -1 on failure.
1619 * This function replaces the old file atomically, if possible. This
1620 * function, and all other functions in util.c that create files, create them
1624 write_str_to_file(const char *fname
, const char *str
, int bin
)
1627 if (!bin
&& strchr(str
, '\r')) {
1629 "We're writing a text string that already contains a CR.");
1632 return write_bytes_to_file(fname
, str
, strlen(str
), bin
);
1635 /** Represents a file that we're writing to, with support for atomic commit:
1636 * we can write into a a temporary file, and either remove the file on
1637 * failure, or replace the original file on success. */
1638 struct open_file_t
{
1639 char *tempname
; /**< Name of the temporary file. */
1640 char *filename
; /**< Name of the original file. */
1641 int rename_on_close
; /**< Are we using the temporary file or not? */
1642 int fd
; /**< fd for the open file. */
1643 FILE *stdio_file
; /**< stdio wrapper for <b>fd</b>. */
1646 /** Try to start writing to the file in <b>fname</b>, passing the flags
1647 * <b>open_flags</b> to the open() syscall, creating the file (if needed) with
1648 * access value <b>mode</b>. If the O_APPEND flag is set, we append to the
1649 * original file. Otherwise, we open a new temporary file in the same
1650 * directory, and either replace the original or remove the temporary file
1653 * Return the fd for the newly opened file, and store working data in
1654 * *<b>data_out</b>. The caller should not close the fd manually:
1655 * instead, call finish_writing_to_file() or abort_writing_to_file().
1656 * Returns -1 on failure.
1658 * NOTE: When not appending, the flags O_CREAT and O_TRUNC are treated
1659 * as true and the flag O_EXCL is treated as false.
1661 * NOTE: Ordinarily, O_APPEND means "seek to the end of the file before each
1662 * write()". We don't do that.
1665 start_writing_to_file(const char *fname
, int open_flags
, int mode
,
1666 open_file_t
**data_out
)
1668 size_t tempname_len
= strlen(fname
)+16;
1669 open_file_t
*new_file
= tor_malloc_zero(sizeof(open_file_t
));
1670 const char *open_name
;
1674 tor_assert(data_out
);
1675 #if (O_BINARY != 0 && O_TEXT != 0)
1676 tor_assert((open_flags
& (O_BINARY
|O_TEXT
)) != 0);
1679 tor_assert(tempname_len
> strlen(fname
)); /*check for overflow*/
1680 new_file
->filename
= tor_strdup(fname
);
1681 if (open_flags
& O_APPEND
) {
1683 new_file
->rename_on_close
= 0;
1685 open_flags
&= ~O_APPEND
;
1687 open_name
= new_file
->tempname
= tor_malloc(tempname_len
);
1688 if (tor_snprintf(new_file
->tempname
, tempname_len
, "%s.tmp", fname
)<0) {
1689 log(LOG_WARN
, LD_GENERAL
, "Failed to generate filename");
1692 /* We always replace an existing temporary file if there is one. */
1693 open_flags
|= O_CREAT
|O_TRUNC
;
1694 open_flags
&= ~O_EXCL
;
1695 new_file
->rename_on_close
= 1;
1698 if ((new_file
->fd
= open(open_name
, open_flags
, mode
)) < 0) {
1699 log(LOG_WARN
, LD_FS
, "Couldn't open \"%s\" (%s) for writing: %s",
1700 open_name
, fname
, strerror(errno
));
1704 if (tor_fd_seekend(new_file
->fd
) < 0) {
1705 log_warn(LD_FS
, "Couldn't seek to end of file \"%s\": %s", open_name
,
1711 *data_out
= new_file
;
1713 return new_file
->fd
;
1716 if (new_file
->fd
>= 0)
1717 close(new_file
->fd
);
1719 tor_free(new_file
->filename
);
1720 tor_free(new_file
->tempname
);
1725 /** Given <b>file_data</b> from start_writing_to_file(), return a stdio FILE*
1726 * that can be used to write to the same file. The caller should not mix
1727 * stdio calls with non-stdio calls. */
1729 fdopen_file(open_file_t
*file_data
)
1731 tor_assert(file_data
);
1732 if (file_data
->stdio_file
)
1733 return file_data
->stdio_file
;
1734 tor_assert(file_data
->fd
>= 0);
1735 if (!(file_data
->stdio_file
= fdopen(file_data
->fd
, "a"))) {
1736 log_warn(LD_FS
, "Couldn't fdopen \"%s\" [%d]: %s", file_data
->filename
,
1737 file_data
->fd
, strerror(errno
));
1739 return file_data
->stdio_file
;
1742 /** Combines start_writing_to_file with fdopen_file(): arguments are as
1743 * for start_writing_to_file, but */
1745 start_writing_to_stdio_file(const char *fname
, int open_flags
, int mode
,
1746 open_file_t
**data_out
)
1749 if (start_writing_to_file(fname
, open_flags
, mode
, data_out
)<0)
1751 if (!(res
= fdopen_file(*data_out
))) {
1752 abort_writing_to_file(*data_out
);
1758 /** Helper function: close and free the underlying file and memory in
1759 * <b>file_data</b>. If we were writing into a temporary file, then delete
1760 * that file (if abort_write is true) or replaces the target file with
1761 * the temporary file (if abort_write is false). */
1763 finish_writing_to_file_impl(open_file_t
*file_data
, int abort_write
)
1766 tor_assert(file_data
&& file_data
->filename
);
1767 if (file_data
->stdio_file
) {
1768 if (fclose(file_data
->stdio_file
)) {
1769 log_warn(LD_FS
, "Error closing \"%s\": %s", file_data
->filename
,
1771 abort_write
= r
= -1;
1773 } else if (file_data
->fd
>= 0 && close(file_data
->fd
) < 0) {
1774 log_warn(LD_FS
, "Error flushing \"%s\": %s", file_data
->filename
,
1776 abort_write
= r
= -1;
1779 if (file_data
->rename_on_close
) {
1780 tor_assert(file_data
->tempname
&& file_data
->filename
);
1782 unlink(file_data
->tempname
);
1784 tor_assert(strcmp(file_data
->filename
, file_data
->tempname
));
1785 if (replace_file(file_data
->tempname
, file_data
->filename
)) {
1786 log_warn(LD_FS
, "Error replacing \"%s\": %s", file_data
->filename
,
1793 tor_free(file_data
->filename
);
1794 tor_free(file_data
->tempname
);
1795 tor_free(file_data
);
1800 /** Finish writing to <b>file_data</b>: close the file handle, free memory as
1801 * needed, and if using a temporary file, replace the original file with
1802 * the temporary file. */
1804 finish_writing_to_file(open_file_t
*file_data
)
1806 return finish_writing_to_file_impl(file_data
, 0);
1809 /** Finish writing to <b>file_data</b>: close the file handle, free memory as
1810 * needed, and if using a temporary file, delete it. */
1812 abort_writing_to_file(open_file_t
*file_data
)
1814 return finish_writing_to_file_impl(file_data
, 1);
1817 /** Helper: given a set of flags as passed to open(2), open the file
1818 * <b>fname</b> and write all the sized_chunk_t structs in <b>chunks</b> to
1819 * the file. Do so as atomically as possible e.g. by opening temp files and
1822 write_chunks_to_file_impl(const char *fname
, const smartlist_t
*chunks
,
1825 open_file_t
*file
= NULL
;
1828 fd
= start_writing_to_file(fname
, open_flags
, 0600, &file
);
1831 SMARTLIST_FOREACH(chunks
, sized_chunk_t
*, chunk
,
1833 result
= write_all(fd
, chunk
->bytes
, chunk
->len
, 0);
1835 log(LOG_WARN
, LD_FS
, "Error writing to \"%s\": %s", fname
,
1839 tor_assert((size_t)result
== chunk
->len
);
1842 return finish_writing_to_file(file
);
1844 abort_writing_to_file(file
);
1848 /** Given a smartlist of sized_chunk_t, write them atomically to a file
1849 * <b>fname</b>, overwriting or creating the file as necessary. */
1851 write_chunks_to_file(const char *fname
, const smartlist_t
*chunks
, int bin
)
1853 int flags
= OPEN_FLAGS_REPLACE
|(bin
?O_BINARY
:O_TEXT
);
1854 return write_chunks_to_file_impl(fname
, chunks
, flags
);
1857 /** As write_str_to_file, but does not assume a NUL-terminated
1858 * string. Instead, we write <b>len</b> bytes, starting at <b>str</b>. */
1860 write_bytes_to_file(const char *fname
, const char *str
, size_t len
,
1863 int flags
= OPEN_FLAGS_REPLACE
|(bin
?O_BINARY
:O_TEXT
);
1865 sized_chunk_t c
= { str
, len
};
1866 smartlist_t
*chunks
= smartlist_create();
1867 smartlist_add(chunks
, &c
);
1868 r
= write_chunks_to_file_impl(fname
, chunks
, flags
);
1869 smartlist_free(chunks
);
1873 /** As write_bytes_to_file, but if the file already exists, append the bytes
1874 * to the end of the file instead of overwriting it. */
1876 append_bytes_to_file(const char *fname
, const char *str
, size_t len
,
1879 int flags
= OPEN_FLAGS_APPEND
|(bin
?O_BINARY
:O_TEXT
);
1881 sized_chunk_t c
= { str
, len
};
1882 smartlist_t
*chunks
= smartlist_create();
1883 smartlist_add(chunks
, &c
);
1884 r
= write_chunks_to_file_impl(fname
, chunks
, flags
);
1885 smartlist_free(chunks
);
1889 /** Read the contents of <b>filename</b> into a newly allocated
1890 * string; return the string on success or NULL on failure.
1892 * If <b>stat_out</b> is provided, store the result of stat()ing the
1893 * file into <b>stat_out</b>.
1895 * If <b>flags</b> & RFTS_BIN, open the file in binary mode.
1896 * If <b>flags</b> & RFTS_IGNORE_MISSING, don't warn if the file
1900 * This function <em>may</em> return an erroneous result if the file
1901 * is modified while it is running, but must not crash or overflow.
1902 * Right now, the error case occurs when the file length grows between
1903 * the call to stat and the call to read_all: the resulting string will
1907 read_file_to_str(const char *filename
, int flags
, struct stat
*stat_out
)
1909 int fd
; /* router file */
1910 struct stat statbuf
;
1913 int bin
= flags
& RFTS_BIN
;
1915 tor_assert(filename
);
1917 fd
= open(filename
,O_RDONLY
|(bin
?O_BINARY
:O_TEXT
),0);
1919 int severity
= LOG_WARN
;
1920 int save_errno
= errno
;
1921 if (errno
== ENOENT
&& (flags
& RFTS_IGNORE_MISSING
))
1922 severity
= LOG_INFO
;
1923 log_fn(severity
, LD_FS
,"Could not open \"%s\": %s ",filename
,
1929 if (fstat(fd
, &statbuf
)<0) {
1930 int save_errno
= errno
;
1932 log_warn(LD_FS
,"Could not fstat \"%s\".",filename
);
1937 if ((uint64_t)(statbuf
.st_size
)+1 > SIZE_T_CEILING
)
1940 string
= tor_malloc((size_t)(statbuf
.st_size
+1));
1942 r
= read_all(fd
,string
,(size_t)statbuf
.st_size
,0);
1944 int save_errno
= errno
;
1945 log_warn(LD_FS
,"Error reading from file \"%s\": %s", filename
,
1952 string
[r
] = '\0'; /* NUL-terminate the result. */
1955 if (!bin
&& strchr(string
, '\r')) {
1956 log_debug(LD_FS
, "We didn't convert CRLF to LF as well as we hoped "
1957 "when reading %s. Coping.",
1959 tor_strstrip(string
, "\r");
1963 statbuf
.st_size
= (size_t) r
;
1966 if (r
!= statbuf
.st_size
) {
1967 /* Unless we're using text mode on win32, we'd better have an exact
1968 * match for size. */
1969 int save_errno
= errno
;
1970 log_warn(LD_FS
,"Could read only %d of %ld bytes of file \"%s\".",
1971 (int)r
, (long)statbuf
.st_size
,filename
);
1979 memcpy(stat_out
, &statbuf
, sizeof(struct stat
));
1985 #define TOR_ISODIGIT(c) ('0' <= (c) && (c) <= '7')
1987 /** Given a c-style double-quoted escaped string in <b>s</b>, extract and
1988 * decode its contents into a newly allocated string. On success, assign this
1989 * string to *<b>result</b>, assign its length to <b>size_out</b> (if
1990 * provided), and return a pointer to the position in <b>s</b> immediately
1991 * after the string. On failure, return NULL.
1994 unescape_string(const char *s
, char **result
, size_t *size_out
)
2009 if ((cp
[1] == 'x' || cp
[1] == 'X')
2010 && TOR_ISXDIGIT(cp
[2]) && TOR_ISXDIGIT(cp
[3])) {
2012 } else if (TOR_ISODIGIT(cp
[1])) {
2014 if (TOR_ISODIGIT(*cp
)) ++cp
;
2015 if (TOR_ISODIGIT(*cp
)) ++cp
;
2028 out
= *result
= tor_malloc(cp
-s
+ 1);
2035 if (size_out
) *size_out
= out
- *result
;
2038 tor_fragile_assert();
2044 case 'n': *out
++ = '\n'; cp
+= 2; break;
2045 case 'r': *out
++ = '\r'; cp
+= 2; break;
2046 case 't': *out
++ = '\t'; cp
+= 2; break;
2048 *out
++ = ((hex_decode_digit(cp
[2])<<4) +
2049 hex_decode_digit(cp
[3]));
2052 case '0': case '1': case '2': case '3': case '4': case '5':
2057 if (TOR_ISODIGIT(*cp
)) { n
= n
*8 + *cp
-'0'; cp
++; }
2058 if (TOR_ISODIGIT(*cp
)) { n
= n
*8 + *cp
-'0'; cp
++; }
2059 if (n
> 255) { tor_free(*result
); return NULL
; }
2071 tor_free(*result
); return NULL
;
2080 /** Given a string containing part of a configuration file or similar format,
2081 * advance past comments and whitespace and try to parse a single line. If we
2082 * parse a line successfully, set *<b>key_out</b> to a new string holding the
2083 * key portion and *<b>value_out</b> to a new string holding the value portion
2084 * of the line, and return a pointer to the start of the next line. If we run
2085 * out of data, return a pointer to the end of the string. If we encounter an
2086 * error, return NULL.
2089 parse_config_line_from_str(const char *line
, char **key_out
, char **value_out
)
2091 const char *key
, *val
, *cp
;
2093 tor_assert(key_out
);
2094 tor_assert(value_out
);
2096 *key_out
= *value_out
= NULL
;
2098 /* Skip until the first keyword. */
2100 while (TOR_ISSPACE(*line
))
2103 while (*line
&& *line
!= '\n')
2110 if (!*line
) { /* End of string? */
2111 *key_out
= *value_out
= NULL
;
2115 /* Skip until the next space. */
2117 while (*line
&& !TOR_ISSPACE(*line
) && *line
!= '#')
2119 *key_out
= tor_strndup(key
, line
-key
);
2121 /* Skip until the value. */
2122 while (*line
== ' ' || *line
== '\t')
2127 /* Find the end of the line. */
2128 if (*line
== '\"') {
2129 if (!(line
= unescape_string(line
, value_out
, NULL
)))
2131 while (*line
== ' ' || *line
== '\t')
2133 if (*line
&& *line
!= '#' && *line
!= '\n')
2136 while (*line
&& *line
!= '\n' && *line
!= '#')
2138 if (*line
== '\n') {
2143 while (cp
>val
&& TOR_ISSPACE(*(cp
-1)))
2146 tor_assert(cp
>= val
);
2147 *value_out
= tor_strndup(val
, cp
-val
);
2153 } while (*line
&& *line
!= '\n');
2155 while (TOR_ISSPACE(*line
)) ++line
;
2160 /** Expand any homedir prefix on <b>filename</b>; return a newly allocated
2163 expand_filename(const char *filename
)
2165 tor_assert(filename
);
2166 if (*filename
== '~') {
2168 char *home
, *result
;
2171 if (filename
[1] == '/' || filename
[1] == '\0') {
2172 home
= getenv("HOME");
2174 log_warn(LD_CONFIG
, "Couldn't find $HOME environment variable while "
2175 "expanding \"%s\"", filename
);
2178 home
= tor_strdup(home
);
2179 rest
= strlen(filename
)>=2?(filename
+2):"";
2182 char *username
, *slash
;
2183 slash
= strchr(filename
, '/');
2185 username
= tor_strndup(filename
+1,slash
-filename
-1);
2187 username
= tor_strdup(filename
+1);
2188 if (!(home
= get_user_homedir(username
))) {
2189 log_warn(LD_CONFIG
,"Couldn't get homedir for \"%s\"",username
);
2194 rest
= slash
? (slash
+1) : "";
2196 log_warn(LD_CONFIG
, "Couldn't expend homedir on system without pwd.h");
2197 return tor_strdup(filename
);
2201 /* Remove trailing slash. */
2202 if (strlen(home
)>1 && !strcmpend(home
,PATH_SEPARATOR
)) {
2203 home
[strlen(home
)-1] = '\0';
2205 /* Plus one for /, plus one for NUL.
2206 * Round up to 16 in case we can't do math. */
2207 len
= strlen(home
)+strlen(rest
)+16;
2208 result
= tor_malloc(len
);
2209 tor_snprintf(result
,len
,"%s"PATH_SEPARATOR
"%s",home
,rest
);
2213 return tor_strdup(filename
);
2217 #define MAX_SCANF_WIDTH 9999
2221 digit_to_num(char d
)
2223 int num
= ((int)d
) - (int)'0';
2224 tor_assert(num
<= 9 && num
>= 0);
2230 scan_unsigned(const char **bufp
, unsigned *out
, int width
)
2232 unsigned result
= 0;
2233 int scanned_so_far
= 0;
2234 if (!bufp
|| !*bufp
|| !out
)
2237 width
=MAX_SCANF_WIDTH
;
2239 while (**bufp
&& TOR_ISDIGIT(**bufp
) && scanned_so_far
< width
) {
2240 int digit
= digit_to_num(*(*bufp
)++);
2241 unsigned new_result
= result
* 10 + digit
;
2242 if (new_result
> UINT32_MAX
|| new_result
< result
)
2243 return -1; /* over/underflow. */
2244 result
= new_result
;
2248 if (!scanned_so_far
) /* No actual digits scanned */
2257 scan_string(const char **bufp
, char *out
, int width
)
2259 int scanned_so_far
= 0;
2260 if (!bufp
|| !out
|| width
< 0)
2262 while (**bufp
&& ! TOR_ISSPACE(**bufp
) && scanned_so_far
< width
) {
2263 *out
++ = *(*bufp
)++;
2270 /** Locale-independent, minimal, no-surprises scanf variant, accepting only a
2271 * restricted pattern format. For more info on what it supports, see
2272 * tor_sscanf() documentation. */
2274 tor_vsscanf(const char *buf
, const char *pattern
, va_list ap
)
2279 if (*pattern
!= '%') {
2280 if (*buf
== *pattern
) {
2290 if (TOR_ISDIGIT(*pattern
)) {
2291 width
= digit_to_num(*pattern
++);
2292 while (TOR_ISDIGIT(*pattern
)) {
2294 width
+= digit_to_num(*pattern
++);
2295 if (width
> MAX_SCANF_WIDTH
)
2298 if (!width
) /* No zero-width things. */
2301 if (*pattern
== 'u') {
2302 unsigned *u
= va_arg(ap
, unsigned *);
2305 if (scan_unsigned(&buf
, u
, width
)<0)
2309 } else if (*pattern
== 's') {
2310 char *s
= va_arg(ap
, char *);
2313 if (scan_string(&buf
, s
, width
)<0)
2317 } else if (*pattern
== 'c') {
2318 char *ch
= va_arg(ap
, char *);
2326 } else if (*pattern
== '%') {
2332 return -1; /* Unrecognized pattern component. */
2340 /** Minimal sscanf replacement: parse <b>buf</b> according to <b>pattern</b>
2341 * and store the results in the corresponding argument fields. Differs from
2342 * sscanf in that it: Only handles %u and %Ns. Does not handle arbitrarily
2343 * long widths. %u does not consume any space. Is locale-independent.
2344 * Returns -1 on malformed patterns. */
2346 tor_sscanf(const char *buf
, const char *pattern
, ...)
2350 va_start(ap
, pattern
);
2351 r
= tor_vsscanf(buf
, pattern
, ap
);
2356 /** Return a new list containing the filenames in the directory <b>dirname</b>.
2357 * Return NULL on error or if <b>dirname</b> is not a directory.
2360 tor_listdir(const char *dirname
)
2362 smartlist_t
*result
;
2366 WIN32_FIND_DATA findData
;
2367 size_t pattern_len
= strlen(dirname
)+16;
2368 pattern
= tor_malloc(pattern_len
);
2369 tor_snprintf(pattern
, pattern_len
, "%s\\*", dirname
);
2370 if (INVALID_HANDLE_VALUE
== (handle
= FindFirstFile(pattern
, &findData
))) {
2374 result
= smartlist_create();
2376 if (strcmp(findData
.cFileName
, ".") &&
2377 strcmp(findData
.cFileName
, "..")) {
2378 smartlist_add(result
, tor_strdup(findData
.cFileName
));
2380 if (!FindNextFile(handle
, &findData
)) {
2382 if ((err
= GetLastError()) != ERROR_NO_MORE_FILES
) {
2383 char *errstr
= format_win32_error(err
);
2384 log_warn(LD_FS
, "Error reading directory '%s': %s", dirname
, errstr
);
2395 if (!(d
= opendir(dirname
)))
2398 result
= smartlist_create();
2399 while ((de
= readdir(d
))) {
2400 if (!strcmp(de
->d_name
, ".") ||
2401 !strcmp(de
->d_name
, ".."))
2403 smartlist_add(result
, tor_strdup(de
->d_name
));
2410 /** Return true iff <b>filename</b> is a relative path. */
2412 path_is_relative(const char *filename
)
2414 if (filename
&& filename
[0] == '/')
2417 else if (filename
&& filename
[0] == '\\')
2419 else if (filename
&& strlen(filename
)>3 && TOR_ISALPHA(filename
[0]) &&
2420 filename
[1] == ':' && filename
[2] == '\\')
2432 /* Based on code contributed by christian grothoff */
2433 /** True iff we've called start_daemon(). */
2434 static int start_daemon_called
= 0;
2435 /** True iff we've called finish_daemon(). */
2436 static int finish_daemon_called
= 0;
2437 /** Socketpair used to communicate between parent and child process while
2439 static int daemon_filedes
[2];
2440 /** Start putting the process into daemon mode: fork and drop all resources
2441 * except standard fds. The parent process never returns, but stays around
2442 * until finish_daemon is called. (Note: it's safe to call this more
2443 * than once: calls after the first are ignored.)
2450 if (start_daemon_called
)
2452 start_daemon_called
= 1;
2454 if (pipe(daemon_filedes
)) {
2455 log_err(LD_GENERAL
,"pipe failed; exiting. Error was %s", strerror(errno
));
2460 log_err(LD_GENERAL
,"fork failed. Exiting.");
2463 if (pid
) { /* Parent */
2467 close(daemon_filedes
[1]); /* we only read */
2469 while (0 < read(daemon_filedes
[0], &c
, sizeof(char))) {
2477 exit(1); /* child reported error */
2478 } else { /* Child */
2479 close(daemon_filedes
[0]); /* we only write */
2481 pid
= setsid(); /* Detach from controlling terminal */
2483 * Fork one more time, so the parent (the session group leader) can exit.
2484 * This means that we, as a non-session group leader, can never regain a
2485 * controlling terminal. This part is recommended by Stevens's
2486 * _Advanced Programming in the Unix Environment_.
2491 set_main_thread(); /* We are now the main thread. */
2497 /** Finish putting the process into daemon mode: drop standard fds, and tell
2498 * the parent process to exit. (Note: it's safe to call this more than once:
2499 * calls after the first are ignored. Calls start_daemon first if it hasn't
2500 * been called already.)
2503 finish_daemon(const char *desired_cwd
)
2507 if (finish_daemon_called
)
2509 if (!start_daemon_called
)
2511 finish_daemon_called
= 1;
2515 /* Don't hold the wrong FS mounted */
2516 if (chdir(desired_cwd
) < 0) {
2517 log_err(LD_GENERAL
,"chdir to \"%s\" failed. Exiting.",desired_cwd
);
2521 nullfd
= open("/dev/null", O_RDWR
);
2523 log_err(LD_GENERAL
,"/dev/null can't be opened. Exiting.");
2526 /* close fds linking to invoking terminal, but
2527 * close usual incoming fds, but redirect them somewhere
2528 * useful so the fds don't get reallocated elsewhere.
2530 if (dup2(nullfd
,0) < 0 ||
2531 dup2(nullfd
,1) < 0 ||
2532 dup2(nullfd
,2) < 0) {
2533 log_err(LD_GENERAL
,"dup2 failed. Exiting.");
2538 /* signal success */
2539 if (write(daemon_filedes
[1], &c
, sizeof(char)) != sizeof(char)) {
2540 log_err(LD_GENERAL
,"write failed. Exiting.");
2542 close(daemon_filedes
[1]);
2545 /* defined(MS_WINDOWS) */
2551 finish_daemon(const char *cp
)
2557 /** Write the current process ID, followed by NL, into <b>filename</b>.
2560 write_pidfile(char *filename
)
2564 if ((pidfile
= fopen(filename
, "w")) == NULL
) {
2565 log_warn(LD_FS
, "Unable to open \"%s\" for writing: %s", filename
,
2569 fprintf(pidfile
, "%d\n", (int)_getpid());
2571 fprintf(pidfile
, "%d\n", (int)getpid());