|
|
@@ -2,6 +2,11 @@
|
|
|
/* See LICENSE for licensing information */
|
|
|
/* $Id$ */
|
|
|
|
|
|
+/*****
|
|
|
+ * util.c: Common functions for strings, IO, network, data structures,
|
|
|
+ * process control, and cross-platform portability.
|
|
|
+ *****/
|
|
|
+
|
|
|
#include "orconfig.h"
|
|
|
|
|
|
#ifdef MS_WINDOWS
|
|
|
@@ -86,7 +91,7 @@
|
|
|
#define INADDR_NONE ((unsigned long) -1)
|
|
|
#endif
|
|
|
|
|
|
-/* in-line the strl functions */
|
|
|
+/* Inline the strl functions if the plaform doesn't have them. */
|
|
|
#ifndef HAVE_STRLCPY
|
|
|
#include "strlcpy.c"
|
|
|
#endif
|
|
|
@@ -94,10 +99,14 @@
|
|
|
#include "strlcat.c"
|
|
|
#endif
|
|
|
|
|
|
-/*
|
|
|
+/*****
|
|
|
* Memory wrappers
|
|
|
- */
|
|
|
+ *****/
|
|
|
|
|
|
+/* Allocate a chunk of 'size' bytes of memory, and return a pointer to
|
|
|
+ * result. On error, log and terminate the process. (Same as malloc(size),
|
|
|
+ * but never returns NULL.)
|
|
|
+ */
|
|
|
void *tor_malloc(size_t size) {
|
|
|
void *result;
|
|
|
|
|
|
@@ -115,12 +124,20 @@ void *tor_malloc(size_t size) {
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
+/* Allocate a chunk of 'size' bytes of memory, fill the memory with
|
|
|
+ * zero bytes, and return a pointer to the result. Log and terminate
|
|
|
+ * the process on error. (Same as calloc(size,1), but never returns NULL.)
|
|
|
+ */
|
|
|
void *tor_malloc_zero(size_t size) {
|
|
|
void *result = tor_malloc(size);
|
|
|
memset(result, 0, size);
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
+/* Change the size of the memory block pointed to by 'ptr' to 'size'
|
|
|
+ * bytes long; return the new memory block. On error, log and
|
|
|
+ * terminate. (Like realloc(ptr,size), but never returns NULL.)
|
|
|
+ */
|
|
|
void *tor_realloc(void *ptr, size_t size) {
|
|
|
void *result;
|
|
|
|
|
|
@@ -132,6 +149,10 @@ void *tor_realloc(void *ptr, size_t size) {
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
+/* Return a newly allocated copy of the NUL-terminated string s. On
|
|
|
+ * error, log and terminate. (Like strdup(s), but never returns
|
|
|
+ * NULL.)
|
|
|
+ */
|
|
|
char *tor_strdup(const char *s) {
|
|
|
char *dup;
|
|
|
tor_assert(s);
|
|
|
@@ -144,6 +165,11 @@ char *tor_strdup(const char *s) {
|
|
|
return dup;
|
|
|
}
|
|
|
|
|
|
+/* Allocate and return a new string containing the first 'n'
|
|
|
+ * characters of 's'. If 's' is longer than 'n' characters, only the
|
|
|
+ * first 'n' are copied. The result is always NUL-terminated. (Like
|
|
|
+ * strndup(s,n), but never returns NULL.)
|
|
|
+ */
|
|
|
char *tor_strndup(const char *s, size_t n) {
|
|
|
char *dup;
|
|
|
tor_assert(s);
|
|
|
@@ -153,7 +179,8 @@ char *tor_strndup(const char *s, size_t n) {
|
|
|
return dup;
|
|
|
}
|
|
|
|
|
|
-/* Convert s to lowercase. */
|
|
|
+/* Convert all alphabetic characters in the nul-terminated string 's' to
|
|
|
+ * lowercase. */
|
|
|
void tor_strlower(char *s)
|
|
|
{
|
|
|
while (*s) {
|
|
|
@@ -185,6 +212,10 @@ void set_uint32(char *cp, uint32_t v)
|
|
|
}
|
|
|
#endif
|
|
|
|
|
|
+/* Encode the first 'fromlen' bytes stored at 'from' in hexidecimal;
|
|
|
+ * write the result as a NUL-terminated string to 'to'. 'to' must
|
|
|
+ * have at least (2*fromlen)+1 bytes of free space.
|
|
|
+ */
|
|
|
void hex_encode(const char *from, int fromlen, char *to)
|
|
|
{
|
|
|
const unsigned char *fp = from;
|
|
|
@@ -198,6 +229,11 @@ void hex_encode(const char *from, int fromlen, char *to)
|
|
|
*to = '\0';
|
|
|
}
|
|
|
|
|
|
+/* Return a pointer to a NUL-terminated hexidecimal string encoding
|
|
|
+ * the first 'fromlen' bytes of 'from'. (fromlen must be <= 32.) The
|
|
|
+ * result does not need to be deallocated, but repeated calls to
|
|
|
+ * hex_str will trash old results.
|
|
|
+ */
|
|
|
const char *hex_str(const char *from, int fromlen)
|
|
|
{
|
|
|
static char buf[65];
|
|
|
@@ -207,21 +243,27 @@ const char *hex_str(const char *from, int fromlen)
|
|
|
return buf;
|
|
|
}
|
|
|
|
|
|
-/*
|
|
|
- * A simple smartlist interface to make an unordered list of acceptable
|
|
|
- * nodes and then choose a random one.
|
|
|
- * smartlist_create() mallocs the list, _free() frees the list,
|
|
|
- * _add() adds an element, _remove() removes an element if it's there,
|
|
|
- * _choose() returns a random element.
|
|
|
+/*****
|
|
|
+ * smartlist_t: a simple resizeable array abstraction.
|
|
|
+ *****/
|
|
|
+
|
|
|
+/* All newly allocated smartlists have this capacity.
|
|
|
*/
|
|
|
#define SMARTLIST_DEFAULT_CAPACITY 32
|
|
|
|
|
|
+
|
|
|
struct smartlist_t {
|
|
|
+ /* 'list' has enough capacity to store exactly 'capacity' elements
|
|
|
+ * before it needs to be resized. Only the first 'num_used' (<=
|
|
|
+ * capacity) elements point to valid data.
|
|
|
+ */
|
|
|
void **list;
|
|
|
int num_used;
|
|
|
int capacity;
|
|
|
};
|
|
|
|
|
|
+/* Allocate and return an empty smartlist.
|
|
|
+ */
|
|
|
smartlist_t *smartlist_create() {
|
|
|
smartlist_t *sl = tor_malloc(sizeof(smartlist_t));
|
|
|
sl->num_used = 0;
|
|
|
@@ -230,32 +272,46 @@ smartlist_t *smartlist_create() {
|
|
|
return sl;
|
|
|
}
|
|
|
|
|
|
+/* Deallocate a smartlist. Does not release storage associated with the
|
|
|
+ * list's elements.
|
|
|
+ */
|
|
|
void smartlist_free(smartlist_t *sl) {
|
|
|
free(sl->list);
|
|
|
free(sl);
|
|
|
}
|
|
|
|
|
|
+/* Change the capacity of the smartlist to 'n', so that we can grow
|
|
|
+ * the list upt to'n' elements with no further reallocation or wasted
|
|
|
+ * space. If 'n' is less than or equal to the number of elements
|
|
|
+ * currently in the list, reduces the list's capacity as much as
|
|
|
+ * possible without losing elements.
|
|
|
+ */
|
|
|
void smartlist_set_capacity(smartlist_t *sl, int n) {
|
|
|
- if (n<0)
|
|
|
+ if (n < sl->num_used)
|
|
|
n = sl->num_used;
|
|
|
- if (sl->capacity != n && sl->num_used < n) {
|
|
|
+ if (sl->capacity != n) {
|
|
|
sl->capacity = n;
|
|
|
sl->list = tor_realloc(sl->list, sizeof(void*)*sl->capacity);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-/* Remove all elements from the list. */
|
|
|
+/* Remove all elements from the list.
|
|
|
+ */
|
|
|
void smartlist_clear(smartlist_t *sl) {
|
|
|
sl->num_used = 0;
|
|
|
}
|
|
|
|
|
|
+/* Set the list's new length to 'len' (which must be <= the list's
|
|
|
+ * current size). Remove the last smartlist_len(sl)-len elements from the
|
|
|
+ * list.
|
|
|
+ */
|
|
|
void smartlist_truncate(smartlist_t *sl, int len)
|
|
|
{
|
|
|
tor_assert(len <= sl->num_used);
|
|
|
sl->num_used = len;
|
|
|
}
|
|
|
|
|
|
-/* add element to the list */
|
|
|
+/* Append element to the end of the list. */
|
|
|
void smartlist_add(smartlist_t *sl, void *element) {
|
|
|
if (sl->num_used >= sl->capacity) {
|
|
|
sl->capacity *= 2;
|
|
|
@@ -264,12 +320,15 @@ void smartlist_add(smartlist_t *sl, void *element) {
|
|
|
sl->list[sl->num_used++] = element;
|
|
|
}
|
|
|
|
|
|
-/* Add all elements from S2 to S1. */
|
|
|
+/* Append each elements from S2 to the end of S1. */
|
|
|
void smartlist_add_all(smartlist_t *sl, const smartlist_t *s2)
|
|
|
{
|
|
|
SMARTLIST_FOREACH(s2, void *, element, smartlist_add(sl, element));
|
|
|
}
|
|
|
|
|
|
+/* Remove all elements E from sl such that E==element. Does not preserve
|
|
|
+ * the order of s1.
|
|
|
+ */
|
|
|
void smartlist_remove(smartlist_t *sl, void *element) {
|
|
|
int i;
|
|
|
if(element == NULL)
|
|
|
@@ -281,6 +340,8 @@ void smartlist_remove(smartlist_t *sl, void *element) {
|
|
|
}
|
|
|
}
|
|
|
|
|
|
+/* Return true iff some element E of sl has E==element.
|
|
|
+ */
|
|
|
int smartlist_isin(const smartlist_t *sl, void *element) {
|
|
|
int i;
|
|
|
for(i=0; i < sl->num_used; i++)
|
|
|
@@ -289,6 +350,8 @@ int smartlist_isin(const smartlist_t *sl, void *element) {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
+/* Return true iff some element E of sl2 has smartlist_isin(sl1,E).
|
|
|
+ */
|
|
|
int smartlist_overlap(const smartlist_t *sl1, const smartlist_t *sl2) {
|
|
|
int i;
|
|
|
for(i=0; i < sl2->num_used; i++)
|
|
|
@@ -297,7 +360,9 @@ int smartlist_overlap(const smartlist_t *sl1, const smartlist_t *sl2) {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-/* remove elements of sl1 that aren't in sl2 */
|
|
|
+/* Remove every element E of sl1 such that !smartlist_isin(sl2,E).
|
|
|
+ * Does not preserve the order of sl1.
|
|
|
+ */
|
|
|
void smartlist_intersect(smartlist_t *sl1, const smartlist_t *sl2) {
|
|
|
int i;
|
|
|
for(i=0; i < sl1->num_used; i++)
|
|
|
@@ -307,24 +372,33 @@ void smartlist_intersect(smartlist_t *sl1, const smartlist_t *sl2) {
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-/* remove all elements of sl2 from sl1 */
|
|
|
+/* Remove every element E of sl1 such that smartlist_isin(sl2,E).
|
|
|
+ * Does not preserve the order of sl1.
|
|
|
+ */
|
|
|
void smartlist_subtract(smartlist_t *sl1, const smartlist_t *sl2) {
|
|
|
int i;
|
|
|
for(i=0; i < sl2->num_used; i++)
|
|
|
smartlist_remove(sl1, sl2->list[i]);
|
|
|
}
|
|
|
|
|
|
+/* Return a randomly chosen element of sl; or NULL if sl is empty.
|
|
|
+ */
|
|
|
void *smartlist_choose(const smartlist_t *sl) {
|
|
|
if(sl->num_used)
|
|
|
return sl->list[crypto_pseudo_rand_int(sl->num_used)];
|
|
|
return NULL; /* no elements to choose from */
|
|
|
}
|
|
|
|
|
|
+/* Return the 'idx'th element of sl.
|
|
|
+ */
|
|
|
void *smartlist_get(const smartlist_t *sl, int idx)
|
|
|
{
|
|
|
tor_assert(sl && idx>=0 && idx < sl->num_used);
|
|
|
return sl->list[idx];
|
|
|
}
|
|
|
+/* Change the value of the 'idx'th element of sl to 'val'; return the old
|
|
|
+ * value of the 'idx'th element.
|
|
|
+ */
|
|
|
void *smartlist_set(smartlist_t *sl, int idx, void *val)
|
|
|
{
|
|
|
void *old;
|
|
|
@@ -333,6 +407,10 @@ void *smartlist_set(smartlist_t *sl, int idx, void *val)
|
|
|
sl->list[idx] = val;
|
|
|
return old;
|
|
|
}
|
|
|
+/* Remove the 'idx'th element of sl; if idx is not the last element,
|
|
|
+ * swap the last element of sl into the 'idx'th space. Return the old value
|
|
|
+ * of the 'idx'th element.
|
|
|
+ */
|
|
|
void *smartlist_del(smartlist_t *sl, int idx)
|
|
|
{
|
|
|
void *old;
|
|
|
@@ -341,6 +419,10 @@ void *smartlist_del(smartlist_t *sl, int idx)
|
|
|
sl->list[idx] = sl->list[--sl->num_used];
|
|
|
return old;
|
|
|
}
|
|
|
+/* Remove the 'idx'th element of sl; if idx is not the last element,
|
|
|
+ * moving all subsequent elements back one space. Return the old value
|
|
|
+ * of the 'idx'th element.
|
|
|
+ */
|
|
|
void *smartlist_del_keeporder(smartlist_t *sl, int idx)
|
|
|
{
|
|
|
void *old;
|
|
|
@@ -351,10 +433,15 @@ void *smartlist_del_keeporder(smartlist_t *sl, int idx)
|
|
|
memmove(sl->list+idx, sl->list+idx+1, sizeof(void*)*(sl->num_used-idx));
|
|
|
return old;
|
|
|
}
|
|
|
+/* Return the number of items in sl.
|
|
|
+ */
|
|
|
int smartlist_len(const smartlist_t *sl)
|
|
|
{
|
|
|
return sl->num_used;
|
|
|
}
|
|
|
+/* Insert the value 'val' as the new 'idx'th element of 'sl', moving all
|
|
|
+ * items previously at 'idx' or later forward on space.
|
|
|
+ */
|
|
|
void smartlist_insert(smartlist_t *sl, int idx, void *val)
|
|
|
{
|
|
|
tor_assert(sl && idx >= 0 && idx <= sl->num_used);
|
|
|
@@ -375,9 +462,9 @@ void smartlist_insert(smartlist_t *sl, int idx, void *val)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-/*
|
|
|
+/*****
|
|
|
* Splay-tree implementation of string-to-void* map
|
|
|
- */
|
|
|
+ *****/
|
|
|
struct strmap_entry_t {
|
|
|
SPLAY_ENTRY(strmap_entry_t) node;
|
|
|
char *key;
|
|
|
@@ -636,7 +723,8 @@ void strmap_free(strmap_t *map, void (*free_val)(void*))
|
|
|
* String manipulation
|
|
|
*/
|
|
|
|
|
|
-/* return the first char of s that is not whitespace and not a comment */
|
|
|
+/* Return a pointer to the first char of s that is not whitespace and
|
|
|
+ * not a comment. */
|
|
|
const char *eat_whitespace(const char *s) {
|
|
|
tor_assert(s);
|
|
|
|
|
|
@@ -653,13 +741,14 @@ const char *eat_whitespace(const char *s) {
|
|
|
return s;
|
|
|
}
|
|
|
|
|
|
+/* Return a pointer to the first char of s that is not a space or a tab. */
|
|
|
const char *eat_whitespace_no_nl(const char *s) {
|
|
|
while(*s == ' ' || *s == '\t')
|
|
|
++s;
|
|
|
return s;
|
|
|
}
|
|
|
|
|
|
-/* return the first char of s that is whitespace or '#' or '\0 */
|
|
|
+/* Return a pointer to the first char of s that is whitespace or '#' or '\0 */
|
|
|
const char *find_whitespace(const char *s) {
|
|
|
tor_assert(s);
|
|
|
|
|
|
@@ -669,10 +758,13 @@ const char *find_whitespace(const char *s) {
|
|
|
return s;
|
|
|
}
|
|
|
|
|
|
-/*
|
|
|
- * Time
|
|
|
- */
|
|
|
+/*****
|
|
|
+ * Time
|
|
|
+ *****/
|
|
|
|
|
|
+/* Set *timeval to the current time of day. On error, log and terminate.
|
|
|
+ * (Same as gettimeofday(timeval,NULL), but never returns -1.)
|
|
|
+ */
|
|
|
void tor_gettimeofday(struct timeval *timeval) {
|
|
|
#ifdef HAVE_GETTIMEOFDAY
|
|
|
if (gettimeofday(timeval, NULL)) {
|
|
|
@@ -689,6 +781,8 @@ void tor_gettimeofday(struct timeval *timeval) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
+/* Returns the number of microseconds elapsed between *start and *end.
|
|
|
+ */
|
|
|
long
|
|
|
tv_udiff(struct timeval *start, struct timeval *end)
|
|
|
{
|
|
|
@@ -709,6 +803,8 @@ tv_udiff(struct timeval *start, struct timeval *end)
|
|
|
return udiff;
|
|
|
}
|
|
|
|
|
|
+/* Return -1 if *a<*b, 0 if *a==*b, and 1 if *a>*b.
|
|
|
+ */
|
|
|
int tv_cmp(struct timeval *a, struct timeval *b) {
|
|
|
if (a->tv_sec > b->tv_sec)
|
|
|
return 1;
|
|
|
@@ -721,12 +817,16 @@ int tv_cmp(struct timeval *a, struct timeval *b) {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
+/* Increment *a by the number of seconds and microseconds in *b.
|
|
|
+ */
|
|
|
void tv_add(struct timeval *a, struct timeval *b) {
|
|
|
a->tv_usec += b->tv_usec;
|
|
|
a->tv_sec += b->tv_sec + (a->tv_usec / 1000000);
|
|
|
a->tv_usec %= 1000000;
|
|
|
}
|
|
|
|
|
|
+/* Increment *a by 'ms' milliseconds.
|
|
|
+ */
|
|
|
void tv_addms(struct timeval *a, long ms) {
|
|
|
a->tv_usec += (ms * 1000) % 1000000;
|
|
|
a->tv_sec += ((ms * 1000) / 1000000) + (a->tv_usec / 1000000);
|
|
|
@@ -743,6 +843,9 @@ static int n_leapdays(int y1, int y2) {
|
|
|
static const int days_per_month[] =
|
|
|
{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
|
|
|
|
|
|
+/* Return a time_t given a struct tm. The result is given in GMT, and
|
|
|
+ * does not account for leap seconds.
|
|
|
+ */
|
|
|
time_t tor_timegm (struct tm *tm) {
|
|
|
/* This is a pretty ironclad timegm implementation, snarfed from Python2.2.
|
|
|
* It's way more brute-force than fiddling with tzset().
|
|
|
@@ -770,8 +873,10 @@ time_t tor_timegm (struct tm *tm) {
|
|
|
* Low-level I/O.
|
|
|
*/
|
|
|
|
|
|
-/* a wrapper for write(2) that makes sure to write all count bytes.
|
|
|
- * Only use if fd is a blocking fd. */
|
|
|
+/* Write 'count' bytes from 'buf' to 'fd'. isSocket must be 1 if fd
|
|
|
+ * was returned by socket() or accept(), and 0 if fd was returned by
|
|
|
+ * open(). Return the number of bytes written, or -1 on error. Only
|
|
|
+ * use if fd is a blocking fd. */
|
|
|
int write_all(int fd, const char *buf, size_t count, int isSocket) {
|
|
|
size_t written = 0;
|
|
|
int result;
|
|
|
@@ -788,8 +893,10 @@ int write_all(int fd, const char *buf, size_t count, int isSocket) {
|
|
|
return count;
|
|
|
}
|
|
|
|
|
|
-/* a wrapper for read(2) that makes sure to read all count bytes.
|
|
|
- * Only use if fd is a blocking fd. */
|
|
|
+/* Read 'count' bytes from 'fd' to 'buf'. isSocket must be 1 if fd
|
|
|
+ * was returned by socket() or accept(), and 0 if fd was returned by
|
|
|
+ * open(). Return the number of bytes read, or -1 on error. Only use
|
|
|
+ * if fd is a blocking fd. */
|
|
|
int read_all(int fd, char *buf, size_t count, int isSocket) {
|
|
|
size_t numread = 0;
|
|
|
int result;
|
|
|
@@ -806,6 +913,8 @@ int read_all(int fd, char *buf, size_t count, int isSocket) {
|
|
|
return count;
|
|
|
}
|
|
|
|
|
|
+/* Turn 'socket' into a nonblocking socket.
|
|
|
+ */
|
|
|
void set_socket_nonblocking(int socket)
|
|
|
{
|
|
|
#ifdef MS_WINDOWS
|
|
|
@@ -850,6 +959,8 @@ int spawn_func(int (*func)(void *), void *data)
|
|
|
#endif
|
|
|
}
|
|
|
|
|
|
+/* End the current thread/process.
|
|
|
+ */
|
|
|
void spawn_exit()
|
|
|
{
|
|
|
#ifdef MS_WINDOWS
|
|
|
@@ -860,9 +971,16 @@ void spawn_exit()
|
|
|
}
|
|
|
|
|
|
|
|
|
-/*
|
|
|
- * Windows compatibility.
|
|
|
- */
|
|
|
+/**
|
|
|
+ * Allocate a pair of connected sockets. (Like socketpair(family,
|
|
|
+ * type,protocol,fd), but works on systems that don't have
|
|
|
+ * socketpair.)
|
|
|
+ *
|
|
|
+ * Currently, only (AF_UNIX, SOCK_STREAM, 0 ) sockets are supported.
|
|
|
+ * Note that on systems without socketpair, this call will sometimes
|
|
|
+ * fail if localhost is inaccessible (for example, if the networking
|
|
|
+ * stack is down).
|
|
|
+ **/
|
|
|
int
|
|
|
tor_socketpair(int family, int type, int protocol, int fd[2])
|
|
|
{
|
|
|
@@ -966,16 +1084,22 @@ tor_socketpair(int family, int type, int protocol, int fd[2])
|
|
|
#endif
|
|
|
}
|
|
|
|
|
|
+/* On Windows, WSAEWOULDBLOCK is not always correct: when you see it,
|
|
|
+ * you need to ask the socket for its actual errno. Also, you need to
|
|
|
+ * get your errors from WSAGetLastError, not errno.
|
|
|
+ */
|
|
|
#ifdef MS_WINDOWS
|
|
|
-int correct_socket_errno(int s)
|
|
|
+int tor_socket_errno(int sock)
|
|
|
{
|
|
|
int optval, optvallen=sizeof(optval);
|
|
|
- tor_assert(errno == WSAEWOULDBLOCK);
|
|
|
- if (getsockopt(s, SOL_SOCKET, SO_ERROR, (void*)&optval, &optvallen))
|
|
|
- return errno;
|
|
|
- if (optval)
|
|
|
- return optval;
|
|
|
- return WSAEWOULDBLOCK;
|
|
|
+ int err = WSAGetLastError();
|
|
|
+ if (err == WSAEWOULDBLOCK && sock >= 0) {
|
|
|
+ if (getsockopt(sock, SOL_SOCKET, SO_ERROR, (void*)&optval, &optvallen))
|
|
|
+ return err;
|
|
|
+ if (optval)
|
|
|
+ return optval;
|
|
|
+ }
|
|
|
+ return err;
|
|
|
}
|
|
|
#endif
|
|
|
|
|
|
@@ -1003,8 +1127,9 @@ file_status_t file_status(const char *fname)
|
|
|
return FN_ERROR;
|
|
|
}
|
|
|
|
|
|
-/* Check whether dirname exists and is private. If yes returns
|
|
|
- 0. Else returns -1. */
|
|
|
+/* Check whether dirname exists and is private. If yes returns 0. If
|
|
|
+ * it does not exist, and create is set, try to creat it and return 0
|
|
|
+ * on success. Else return -1. */
|
|
|
int check_private_dir(const char *dirname, int create)
|
|
|
{
|
|
|
int r;
|
|
|
@@ -1056,6 +1181,11 @@ int check_private_dir(const char *dirname, int create)
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
+/* Create a file named 'fname' with the contents 'str'. Overwrite the
|
|
|
+ * previous 'fname' if possible. Return 0 on success, -1 on failure.
|
|
|
+ *
|
|
|
+ * This function replaces the old file atomically, if possible.
|
|
|
+ */
|
|
|
int
|
|
|
write_str_to_file(const char *fname, const char *str)
|
|
|
{
|
|
|
@@ -1084,6 +1214,7 @@ write_str_to_file(const char *fname, const char *str)
|
|
|
return -1;
|
|
|
}
|
|
|
fclose(file);
|
|
|
+ /* XXXX This won't work on windows: you can't use rename to replace a file.*/
|
|
|
if (rename(tempname, fname)) {
|
|
|
log(LOG_WARN, "Error replacing %s: %s", fname, strerror(errno));
|
|
|
return -1;
|
|
|
@@ -1091,6 +1222,9 @@ write_str_to_file(const char *fname, const char *str)
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
+/* Read the contents of 'filename' into a newly allocated string; return the
|
|
|
+ * string on success or NULL on failure.
|
|
|
+ */
|
|
|
char *read_file_to_str(const char *filename) {
|
|
|
int fd; /* router file */
|
|
|
struct stat statbuf;
|
|
|
@@ -1181,6 +1315,9 @@ try_next_line:
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
+/* Return true iff 'ip' (in host order) is an IP reserved to localhost,
|
|
|
+ * or reserved for local networks by RFC 1918.
|
|
|
+ */
|
|
|
int is_internal_IP(uint32_t ip) {
|
|
|
|
|
|
if (((ip & 0xff000000) == 0x0a000000) || /* 10/8 */
|
|
|
@@ -1193,9 +1330,13 @@ int is_internal_IP(uint32_t ip) {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
+/* Hold the result of our call to 'uname'. */
|
|
|
static char uname_result[256];
|
|
|
+/* True iff uname_Result is set. */
|
|
|
static int uname_result_is_set = 0;
|
|
|
|
|
|
+/* Return a pointer to a description of our platform.
|
|
|
+ */
|
|
|
const char *
|
|
|
get_uname(void)
|
|
|
{
|
|
|
@@ -1224,6 +1365,10 @@ get_uname(void)
|
|
|
static int start_daemon_called = 0;
|
|
|
static int finish_daemon_called = 0;
|
|
|
static int daemon_filedes[2];
|
|
|
+/* Begin running this process as a daemon. The child process will return
|
|
|
+ * quickly; the parent process will wait around until the child process calls
|
|
|
+ * finish_daemon.
|
|
|
+ */
|
|
|
void start_daemon(char *desired_cwd)
|
|
|
{
|
|
|
pid_t pid;
|
|
|
@@ -1278,6 +1423,9 @@ void start_daemon(char *desired_cwd)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
+/* Tell the parent process that the child has successfully finished setup,
|
|
|
+ * and the daemon is now running.
|
|
|
+ */
|
|
|
void finish_daemon(void)
|
|
|
{
|
|
|
int nullfd;
|
|
|
@@ -1313,6 +1461,8 @@ void start_daemon(char *cp) {}
|
|
|
void finish_daemon(void) {}
|
|
|
#endif
|
|
|
|
|
|
+/* Write the current process ID, followed by NL, into 'filaname',
|
|
|
+ */
|
|
|
void write_pidfile(char *filename) {
|
|
|
#ifndef MS_WINDOWS
|
|
|
FILE *pidfile;
|
|
|
@@ -1327,6 +1477,9 @@ void write_pidfile(char *filename) {
|
|
|
#endif
|
|
|
}
|
|
|
|
|
|
+/* Call setuid and setgid to run as 'user':'group'. Return 0 on
|
|
|
+ * success. On failure, log and return -1.
|
|
|
+ */
|
|
|
int switch_id(char *user, char *group) {
|
|
|
#ifndef MS_WINDOWS
|
|
|
struct passwd *pw = NULL;
|
|
|
@@ -1377,6 +1530,10 @@ int switch_id(char *user, char *group) {
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
+/* Set *addr to the IP address (in dotted-quad notation) stored in c.
|
|
|
+ * Return 1 on success, 0 if c is badly formatted. (Like inet_aton(c,addr),
|
|
|
+ * but works on Windows.)
|
|
|
+ */
|
|
|
int tor_inet_aton(const char *c, struct in_addr* addr)
|
|
|
{
|
|
|
#ifdef HAVE_INET_ATON
|
Nick Mathewson