src/common/compat.c

   1 /* Copyright (c) 2003-2004, Roger Dingledine
   2  * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
   3  * Copyright (c) 2007-2009, The Tor Project, Inc. */
   4 /* See LICENSE for licensing information */
   5
   6 /**
   7  * \file compat.c
   8  * \brief Wrappers to make calls more portable.  This code defines
   9  * functions such as tor_malloc, tor_snprintf, get/set various data types,
  10  * renaming, setting socket options, switching user IDs.  It is basically
  11  * where the non-portable items are conditionally included depending on
  12  * the platform.
  13  **/
  14
  15 /* This is required on rh7 to make strptime not complain.
  16  * We also need it to make memmem get defined (where available)
  17  */
  18 #define _GNU_SOURCE
  19
  20 #include "compat.h"
  21
  22 #ifdef MS_WINDOWS
  23 #include <process.h>
  24 #include <windows.h>
  25 #include <sys/locking.h>
  26 #endif
  27
  28 #ifdef HAVE_UNAME
  29 #include <sys/utsname.h>
  30 #endif
  31 #ifdef HAVE_UNISTD_H
  32 #include <unistd.h>
  33 #endif
  34 #ifdef HAVE_SYS_FCNTL_H
  35 #include <sys/fcntl.h>
  36 #endif
  37 #ifdef HAVE_PWD_H
  38 #include <pwd.h>
  39 #endif
  40 #ifdef HAVE_GRP_H
  41 #include <grp.h>
  42 #endif
  43 #ifdef HAVE_FCNTL_H
  44 #include <fcntl.h>
  45 #endif
  46 #ifdef HAVE_ERRNO_H
  47 #include <errno.h>
  48 #endif
  49 #ifdef HAVE_ARPA_INET_H
  50 #include <arpa/inet.h>
  51 #endif
  52
  53 #ifndef HAVE_GETTIMEOFDAY
  54 #ifdef HAVE_FTIME
  55 #include <sys/timeb.h>
  56 #endif
  57 #endif
  58
  59 #ifdef HAVE_NETDB_H
  60 #include <netdb.h>
  61 #endif
  62 #ifdef HAVE_SYS_PARAM_H
  63 #include <sys/param.h> /* FreeBSD needs this to know what version it is */
  64 #endif
  65 #include <stdio.h>
  66 #include <stdlib.h>
  67 #include <assert.h>
  68 #ifdef HAVE_SIGNAL_H
  69 #include <signal.h>
  70 #endif
  71 #ifdef HAVE_UTIME_H
  72 #include <utime.h>
  73 #endif
  74 #ifdef HAVE_SYS_UTIME_H
  75 #include <sys/utime.h>
  76 #endif
  77 #ifdef HAVE_SYS_MMAN_H
  78 #include <sys/mman.h>
  79 #endif
  80 #ifdef HAVE_SYS_SYSLIMITS_H
  81 #include <sys/syslimits.h>
  82 #endif
  83 #ifdef HAVE_SYS_FILE_H
  84 #include <sys/file.h>
  85 #endif
  86 #if defined(HAVE_SYS_PRCTL_H) && defined(__linux__)
  87 /* Only use the linux prctl;  the IRIX prctl is totally different */
  88 #include <sys/prctl.h>
  89 #endif
  90
  91 #include "log.h"
  92 #include "util.h"
  93 #include "container.h"
  94 #include "address.h"
  95
  96 /* Inline the strl functions if the platform doesn't have them. */
  97 #ifndef HAVE_STRLCPY
  98 #include "strlcpy.c"
  99 #endif
 100 #ifndef HAVE_STRLCAT
 101 #include "strlcat.c"
 102 #endif
 103
 104 #ifdef HAVE_SYS_MMAN_H
 105 /** Try to create a memory mapping for <b>filename</b> and return it.  On
 106  * failure, return NULL.  Sets errno properly, using ERANGE to mean
 107  * "empty file". */
 108 tor_mmap_t *
 109 tor_mmap_file(const char *filename)
 110 {
 111   int fd; /* router file */
 112   char *string;
 113   int page_size;
 114   tor_mmap_t *res;
 115   size_t size, filesize;
 116
 117   tor_assert(filename);
 118
 119   fd = open(filename, O_RDONLY, 0);
 120   if (fd<0) {
 121     int save_errno = errno;
 122     int severity = (errno == ENOENT) ? LOG_INFO : LOG_WARN;
 123     log_fn(severity, LD_FS,"Could not open \"%s\" for mmap(): %s",filename,
 124            strerror(errno));
 125     errno = save_errno;
 126     return NULL;
 127   }
 128
 129   size = filesize = (size_t) lseek(fd, 0, SEEK_END);
 130   lseek(fd, 0, SEEK_SET);
 131   /* ensure page alignment */
 132   page_size = getpagesize();
 133   size += (size%page_size) ? page_size-(size%page_size) : 0;
 134
 135   if (!size) {
 136     /* Zero-length file. If we call mmap on it, it will succeed but
 137      * return NULL, and bad things will happen. So just fail. */
 138     log_info(LD_FS,"File \"%s\" is empty. Ignoring.",filename);
 139     errno = ERANGE;
 140     close(fd);
 141     return NULL;
 142   }
 143
 144   string = mmap(0, size, PROT_READ, MAP_PRIVATE, fd, 0);
 145   close(fd);
 146   if (string == MAP_FAILED) {
 147     int save_errno = errno;
 148     log_warn(LD_FS,"Could not mmap file \"%s\": %s", filename,
 149              strerror(errno));
 150     errno = save_errno;
 151     return NULL;
 152   }
 153
 154   res = tor_malloc_zero(sizeof(tor_mmap_t));
 155   res->data = string;
 156   res->size = filesize;
 157   res->mapping_size = size;
 158
 159   return res;
 160 }
 161 /** Release storage held for a memory mapping. */
 162 void
 163 tor_munmap_file(tor_mmap_t *handle)
 164 {
 165   munmap((char*)handle->data, handle->mapping_size);
 166   tor_free(handle);
 167 }
 168 #elif defined(MS_WINDOWS)
 169 tor_mmap_t *
 170 tor_mmap_file(const char *filename)
 171 {
 172   tor_mmap_t *res = tor_malloc_zero(sizeof(tor_mmap_t));
 173   int empty = 0;
 174   res->file_handle = INVALID_HANDLE_VALUE;
 175   res->mmap_handle = NULL;
 176
 177   res->file_handle = CreateFile(filename,
 178                                 GENERIC_READ, FILE_SHARE_READ,
 179                                 NULL,
 180                                 OPEN_EXISTING,
 181                                 FILE_ATTRIBUTE_NORMAL,
 182                                 0);
 183
 184   if (res->file_handle == INVALID_HANDLE_VALUE)
 185     goto win_err;
 186
 187   res->size = GetFileSize(res->file_handle, NULL);
 188
 189   if (res->size == 0) {
 190     log_info(LD_FS,"File \"%s\" is empty. Ignoring.",filename);
 191     empty = 1;
 192     goto err;
 193   }
 194
 195   res->mmap_handle = CreateFileMapping(res->file_handle,
 196                                        NULL,
 197                                        PAGE_READONLY,
 198 #if SIZEOF_SIZE_T > 4
 199                                        (res->base.size >> 32),
 200 #else
 201                                        0,
 202 #endif
 203                                        (res->size & 0xfffffffful),
 204                                        NULL);
 205   if (res->mmap_handle == NULL)
 206     goto win_err;
 207   res->data = (char*) MapViewOfFile(res->mmap_handle,
 208                                     FILE_MAP_READ,
 209                                     0, 0, 0);
 210   if (!res->data)
 211     goto win_err;
 212
 213   return res;
 214  win_err: {
 215     DWORD e = GetLastError();
 216     int severity = (e == ERROR_FILE_NOT_FOUND || e == ERROR_PATH_NOT_FOUND) ?
 217       LOG_INFO : LOG_WARN;
 218     char *msg = format_win32_error(e);
 219     log_fn(severity, LD_FS, "Couldn't mmap file \"%s\": %s", filename, msg);
 220     tor_free(msg);
 221     if (e == ERROR_FILE_NOT_FOUND || e == ERROR_PATH_NOT_FOUND)
 222       errno = ENOENT;
 223     else
 224       errno = EINVAL;
 225   }
 226  err:
 227   if (empty)
 228     errno = ERANGE;
 229   tor_munmap_file(res);
 230   return NULL;
 231 }
 232 void
 233 tor_munmap_file(tor_mmap_t *handle)
 234 {
 235   if (handle->data)
 236     /* This is an ugly cast, but without it, "data" in struct tor_mmap_t would
 237        have to be redefined as non-const. */
 238     UnmapViewOfFile( (LPVOID) handle->data);
 239
 240   if (handle->mmap_handle != NULL)
 241     CloseHandle(handle->mmap_handle);
 242   if (handle->file_handle != INVALID_HANDLE_VALUE)
 243     CloseHandle(handle->file_handle);
 244   tor_free(handle);
 245 }
 246 #else
 247 tor_mmap_t *
 248 tor_mmap_file(const char *filename)
 249 {
 250   struct stat st;
 251   char *res = read_file_to_str(filename, RFTS_BIN|RFTS_IGNORE_MISSING, &st);
 252   tor_mmap_t *handle;
 253   if (! res)
 254     return NULL;
 255   handle = tor_malloc_zero(sizeof(tor_mmap_t));
 256   handle->data = res;
 257   handle->size = st.st_size;
 258   return handle;
 259 }
 260 void
 261 tor_munmap_file(tor_mmap_t *handle)
 262 {
 263   char *d = (char*)handle->data;
 264   tor_free(d);
 265   memset(handle, 0, sizeof(tor_mmap_t));
 266   tor_free(handle);
 267 }
 268 #endif
 269
 270 /** Replacement for snprintf.  Differs from platform snprintf in two
 271  * ways: First, always NUL-terminates its output.  Second, always
 272  * returns -1 if the result is truncated.  (Note that this return
 273  * behavior does <i>not</i> conform to C99; it just happens to be
 274  * easier to emulate "return -1" with conformant implementations than
 275  * it is to emulate "return number that would be written" with
 276  * non-conformant implementations.) */
 277 int
 278 tor_snprintf(char *str, size_t size, const char *format, ...)
 279 {
 280   va_list ap;
 281   int r;
 282   va_start(ap,format);
 283   r = tor_vsnprintf(str,size,format,ap);
 284   va_end(ap);
 285   return r;
 286 }
 287
 288 /** Replacement for vsnprintf; behavior differs as tor_snprintf differs from
 289  * snprintf.
 290  */
 291 int
 292 tor_vsnprintf(char *str, size_t size, const char *format, va_list args)
 293 {
 294   int r;
 295   if (size == 0)
 296     return -1; /* no place for the NUL */
 297   if (size > SSIZE_T_MAX-16)
 298     return -1;
 299 #ifdef MS_WINDOWS
 300   r = _vsnprintf(str, size, format, args);
 301 #else
 302   r = vsnprintf(str, size, format, args);
 303 #endif
 304   str[size-1] = '\0';
 305   if (r < 0 || r >= (ssize_t)size)
 306     return -1;
 307   return r;
 308 }
 309
 310 /** Given <b>hlen</b> bytes at <b>haystack</b> and <b>nlen</b> bytes at
 311  * <b>needle</b>, return a pointer to the first occurrence of the needle
 312  * within the haystack, or NULL if there is no such occurrence.
 313  *
 314  * Requires that nlen be greater than zero.
 315  */
 316 const void *
 317 tor_memmem(const void *_haystack, size_t hlen,
 318            const void *_needle, size_t nlen)
 319 {
 320 #if defined(HAVE_MEMMEM) && (!defined(__GNUC__) || __GNUC__ >= 2)
 321   tor_assert(nlen);
 322   return memmem(_haystack, hlen, _needle, nlen);
 323 #else
 324   /* This isn't as fast as the GLIBC implementation, but it doesn't need to
 325    * be. */
 326   const char *p, *end;
 327   const char *haystack = (const char*)_haystack;
 328   const char *needle = (const char*)_needle;
 329   char first;
 330   tor_assert(nlen);
 331
 332   p = haystack;
 333   end = haystack + hlen;
 334   first = *(const char*)needle;
 335   while ((p = memchr(p, first, end-p))) {
 336     if (p+nlen > end)
 337       return NULL;
 338     if (!memcmp(p, needle, nlen))
 339       return p;
 340     ++p;
 341   }
 342   return NULL;
 343 #endif
 344 }
 345
 346 /* Tables to implement ctypes-replacement TOR_IS*() functions.  Each table
 347  * has 256 bits to look up whether a character is in some set or not.  This
 348  * fails on non-ASCII platforms, but it is hard to find a platform whose
 349  * character set is not a superset of ASCII nowadays. */
 350 const uint32_t TOR_ISALPHA_TABLE[8] =
 351   { 0, 0, 0x7fffffe, 0x7fffffe, 0, 0, 0, 0 };
 352 const uint32_t TOR_ISALNUM_TABLE[8] =
 353   { 0, 0x3ff0000, 0x7fffffe, 0x7fffffe, 0, 0, 0, 0 };
 354 const uint32_t TOR_ISSPACE_TABLE[8] = { 0x3e00, 0x1, 0, 0, 0, 0, 0, 0 };
 355 const uint32_t TOR_ISXDIGIT_TABLE[8] =
 356   { 0, 0x3ff0000, 0x7e, 0x7e, 0, 0, 0, 0 };
 357 const uint32_t TOR_ISDIGIT_TABLE[8] = { 0, 0x3ff0000, 0, 0, 0, 0, 0, 0 };
 358 const uint32_t TOR_ISPRINT_TABLE[8] =
 359   { 0, 0xffffffff, 0xffffffff, 0x7fffffff, 0, 0, 0, 0x0 };
 360 const uint32_t TOR_ISUPPER_TABLE[8] = { 0, 0, 0x7fffffe, 0, 0, 0, 0, 0 };
 361 const uint32_t TOR_ISLOWER_TABLE[8] = { 0, 0, 0, 0x7fffffe, 0, 0, 0, 0 };
 362 /* Upper-casing and lowercasing tables to map characters to upper/lowercase
 363  * equivalents. */
 364 const char TOR_TOUPPER_TABLE[256] = {
 365   0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
 366   16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
 367   32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,
 368   48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,
 369   64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,
 370   80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,
 371   96,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,
 372   80,81,82,83,84,85,86,87,88,89,90,123,124,125,126,127,
 373   128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
 374   144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
 375   160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
 376   176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
 377   192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
 378   208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
 379   224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,
 380   240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,
 381 };
 382 const char TOR_TOLOWER_TABLE[256] = {
 383   0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
 384   16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
 385   32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,
 386   48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,
 387   64,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,
 388   112,113,114,115,116,117,118,119,120,121,122,91,92,93,94,95,
 389   96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,
 390   112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,
 391   128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
 392   144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
 393   160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
 394   176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
 395   192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
 396   208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
 397   224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,
 398   240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,
 399 };
 400
 401 /** Implementation of strtok_r for platforms whose coders haven't figured out
 402  * how to write one.  Hey guys!  You can use this code here for free! */
 403 char *
 404 tor_strtok_r_impl(char *str, const char *sep, char **lasts)
 405 {
 406   char *cp, *start;
 407   if (str)
 408     start = cp = *lasts = str;
 409   else if (!*lasts)
 410     return NULL;
 411   else
 412     start = cp = *lasts;
 413
 414   tor_assert(*sep);
 415   if (sep[1]) {
 416     while (*cp && !strchr(sep, *cp))
 417       ++cp;
 418   } else {
 419     tor_assert(strlen(sep) == 1);
 420     cp = strchr(cp, *sep);
 421   }
 422
 423   if (!cp || !*cp) {
 424     *lasts = NULL;
 425   } else {
 426     *cp++ = '\0';
 427     *lasts = cp;
 428   }
 429   return start;
 430 }
 431
 432 #ifdef MS_WINDOWS
 433 /** Take a filename and return a pointer to its final element.  This
 434  * function is called on __FILE__ to fix a MSVC nit where __FILE__
 435  * contains the full path to the file.  This is bad, because it
 436  * confuses users to find the home directory of the person who
 437  * compiled the binary in their warning messages.
 438  */
 439 const char *
 440 tor_fix_source_file(const char *fname)
 441 {
 442   const char *cp1, *cp2, *r;
 443   cp1 = strrchr(fname, '/');
 444   cp2 = strrchr(fname, '\\');
 445   if (cp1 && cp2) {
 446     r = (cp1<cp2)?(cp2+1):(cp1+1);
 447   } else if (cp1) {
 448     r = cp1+1;
 449   } else if (cp2) {
 450     r = cp2+1;
 451   } else {
 452     r = fname;
 453   }
 454   return r;
 455 }
 456 #endif
 457
 458 /**
 459  * Read a 16-bit value beginning at <b>cp</b>.  Equivalent to
 460  * *(uint16_t*)(cp), but will not cause segfaults on platforms that forbid
 461  * unaligned memory access.
 462  */
 463 uint16_t
 464 get_uint16(const char *cp)
 465 {
 466   uint16_t v;
 467   memcpy(&v,cp,2);
 468   return v;
 469 }
 470 /**
 471  * Read a 32-bit value beginning at <b>cp</b>.  Equivalent to
 472  * *(uint32_t*)(cp), but will not cause segfaults on platforms that forbid
 473  * unaligned memory access.
 474  */
 475 uint32_t
 476 get_uint32(const char *cp)
 477 {
 478   uint32_t v;
 479   memcpy(&v,cp,4);
 480   return v;
 481 }
 482 /**
 483  * Read a 64-bit value beginning at <b>cp</b>.  Equivalent to
 484  * *(uint64_t*)(cp), but will not cause segfaults on platforms that forbid
 485  * unaligned memory access.
 486  */
 487 uint64_t
 488 get_uint64(const char *cp)
 489 {
 490   uint64_t v;
 491   memcpy(&v,cp,8);
 492   return v;
 493 }
 494
 495 /**
 496  * Set a 16-bit value beginning at <b>cp</b> to <b>v</b>. Equivalent to
 497  * *(uint16_t*)(cp) = v, but will not cause segfaults on platforms that forbid
 498  * unaligned memory access. */
 499 void
 500 set_uint16(char *cp, uint16_t v)
 501 {
 502   memcpy(cp,&v,2);
 503 }
 504 /**
 505  * Set a 32-bit value beginning at <b>cp</b> to <b>v</b>. Equivalent to
 506  * *(uint32_t*)(cp) = v, but will not cause segfaults on platforms that forbid
 507  * unaligned memory access. */
 508 void
 509 set_uint32(char *cp, uint32_t v)
 510 {
 511   memcpy(cp,&v,4);
 512 }
 513 /**
 514  * Set a 64-bit value beginning at <b>cp</b> to <b>v</b>. Equivalent to
 515  * *(uint64_t*)(cp) = v, but will not cause segfaults on platforms that forbid
 516  * unaligned memory access. */
 517 void
 518 set_uint64(char *cp, uint64_t v)
 519 {
 520   memcpy(cp,&v,8);
 521 }
 522
 523 /**
 524  * Rename the file <b>from</b> to the file <b>to</b>.  On Unix, this is
 525  * the same as rename(2).  On windows, this removes <b>to</b> first if
 526  * it already exists.
 527  * Returns 0 on success.  Returns -1 and sets errno on failure.
 528  */
 529 int
 530 replace_file(const char *from, const char *to)
 531 {
 532 #ifndef MS_WINDOWS
 533   return rename(from,to);
 534 #else
 535   switch (file_status(to))
 536     {
 537     case FN_NOENT:
 538       break;
 539     case FN_FILE:
 540       if (unlink(to)) return -1;
 541       break;
 542     case FN_ERROR:
 543       return -1;
 544     case FN_DIR:
 545       errno = EISDIR;
 546       return -1;
 547     }
 548   return rename(from,to);
 549 #endif
 550 }
 551
 552 /** Change <b>fname</b>'s modification time to now. */
 553 int
 554 touch_file(const char *fname)
 555 {
 556   if (utime(fname, NULL)!=0)
 557     return -1;
 558   return 0;
 559 }
 560
 561 /** Represents a lockfile on which we hold the lock. */
 562 struct tor_lockfile_t {
 563   char *filename;
 564   int fd;
 565 };
 566
 567 /** Try to get a lock on the lockfile <b>filename</b>, creating it as
 568  * necessary.  If someone else has the lock and <b>blocking</b> is true,
 569  * wait until the lock is available.  Otherwise return immediately whether
 570  * we succeeded or not.
 571  *
 572  * Set *<b>locked_out</b> to true if somebody else had the lock, and to false
 573  * otherwise.
 574  *
 575  * Return a <b>tor_lockfile_t</b> on success, NULL on failure.
 576  *
 577  * (Implementation note: because we need to fall back to fcntl on some
 578  *  platforms, these locks are per-process, not per-thread.  If you want
 579  *  to do in-process locking, use tor_mutex_t like a normal person.)
 580  */
 581 tor_lockfile_t *
 582 tor_lockfile_lock(const char *filename, int blocking, int *locked_out)
 583 {
 584   tor_lockfile_t *result;
 585   int fd;
 586   *locked_out = 0;
 587
 588   log_info(LD_FS, "Locking \"%s\"", filename);
 589   fd = open(filename, O_RDWR|O_CREAT|O_TRUNC, 0600);
 590   if (fd < 0) {
 591     log_warn(LD_FS,"Couldn't open \"%s\" for locking: %s", filename,
 592              strerror(errno));
 593     return NULL;
 594   }
 595
 596 #ifdef WIN32
 597   _lseek(fd, 0, SEEK_SET);
 598   if (_locking(fd, blocking ? _LK_LOCK : _LK_NBLCK, 1) < 0) {
 599     if (errno != EDEADLOCK)
 600       log_warn(LD_FS,"Couldn't lock \"%s\": %s", filename, strerror(errno));
 601     else
 602       *locked_out = 1;
 603     close(fd);
 604     return NULL;
 605   }
 606 #elif defined(HAVE_FLOCK)
 607   if (flock(fd, LOCK_EX|(blocking ? 0 : LOCK_NB)) < 0) {
 608     if (errno != EWOULDBLOCK)
 609       log_warn(LD_FS,"Couldn't lock \"%s\": %s", filename, strerror(errno));
 610     else
 611       *locked_out = 1;
 612     close(fd);
 613     return NULL;
 614   }
 615 #else
 616   {
 617     struct flock lock;
 618     memset(&lock, 0, sizeof(lock));
 619     lock.l_type = F_WRLCK;
 620     lock.l_whence = SEEK_SET;
 621     if (fcntl(fd, blocking ? F_SETLKW : F_SETLK, &lock) < 0) {
 622       if (errno != EACCES && errno != EAGAIN)
 623         log_warn(LD_FS, "Couldn't lock \"%s\": %s", filename, strerror(errno));
 624       else
 625         *locked_out = 1;
 626       close(fd);
 627       return NULL;
 628     }
 629   }
 630 #endif
 631
 632   result = tor_malloc(sizeof(tor_lockfile_t));
 633   result->filename = tor_strdup(filename);
 634   result->fd = fd;
 635   return result;
 636 }
 637
 638 /** Release the lock held as <b>lockfile</b>. */
 639 void
 640 tor_lockfile_unlock(tor_lockfile_t *lockfile)
 641 {
 642   tor_assert(lockfile);
 643
 644   log_info(LD_FS, "Unlocking \"%s\"", lockfile->filename);
 645 #ifdef WIN32
 646   _lseek(lockfile->fd, 0, SEEK_SET);
 647   if (_locking(lockfile->fd, _LK_UNLCK, 1) < 0) {
 648     log_warn(LD_FS,"Error unlocking \"%s\": %s", lockfile->filename,
 649              strerror(errno));
 650   }
 651 #elif defined(HAVE_FLOCK)
 652   if (flock(lockfile->fd, LOCK_UN) < 0) {
 653     log_warn(LD_FS, "Error unlocking \"%s\": %s", lockfile->filename,
 654              strerror(errno));
 655   }
 656 #else
 657   /* Closing the lockfile is sufficient. */
 658 #endif
 659
 660   close(lockfile->fd);
 661   lockfile->fd = -1;
 662   tor_free(lockfile->filename);
 663   tor_free(lockfile);
 664 }
 665
 666 /* Some old versions of Unix didn't define constants for these values,
 667  * and instead expect you to say 0, 1, or 2. */
 668 #ifndef SEEK_CUR
 669 #define SEEK_CUR 1
 670 #endif
 671 #ifndef SEEK_END
 672 #define SEEK_END 2
 673 #endif
 674
 675 /** Return the position of <b>fd</b> with respect to the start of the file. */
 676 off_t
 677 tor_fd_getpos(int fd)
 678 {
 679 #ifdef WIN32
 680   return (off_t) _lseek(fd, 0, SEEK_CUR);
 681 #else
 682   return (off_t) lseek(fd, 0, SEEK_CUR);
 683 #endif
 684 }
 685
 686 /** Move <b>fd</b> to the end of the file. Return -1 on error, 0 on success. */
 687 int
 688 tor_fd_seekend(int fd)
 689 {
 690 #ifdef WIN32
 691   return _lseek(fd, 0, SEEK_END) < 0 ? -1 : 0;
 692 #else
 693   return lseek(fd, 0, SEEK_END) < 0 ? -1 : 0;
 694 #endif
 695 }
 696
 697 #undef DEBUG_SOCKET_COUNTING
 698 #ifdef DEBUG_SOCKET_COUNTING
 699 /** A bitarray of all fds that should be passed to tor_socket_close(). Only
 700  * used if DEBUG_SOCKET_COUNTING is defined. */
 701 static bitarray_t *open_sockets = NULL;
 702 /** The size of <b>open_sockets</b>, in bits. */
 703 static int max_socket = -1;
 704 #endif
 705
 706 /** Count of number of sockets currently open.  (Undercounts sockets opened by
 707  * eventdns and libevent.) */
 708 static int n_sockets_open = 0;
 709
 710 /** Mutex to protect open_sockets, max_socket, and n_sockets_open. */
 711 static tor_mutex_t *socket_accounting_mutex = NULL;
 712
 713 static INLINE void
 714 socket_accounting_lock(void)
 715 {
 716   if (PREDICT_UNLIKELY(!socket_accounting_mutex))
 717     socket_accounting_mutex = tor_mutex_new();
 718   tor_mutex_acquire(socket_accounting_mutex);
 719 }
 720
 721 static INLINE void
 722 socket_accounting_unlock(void)
 723 {
 724   tor_mutex_release(socket_accounting_mutex);
 725 }
 726
 727 /** As close(), but guaranteed to work for sockets across platforms (including
 728  * Windows, where close()ing a socket doesn't work.  Returns 0 on success, -1
 729  * on failure. */
 730 int
 731 tor_close_socket(int s)
 732 {
 733   int r = 0;
 734
 735   /* On Windows, you have to call close() on fds returned by open(),
 736    * and closesocket() on fds returned by socket().  On Unix, everything
 737    * gets close()'d.  We abstract this difference by always using
 738    * tor_close_socket to close sockets, and always using close() on
 739    * files.
 740    */
 741 #if defined(MS_WINDOWS)
 742   r = closesocket(s);
 743 #else
 744   r = close(s);
 745 #endif
 746
 747   socket_accounting_lock();
 748 #ifdef DEBUG_SOCKET_COUNTING
 749   if (s > max_socket || ! bitarray_is_set(open_sockets, s)) {
 750     log_warn(LD_BUG, "Closing a socket (%d) that wasn't returned by tor_open_"
 751              "socket(), or that was already closed or something.", s);
 752   } else {
 753     tor_assert(open_sockets && s <= max_socket);
 754     bitarray_clear(open_sockets, s);
 755   }
 756 #endif
 757   if (r == 0) {
 758     --n_sockets_open;
 759   } else {
 760     int err = tor_socket_errno(-1);
 761     log_info(LD_NET, "Close returned an error: %s", tor_socket_strerror(err));
 762 #ifdef WIN32
 763     if (err != WSAENOTSOCK)
 764       --n_sockets_open;
 765 #else
 766     if (err != EBADF)
 767       --n_sockets_open;
 768 #endif
 769     r = -1;
 770   }
 771
 772   if (n_sockets_open < 0)
 773     log_warn(LD_BUG, "Our socket count is below zero: %d. Please submit a "
 774              "bug report.", n_sockets_open);
 775   socket_accounting_unlock();
 776   return r;
 777 }
 778
 779 #ifdef DEBUG_SOCKET_COUNTING
 780 /** Helper: if DEBUG_SOCKET_COUNTING is enabled, remember that <b>s</b> is
 781  * now an open socket. */
 782 static INLINE void
 783 mark_socket_open(int s)
 784 {
 785   if (s > max_socket) {
 786     if (max_socket == -1) {
 787       open_sockets = bitarray_init_zero(s+128);
 788       max_socket = s+128;
 789     } else {
 790       open_sockets = bitarray_expand(open_sockets, max_socket, s+128);
 791       max_socket = s+128;
 792     }
 793   }
 794   if (bitarray_is_set(open_sockets, s)) {
 795     log_warn(LD_BUG, "I thought that %d was already open, but socket() just "
 796              "gave it to me!", s);
 797   }
 798   bitarray_set(open_sockets, s);
 799 }
 800 #else
 801 #define mark_socket_open(s) STMT_NIL
 802 #endif
 803
 804 /** As socket(), but counts the number of open sockets. */
 805 int
 806 tor_open_socket(int domain, int type, int protocol)
 807 {
 808   int s = socket(domain, type, protocol);
 809   if (s >= 0) {
 810     socket_accounting_lock();
 811     ++n_sockets_open;
 812     mark_socket_open(s);
 813     socket_accounting_unlock();
 814   }
 815   return s;
 816 }
 817
 818 /** As socket(), but counts the number of open sockets. */
 819 int
 820 tor_accept_socket(int sockfd, struct sockaddr *addr, socklen_t *len)
 821 {
 822   int s = accept(sockfd, addr, len);
 823   if (s >= 0) {
 824     socket_accounting_lock();
 825     ++n_sockets_open;
 826     mark_socket_open(s);
 827     socket_accounting_unlock();
 828   }
 829   return s;
 830 }
 831
 832 /** Return the number of sockets we currently have opened. */
 833 int
 834 get_n_open_sockets(void)
 835 {
 836   int n;
 837   socket_accounting_lock();
 838   n = n_sockets_open;
 839   socket_accounting_unlock();
 840   return n;
 841 }
 842
 843 /** Turn <b>socket</b> into a nonblocking socket.
 844  */
 845 void
 846 set_socket_nonblocking(int socket)
 847 {
 848 #if defined(MS_WINDOWS)
 849   unsigned long nonblocking = 1;
 850   ioctlsocket(socket, FIONBIO, (unsigned long*) &nonblocking);
 851 #else
 852   fcntl(socket, F_SETFL, O_NONBLOCK);
 853 #endif
 854 }
 855
 856 /**
 857  * Allocate a pair of connected sockets.  (Like socketpair(family,
 858  * type,protocol,fd), but works on systems that don't have
 859  * socketpair.)
 860  *
 861  * Currently, only (AF_UNIX, SOCK_STREAM, 0) sockets are supported.
 862  *
 863  * Note that on systems without socketpair, this call will fail if
 864  * localhost is inaccessible (for example, if the networking
 865  * stack is down). And even if it succeeds, the socket pair will not
 866  * be able to read while localhost is down later (the socket pair may
 867  * even close, depending on OS-specific timeouts).
 868  *
 869  * Returns 0 on success and -errno on failure; do not rely on the value
 870  * of errno or WSAGetLastError().
 871  **/
 872 /* It would be nicer just to set errno, but that won't work for windows. */
 873 int
 874 tor_socketpair(int family, int type, int protocol, int fd[2])
 875 {
 876 //don't use win32 socketpairs (they are always bad)
 877 #if defined(HAVE_SOCKETPAIR) && !defined(MS_WINDOWS)
 878   int r;
 879   r = socketpair(family, type, protocol, fd);
 880   if (r == 0) {
 881     socket_accounting_lock();
 882     if (fd[0] >= 0) {
 883       ++n_sockets_open;
 884       mark_socket_open(fd[0]);
 885     }
 886     if (fd[1] >= 0) {
 887       ++n_sockets_open;
 888       mark_socket_open(fd[1]);
 889     }
 890     socket_accounting_unlock();
 891   }
 892   return r < 0 ? -errno : r;
 893 #else
 894     /* This socketpair does not work when localhost is down. So
 895      * it's really not the same thing at all. But it's close enough
 896      * for now, and really, when localhost is down sometimes, we
 897      * have other problems too.
 898      */
 899     int listener = -1;
 900     int connector = -1;
 901     int acceptor = -1;
 902     struct sockaddr_in listen_addr;
 903     struct sockaddr_in connect_addr;
 904     int size;
 905     int saved_errno = -1;
 906
 907     if (protocol
 908 #ifdef AF_UNIX
 909         || family != AF_UNIX
 910 #endif
 911         ) {
 912 #ifdef MS_WINDOWS
 913       return -WSAEAFNOSUPPORT;
 914 #else
 915       return -EAFNOSUPPORT;
 916 #endif
 917     }
 918     if (!fd) {
 919       return -EINVAL;
 920     }
 921
 922     listener = tor_open_socket(AF_INET, type, 0);
 923     if (listener < 0)
 924       return -tor_socket_errno(-1);
 925     memset(&listen_addr, 0, sizeof(listen_addr));
 926     listen_addr.sin_family = AF_INET;
 927     listen_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 928     listen_addr.sin_port = 0;   /* kernel chooses port.  */
 929     if (bind(listener, (struct sockaddr *) &listen_addr, sizeof (listen_addr))
 930         == -1)
 931       goto tidy_up_and_fail;
 932     if (listen(listener, 1) == -1)
 933       goto tidy_up_and_fail;
 934
 935     connector = tor_open_socket(AF_INET, type, 0);
 936     if (connector < 0)
 937       goto tidy_up_and_fail;
 938     /* We want to find out the port number to connect to.  */
 939     size = sizeof(connect_addr);
 940     if (getsockname(listener, (struct sockaddr *) &connect_addr, &size) == -1)
 941       goto tidy_up_and_fail;
 942     if (size != sizeof (connect_addr))
 943       goto abort_tidy_up_and_fail;
 944     if (connect(connector, (struct sockaddr *) &connect_addr,
 945                 sizeof(connect_addr)) == -1)
 946       goto tidy_up_and_fail;
 947
 948     size = sizeof(listen_addr);
 949     acceptor = tor_accept_socket(listener,
 950                                  (struct sockaddr *) &listen_addr, &size);
 951     if (acceptor < 0)
 952       goto tidy_up_and_fail;
 953     if (size != sizeof(listen_addr))
 954       goto abort_tidy_up_and_fail;
 955     tor_close_socket(listener);
 956     /* Now check we are talking to ourself by matching port and host on the
 957        two sockets.  */
 958     if (getsockname(connector, (struct sockaddr *) &connect_addr, &size) == -1)
 959       goto tidy_up_and_fail;
 960     if (size != sizeof (connect_addr)
 961         || listen_addr.sin_family != connect_addr.sin_family
 962         || listen_addr.sin_addr.s_addr != connect_addr.sin_addr.s_addr
 963         || listen_addr.sin_port != connect_addr.sin_port) {
 964       goto abort_tidy_up_and_fail;
 965     }
 966     fd[0] = connector;
 967     fd[1] = acceptor;
 968
 969     return 0;
 970
 971   abort_tidy_up_and_fail:
 972 #ifdef MS_WINDOWS
 973     saved_errno = WSAECONNABORTED;
 974 #else
 975     saved_errno = ECONNABORTED; /* I hope this is portable and appropriate.  */
 976 #endif
 977   tidy_up_and_fail:
 978     if (saved_errno < 0)
 979       saved_errno = errno;
 980     if (listener != -1)
 981       tor_close_socket(listener);
 982     if (connector != -1)
 983       tor_close_socket(connector);
 984     if (acceptor != -1)
 985       tor_close_socket(acceptor);
 986     return -saved_errno;
 987 #endif
 988 }
 989
 990 #define ULIMIT_BUFFER 32 /* keep 32 extra fd's beyond _ConnLimit */
 991
 992 /** Learn the maximum allowed number of file descriptors. (Some systems
 993  * have a low soft limit.
 994  *
 995  * We compute this by finding the largest number that we can use.
 996  * If we can't find a number greater than or equal to <b>limit</b>,
 997  * then we fail: return -1.
 998  *
 999  * Otherwise, return 0 and store the maximum we found inside <b>max_out</b>.*/
1000 int
1001 set_max_file_descriptors(rlim_t limit, int *max_out)
1002 {
1003   /* Define some maximum connections values for systems where we cannot
1004    * automatically determine a limit. Re Cygwin, see
1005    * http://archives.seul.org/or/talk/Aug-2006/msg00210.html
1006    * For an iPhone, 9999 should work. For Windows and all other unknown
1007    * systems we use 15000 as the default. */
1008 #ifndef HAVE_GETRLIMIT
1009 #if defined(CYGWIN) || defined(__CYGWIN__)
1010   const char *platform = "Cygwin";
1011   const unsigned long MAX_CONNECTIONS = 3200;
1012 #elif defined(IPHONE)
1013   const char *platform = "iPhone";
1014   const unsigned long MAX_CONNECTIONS = 9999;
1015 #elif defined(MS_WINDOWS)
1016   const char *platform = "Windows";
1017   const unsigned long MAX_CONNECTIONS = 15000;
1018 #else
1019   const char *platform = "unknown platforms with no getrlimit()";
1020   const unsigned long MAX_CONNECTIONS = 15000;
1021 #endif
1022   log_fn(LOG_INFO, LD_NET,
1023          "This platform is missing getrlimit(). Proceeding.");
1024   if (limit > MAX_CONNECTIONS) {
1025     log_warn(LD_CONFIG,
1026              "We do not support more than %lu file descriptors "
1027              "on %s. Tried to raise to %lu.",
1028              (unsigned long)MAX_CONNECTIONS, platform, (unsigned long)limit);
1029     return -1;
1030   }
1031   limit = MAX_CONNECTIONS;
1032 #else /* HAVE_GETRLIMIT */
1033   struct rlimit rlim;
1034   tor_assert(limit > 0);
1035
1036   if (getrlimit(RLIMIT_NOFILE, &rlim) != 0) {
1037     log_warn(LD_NET, "Could not get maximum number of file descriptors: %s",
1038              strerror(errno));
1039     return -1;
1040   }
1041
1042   if (rlim.rlim_max < limit) {
1043     log_warn(LD_CONFIG,"We need %lu file descriptors available, and we're "
1044              "limited to %lu. Please change your ulimit -n.",
1045              (unsigned long)limit, (unsigned long)rlim.rlim_max);
1046     return -1;
1047   }
1048
1049   if (rlim.rlim_max > rlim.rlim_cur) {
1050     log_info(LD_NET,"Raising max file descriptors from %lu to %lu.",
1051              (unsigned long)rlim.rlim_cur, (unsigned long)rlim.rlim_max);
1052   }
1053   rlim.rlim_cur = rlim.rlim_max;
1054
1055   if (setrlimit(RLIMIT_NOFILE, &rlim) != 0) {
1056     int bad = 1;
1057 #ifdef OPEN_MAX
1058     if (errno == EINVAL && OPEN_MAX < rlim.rlim_cur) {
1059       /* On some platforms, OPEN_MAX is the real limit, and getrlimit() is
1060        * full of nasty lies.  I'm looking at you, OSX 10.5.... */
1061       rlim.rlim_cur = OPEN_MAX;
1062       if (setrlimit(RLIMIT_NOFILE, &rlim) == 0) {
1063         if (rlim.rlim_cur < (rlim_t)limit) {
1064           log_warn(LD_CONFIG, "We are limited to %lu file descriptors by "
1065                  "OPEN_MAX, and ConnLimit is %lu.  Changing ConnLimit; sorry.",
1066                    (unsigned long)OPEN_MAX, (unsigned long)limit);
1067         } else {
1068           log_info(LD_CONFIG, "Dropped connection limit to OPEN_MAX (%lu); "
1069                    "Apparently, %lu was too high and rlimit lied to us.",
1070                    (unsigned long)OPEN_MAX, (unsigned long)rlim.rlim_max);
1071         }
1072         bad = 0;
1073       }
1074     }
1075 #endif /* OPEN_MAX */
1076     if (bad) {
1077       log_warn(LD_CONFIG,"Couldn't set maximum number of file descriptors: %s",
1078                strerror(errno));
1079       return -1;
1080     }
1081   }
1082   /* leave some overhead for logs, etc, */
1083   limit = rlim.rlim_cur;
1084 #endif /* HAVE_GETRLIMIT */
1085
1086   if (limit < ULIMIT_BUFFER) {
1087     log_warn(LD_CONFIG,
1088              "ConnLimit must be at least %d. Failing.", ULIMIT_BUFFER);
1089     return -1;
1090   }
1091   if (limit > INT_MAX)
1092     limit = INT_MAX;
1093   tor_assert(max_out);
1094   *max_out = (int)limit - ULIMIT_BUFFER;
1095   return 0;
1096 }
1097
1098 #ifndef MS_WINDOWS
1099 /** Log details of current user and group credentials. Return 0 on
1100  * success. Logs and return -1 on failure.
1101  */
1102 static int
1103 log_credential_status(void)
1104 {
1105 #define CREDENTIAL_LOG_LEVEL LOG_INFO
1106   /* Real, effective and saved UIDs */
1107   uid_t ruid, euid, suid;
1108   /* Read, effective and saved GIDs */
1109   gid_t rgid, egid, sgid;
1110   /* Supplementary groups */
1111   gid_t sup_gids[NGROUPS_MAX + 1];
1112   /* Number of supplementary groups */
1113   int ngids;
1114
1115   /* log UIDs */
1116 #ifdef HAVE_GETRESUID
1117   if (getresuid(&ruid, &euid, &suid) != 0 ) {
1118     log_warn(LD_GENERAL, "Error getting changed UIDs: %s", strerror(errno));
1119     return -1;
1120   } else {
1121     log_fn(CREDENTIAL_LOG_LEVEL, LD_GENERAL,
1122            "UID is %u (real), %u (effective), %u (saved)",
1123            (unsigned)ruid, (unsigned)euid, (unsigned)suid);
1124   }
1125 #else
1126   /* getresuid is not present on MacOS X, so we can't get the saved (E)UID */
1127   ruid = getuid();
1128   euid = geteuid();
1129   (void)suid;
1130
1131   log_fn(CREDENTIAL_LOG_LEVEL, LD_GENERAL,
1132          "UID is %u (real), %u (effective), unknown (saved)",
1133          (unsigned)ruid, (unsigned)euid);
1134 #endif
1135
1136   /* log GIDs */
1137 #ifdef HAVE_GETRESGID
1138   if (getresgid(&rgid, &egid, &sgid) != 0 ) {
1139     log_warn(LD_GENERAL, "Error getting changed GIDs: %s", strerror(errno));
1140     return -1;
1141   } else {
1142     log_fn(CREDENTIAL_LOG_LEVEL, LD_GENERAL,
1143            "GID is %u (real), %u (effective), %u (saved)",
1144            (unsigned)rgid, (unsigned)egid, (unsigned)sgid);
1145   }
1146 #else
1147   /* getresgid is not present on MacOS X, so we can't get the saved (E)GID */
1148   rgid = getgid();
1149   egid = getegid();
1150   (void)sgid;
1151   log_fn(CREDENTIAL_LOG_LEVEL, LD_GENERAL,
1152          "GID is %u (real), %u (effective), unknown (saved)",
1153          (unsigned)rgid, (unsigned)egid);
1154 #endif
1155
1156   /* log supplementary groups */
1157   if ((ngids = getgroups(NGROUPS_MAX + 1, sup_gids)) < 0) {
1158     log_warn(LD_GENERAL, "Error getting supplementary GIDs: %s",
1159              strerror(errno));
1160     return -1;
1161   } else {
1162     int i, retval = 0;
1163     char *strgid;
1164     char *s = NULL;
1165     smartlist_t *elts = smartlist_create();
1166
1167     for (i = 0; i<ngids; i++) {
1168       strgid = tor_malloc(11);
1169       if (tor_snprintf(strgid, 11, "%u", (unsigned)sup_gids[i]) < 0) {
1170         log_warn(LD_GENERAL, "Error printing supplementary GIDs");
1171         tor_free(strgid);
1172         retval = -1;
1173         goto error;
1174       }
1175       smartlist_add(elts, strgid);
1176     }
1177
1178     s = smartlist_join_strings(elts, " ", 0, NULL);
1179
1180     log_fn(CREDENTIAL_LOG_LEVEL, LD_GENERAL, "Supplementary groups are: %s",s);
1181
1182    error:
1183     tor_free(s);
1184     SMARTLIST_FOREACH(elts, char *, cp,
1185     {
1186       tor_free(cp);
1187     });
1188     smartlist_free(elts);
1189
1190     return retval;
1191   }
1192
1193   return 0;
1194 }
1195 #endif
1196
1197 /** Call setuid and setgid to run as <b>user</b> and switch to their
1198  * primary group.  Return 0 on success.  On failure, log and return -1.
1199  */
1200 int
1201 switch_id(const char *user)
1202 {
1203 #ifndef MS_WINDOWS
1204   struct passwd *pw = NULL;
1205   uid_t old_uid;
1206   gid_t old_gid;
1207   static int have_already_switched_id = 0;
1208
1209   tor_assert(user);
1210
1211   if (have_already_switched_id)
1212     return 0;
1213
1214   /* Log the initial credential state */
1215   if (log_credential_status())
1216     return -1;
1217
1218   log_fn(CREDENTIAL_LOG_LEVEL, LD_GENERAL, "Changing user and groups");
1219
1220   /* Get old UID/GID to check if we changed correctly */
1221   old_uid = getuid();
1222   old_gid = getgid();
1223
1224   /* Lookup the user and group information, if we have a problem, bail out. */
1225   pw = getpwnam(user);
1226   if (pw == NULL) {
1227     log_warn(LD_CONFIG, "Error setting configured user: %s not found", user);
1228     return -1;
1229   }
1230
1231   /* Properly switch egid,gid,euid,uid here or bail out */
1232   if (setgroups(1, &pw->pw_gid)) {
1233     log_warn(LD_GENERAL, "Error setting groups to gid %d: \"%s\".",
1234              (int)pw->pw_gid, strerror(errno));
1235     if (old_uid == pw->pw_uid) {
1236       log_warn(LD_GENERAL, "Tor is already running as %s.  You do not need "
1237                "the \"User\" option if you are already running as the user "
1238                "you want to be.  (If you did not set the User option in your "
1239                "torrc, check whether it was specified on the command line "
1240                "by a startup script.)", user);
1241     } else {
1242       log_warn(LD_GENERAL, "If you set the \"User\" option, you must start Tor"
1243                " as root.");
1244     }
1245     return -1;
1246   }
1247
1248   if (setegid(pw->pw_gid)) {
1249     log_warn(LD_GENERAL, "Error setting egid to %d: %s",
1250              (int)pw->pw_gid, strerror(errno));
1251     return -1;
1252   }
1253
1254   if (setgid(pw->pw_gid)) {
1255     log_warn(LD_GENERAL, "Error setting gid to %d: %s",
1256              (int)pw->pw_gid, strerror(errno));
1257     return -1;
1258   }
1259
1260   if (setuid(pw->pw_uid)) {
1261     log_warn(LD_GENERAL, "Error setting configured uid to %s (%d): %s",
1262              user, (int)pw->pw_uid, strerror(errno));
1263     return -1;
1264   }
1265
1266   if (seteuid(pw->pw_uid)) {
1267     log_warn(LD_GENERAL, "Error setting configured euid to %s (%d): %s",
1268              user, (int)pw->pw_uid, strerror(errno));
1269     return -1;
1270   }
1271
1272   /* This is how OpenBSD rolls:
1273   if (setgroups(1, &pw->pw_gid) || setegid(pw->pw_gid) ||
1274       setgid(pw->pw_gid) || setuid(pw->pw_uid) || seteuid(pw->pw_uid)) {
1275       setgid(pw->pw_gid) || seteuid(pw->pw_uid) || setuid(pw->pw_uid)) {
1276     log_warn(LD_GENERAL, "Error setting configured UID/GID: %s",
1277     strerror(errno));
1278     return -1;
1279   }
1280   */
1281
1282   /* We've properly switched egid, gid, euid, uid, and supplementary groups if
1283    * we're here. */
1284
1285 #if !defined(CYGWIN) && !defined(__CYGWIN__)
1286   /* If we tried to drop privilege to a group/user other than root, attempt to
1287    * restore root (E)(U|G)ID, and abort if the operation succeeds */
1288
1289   /* Only check for privilege dropping if we were asked to be non-root */
1290   if (pw->pw_uid) {
1291     /* Try changing GID/EGID */
1292     if (pw->pw_gid != old_gid &&
1293         (setgid(old_gid) != -1 || setegid(old_gid) != -1)) {
1294       log_warn(LD_GENERAL, "Was able to restore group credentials even after "
1295                "switching GID: this means that the setgid code didn't work.");
1296       return -1;
1297     }
1298
1299     /* Try changing UID/EUID */
1300     if (pw->pw_uid != old_uid &&
1301         (setuid(old_uid) != -1 || seteuid(old_uid) != -1)) {
1302       log_warn(LD_GENERAL, "Was able to restore user credentials even after "
1303                "switching UID: this means that the setuid code didn't work.");
1304       return -1;
1305     }
1306   }
1307 #endif
1308
1309   /* Check what really happened */
1310   if (log_credential_status()) {
1311     return -1;
1312   }
1313
1314   have_already_switched_id = 1; /* mark success so we never try again */
1315
1316 #if defined(__linux__) && defined(HAVE_SYS_PRCTL_H) && defined(HAVE_PRCTL)
1317 #ifdef PR_SET_DUMPABLE
1318   if (pw->pw_uid) {
1319     /* Re-enable core dumps if we're not running as root. */
1320     log_info(LD_CONFIG, "Re-enabling coredumps");
1321     if (prctl(PR_SET_DUMPABLE, 1)) {
1322       log_warn(LD_CONFIG, "Unable to re-enable coredumps: %s",strerror(errno));
1323     }
1324   }
1325 #endif
1326 #endif
1327   return 0;
1328
1329 #else
1330   (void)user;
1331
1332   log_warn(LD_CONFIG,
1333            "User specified but switching users is unsupported on your OS.");
1334   return -1;
1335 #endif
1336 }
1337
1338 #ifdef HAVE_PWD_H
1339 /** Allocate and return a string containing the home directory for the
1340  * user <b>username</b>. Only works on posix-like systems. */
1341 char *
1342 get_user_homedir(const char *username)
1343 {
1344   struct passwd *pw;
1345   tor_assert(username);
1346
1347   if (!(pw = getpwnam(username))) {
1348     log_err(LD_CONFIG,"User \"%s\" not found.", username);
1349     return NULL;
1350   }
1351   return tor_strdup(pw->pw_dir);
1352 }
1353 #endif
1354
1355 /** Set *addr to the IP address (in dotted-quad notation) stored in c.
1356  * Return 1 on success, 0 if c is badly formatted.  (Like inet_aton(c,addr),
1357  * but works on Windows and Solaris.)
1358  */
1359 int
1360 tor_inet_aton(const char *str, struct in_addr* addr)
1361 {
1362   unsigned a,b,c,d;
1363   char more;
1364   if (tor_sscanf(str, "%3u.%3u.%3u.%3u%c", &a,&b,&c,&d,&more) != 4)
1365     return 0;
1366   if (a > 255) return 0;
1367   if (b > 255) return 0;
1368   if (c > 255) return 0;
1369   if (d > 255) return 0;
1370   addr->s_addr = htonl((a<<24) | (b<<16) | (c<<8) | d);
1371   return 1;
1372 }
1373
1374 /** Given <b>af</b>==AF_INET and <b>src</b> a struct in_addr, or
1375  * <b>af</b>==AF_INET6 and <b>src</b> a struct in6_addr, try to format the
1376  * address and store it in the <b>len</b>-byte buffer <b>dst</b>.  Returns
1377  * <b>dst</b> on success, NULL on failure.
1378  *
1379  * (Like inet_ntop(af,src,dst,len), but works on platforms that don't have it:
1380  * Tor sometimes needs to format ipv6 addresses even on platforms without ipv6
1381  * support.) */
1382 const char *
1383 tor_inet_ntop(int af, const void *src, char *dst, size_t len)
1384 {
1385   if (af == AF_INET) {
1386     if (tor_inet_ntoa(src, dst, len) < 0)
1387       return NULL;
1388     else
1389       return dst;
1390   } else if (af == AF_INET6) {
1391     const struct in6_addr *addr = src;
1392     char buf[64], *cp;
1393     int longestGapLen = 0, longestGapPos = -1, i,
1394       curGapPos = -1, curGapLen = 0;
1395     uint16_t words[8];
1396     for (i = 0; i < 8; ++i) {
1397       words[i] = (((uint16_t)addr->s6_addr[2*i])<<8) + addr->s6_addr[2*i+1];
1398     }
1399     if (words[0] == 0 && words[1] == 0 && words[2] == 0 && words[3] == 0 &&
1400         words[4] == 0 && ((words[5] == 0 && words[6] && words[7]) ||
1401                           (words[5] == 0xffff))) {
1402       /* This is an IPv4 address. */
1403       if (words[5] == 0) {
1404         tor_snprintf(buf, sizeof(buf), "::%d.%d.%d.%d",
1405                      addr->s6_addr[12], addr->s6_addr[13],
1406                      addr->s6_addr[14], addr->s6_addr[15]);
1407       } else {
1408         tor_snprintf(buf, sizeof(buf), "::%x:%d.%d.%d.%d", words[5],
1409                      addr->s6_addr[12], addr->s6_addr[13],
1410                      addr->s6_addr[14], addr->s6_addr[15]);
1411       }
1412       if (strlen(buf) > len)
1413         return NULL;
1414       strlcpy(dst, buf, len);
1415       return dst;
1416     }
1417     i = 0;
1418     while (i < 8) {
1419       if (words[i] == 0) {
1420         curGapPos = i++;
1421         curGapLen = 1;
1422         while (i<8 && words[i] == 0) {
1423           ++i; ++curGapLen;
1424         }
1425         if (curGapLen > longestGapLen) {
1426           longestGapPos = curGapPos;
1427           longestGapLen = curGapLen;
1428         }
1429       } else {
1430         ++i;
1431       }
1432     }
1433     if (longestGapLen<=1)
1434       longestGapPos = -1;
1435
1436     cp = buf;
1437     for (i = 0; i < 8; ++i) {
1438       if (words[i] == 0 && longestGapPos == i) {
1439         if (i == 0)
1440           *cp++ = ':';
1441         *cp++ = ':';
1442         while (i < 8 && words[i] == 0)
1443           ++i;
1444         --i; /* to compensate for loop increment. */
1445       } else {
1446         tor_snprintf(cp, sizeof(buf)-(cp-buf), "%x", (unsigned)words[i]);
1447         cp += strlen(cp);
1448         if (i != 7)
1449           *cp++ = ':';
1450       }
1451     }
1452     *cp = '\0';
1453     if (strlen(buf) > len)
1454       return NULL;
1455     strlcpy(dst, buf, len);
1456     return dst;
1457   } else {
1458     return NULL;
1459   }
1460 }
1461
1462 /** Given <b>af</b>==AF_INET or <b>af</b>==AF_INET6, and a string <b>src</b>
1463  * encoding an IPv4 address or IPv6 address correspondingly, try to parse the
1464  * address and store the result in <b>dst</b> (which must have space for a
1465  * struct in_addr or a struct in6_addr, as appropriate).  Return 1 on success,
1466  * 0 on a bad parse, and -1 on a bad <b>af</b>.
1467  *
1468  * (Like inet_pton(af,src,dst) but works on platforms that don't have it: Tor
1469  * sometimes needs to format ipv6 addresses even on platforms without ipv6
1470  * support.) */
1471 int
1472 tor_inet_pton(int af, const char *src, void *dst)
1473 {
1474   if (af == AF_INET) {
1475     return tor_inet_aton(src, dst);
1476   } else if (af == AF_INET6) {
1477     struct in6_addr *out = dst;
1478     uint16_t words[8];
1479     int gapPos = -1, i, setWords=0;
1480     const char *dot = strchr(src, '.');
1481     const char *eow; /* end of words. */
1482     if (dot == src)
1483       return 0;
1484     else if (!dot)
1485       eow = src+strlen(src);
1486     else {
1487       unsigned byte1,byte2,byte3,byte4;
1488       char more;
1489       for (eow = dot-1; eow >= src && TOR_ISDIGIT(*eow); --eow)
1490         ;
1491       ++eow;
1492
1493       /* We use "scanf" because some platform inet_aton()s are too lax
1494        * about IPv4 addresses of the form "1.2.3" */
1495       if (tor_sscanf(eow, "%3u.%3u.%3u.%3u%c",
1496                      &byte1,&byte2,&byte3,&byte4,&more) != 4)
1497         return 0;
1498
1499       if (byte1 > 255 || byte2 > 255 || byte3 > 255 || byte4 > 255)
1500         return 0;
1501
1502       words[6] = (byte1<<8) | byte2;
1503       words[7] = (byte3<<8) | byte4;
1504       setWords += 2;
1505     }
1506
1507     i = 0;
1508     while (src < eow) {
1509       if (i > 7)
1510         return 0;
1511       if (TOR_ISXDIGIT(*src)) {
1512         char *next;
1513         long r = strtol(src, &next, 16);
1514         if (next > 4+src)
1515           return 0;
1516         if (next == src)
1517           return 0;
1518         if (r<0 || r>65536)
1519           return 0;
1520
1521         words[i++] = (uint16_t)r;
1522         setWords++;
1523         src = next;
1524         if (*src != ':' && src != eow)
1525           return 0;
1526         ++src;
1527       } else if (*src == ':' && i > 0 && gapPos==-1) {
1528         gapPos = i;
1529         ++src;
1530       } else if (*src == ':' && i == 0 && src[1] == ':' && gapPos==-1) {
1531         gapPos = i;
1532         src += 2;
1533       } else {
1534         return 0;
1535       }
1536     }
1537
1538     if (setWords > 8 ||
1539         (setWords == 8 && gapPos != -1) ||
1540         (setWords < 8 && gapPos == -1))
1541       return 0;
1542
1543     if (gapPos >= 0) {
1544       int nToMove = setWords - (dot ? 2 : 0) - gapPos;
1545       int gapLen = 8 - setWords;
1546       tor_assert(nToMove >= 0);
1547       memmove(&words[gapPos+gapLen], &words[gapPos],
1548               sizeof(uint16_t)*nToMove);
1549       memset(&words[gapPos], 0, sizeof(uint16_t)*gapLen);
1550     }
1551     for (i = 0; i < 8; ++i) {
1552       out->s6_addr[2*i  ] = words[i] >> 8;
1553       out->s6_addr[2*i+1] = words[i] & 0xff;
1554     }
1555
1556     return 1;
1557   } else {
1558     return -1;
1559   }
1560 }
1561
1562 /** Similar behavior to Unix gethostbyname: resolve <b>name</b>, and set
1563  * *<b>addr</b> to the proper IP address, in host byte order.  Returns 0
1564  * on success, -1 on failure; 1 on transient failure.
1565  *
1566  * (This function exists because standard windows gethostbyname
1567  * doesn't treat raw IP addresses properly.)
1568  */
1569 int
1570 tor_lookup_hostname(const char *name, uint32_t *addr)
1571 {
1572   tor_addr_t myaddr;
1573   int ret;
1574
1575   if ((ret = tor_addr_lookup(name, AF_INET, &myaddr)))
1576     return ret;
1577
1578   if (tor_addr_family(&myaddr) == AF_INET) {
1579     *addr = tor_addr_to_ipv4h(&myaddr);
1580     return ret;
1581   }
1582
1583   return -1;
1584 }
1585
1586 /** Hold the result of our call to <b>uname</b>. */
1587 static char uname_result[256];
1588 /** True iff uname_result is set. */
1589 static int uname_result_is_set = 0;
1590
1591 /** Return a pointer to a description of our platform.
1592  */
1593 const char *
1594 get_uname(void)
1595 {
1596 #ifdef HAVE_UNAME
1597   struct utsname u;
1598 #endif
1599   if (!uname_result_is_set) {
1600 #ifdef HAVE_UNAME
1601     if (uname(&u) != -1) {
1602       /* (Linux says 0 is success, Solaris says 1 is success) */
1603       tor_snprintf(uname_result, sizeof(uname_result), "%s %s",
1604                u.sysname, u.machine);
1605     } else
1606 #endif
1607       {
1608 #ifdef MS_WINDOWS
1609         OSVERSIONINFOEX info;
1610         int i;
1611         const char *plat = NULL;
1612         const char *extra = NULL;
1613         static struct {
1614           unsigned major; unsigned minor; const char *version;
1615         } win_version_table[] = {
1616           { 6, 0, "Windows \"Longhorn\"" },
1617           { 5, 2, "Windows Server 2003" },
1618           { 5, 1, "Windows XP" },
1619           { 5, 0, "Windows 2000" },
1620           /* { 4, 0, "Windows NT 4.0" }, */
1621           { 4, 90, "Windows Me" },
1622           { 4, 10, "Windows 98" },
1623           /* { 4, 0, "Windows 95" } */
1624           { 3, 51, "Windows NT 3.51" },
1625           { 0, 0, NULL }
1626         };
1627         memset(&info, 0, sizeof(info));
1628         info.dwOSVersionInfoSize = sizeof(info);
1629         if (! GetVersionEx((LPOSVERSIONINFO)&info)) {
1630           strlcpy(uname_result, "Bizarre version of Windows where GetVersionEx"
1631                   " doesn't work.", sizeof(uname_result));
1632           uname_result_is_set = 1;
1633           return uname_result;
1634         }
1635         if (info.dwMajorVersion == 4 && info.dwMinorVersion == 0) {
1636           if (info.dwPlatformId == VER_PLATFORM_WIN32_NT)
1637             plat = "Windows NT 4.0";
1638           else
1639             plat = "Windows 95";
1640           if (info.szCSDVersion[1] == 'B')
1641             extra = "OSR2 (B)";
1642           else if (info.szCSDVersion[1] == 'C')
1643             extra = "OSR2 (C)";
1644         } else {
1645           for (i=0; win_version_table[i].major>0; ++i) {
1646             if (win_version_table[i].major == info.dwMajorVersion &&
1647                 win_version_table[i].minor == info.dwMinorVersion) {
1648               plat = win_version_table[i].version;
1649               break;
1650             }
1651           }
1652         }
1653         if (plat && !strcmp(plat, "Windows 98")) {
1654           if (info.szCSDVersion[1] == 'A')
1655             extra = "SE (A)";
1656           else if (info.szCSDVersion[1] == 'B')
1657             extra = "SE (B)";
1658         }
1659         if (plat) {
1660           if (!extra)
1661             extra = info.szCSDVersion;
1662           tor_snprintf(uname_result, sizeof(uname_result), "%s %s",
1663                        plat, extra);
1664         } else {
1665           if (info.dwMajorVersion > 6 ||
1666               (info.dwMajorVersion==6 && info.dwMinorVersion>0))
1667             tor_snprintf(uname_result, sizeof(uname_result),
1668                       "Very recent version of Windows [major=%d,minor=%d] %s",
1669                       (int)info.dwMajorVersion,(int)info.dwMinorVersion,
1670                       info.szCSDVersion);
1671           else
1672             tor_snprintf(uname_result, sizeof(uname_result),
1673                       "Unrecognized version of Windows [major=%d,minor=%d] %s",
1674                       (int)info.dwMajorVersion,(int)info.dwMinorVersion,
1675                       info.szCSDVersion);
1676         }
1677 #ifdef VER_SUITE_BACKOFFICE
1678         if (info.wProductType == VER_NT_DOMAIN_CONTROLLER) {
1679           strlcat(uname_result, " [domain controller]", sizeof(uname_result));
1680         } else if (info.wProductType == VER_NT_SERVER) {
1681           strlcat(uname_result, " [server]", sizeof(uname_result));
1682         } else if (info.wProductType == VER_NT_WORKSTATION) {
1683           strlcat(uname_result, " [workstation]", sizeof(uname_result));
1684         }
1685 #endif
1686 #else
1687         strlcpy(uname_result, "Unknown platform", sizeof(uname_result));
1688 #endif
1689       }
1690     uname_result_is_set = 1;
1691   }
1692   return uname_result;
1693 }
1694
1695 /*
1696  *   Process control
1697  */
1698
1699 #if defined(USE_PTHREADS)
1700 /** Wraps a void (*)(void*) function and its argument so we can
1701  * invoke them in a way pthreads would expect.
1702  */
1703 typedef struct tor_pthread_data_t {
1704   void (*func)(void *);
1705   void *data;
1706 } tor_pthread_data_t;
1707 /** Given a tor_pthread_data_t <b>_data</b>, call _data-&gt;func(d-&gt;data)
1708  * and free _data.  Used to make sure we can call functions the way pthread
1709  * expects. */
1710 static void *
1711 tor_pthread_helper_fn(void *_data)
1712 {
1713   tor_pthread_data_t *data = _data;
1714   void (*func)(void*);
1715   void *arg;
1716   /* mask signals to worker threads to avoid SIGPIPE, etc */
1717   sigset_t sigs;
1718   /* We're in a subthread; don't handle any signals here. */
1719   sigfillset(&sigs);
1720   pthread_sigmask(SIG_SETMASK, &sigs, NULL);
1721
1722   func = data->func;
1723   arg = data->data;
1724   tor_free(_data);
1725   func(arg);
1726   return NULL;
1727 }
1728 #endif
1729
1730 /** Minimalist interface to run a void function in the background.  On
1731  * Unix calls fork, on win32 calls beginthread.  Returns -1 on failure.
1732  * func should not return, but rather should call spawn_exit.
1733  *
1734  * NOTE: if <b>data</b> is used, it should not be allocated on the stack,
1735  * since in a multithreaded environment, there is no way to be sure that
1736  * the caller's stack will still be around when the called function is
1737  * running.
1738  */
1739 int
1740 spawn_func(void (*func)(void *), void *data)
1741 {
1742 #if defined(USE_WIN32_THREADS)
1743   int rv;
1744   rv = (int)_beginthread(func, 0, data);
1745   if (rv == (int)-1)
1746     return -1;
1747   return 0;
1748 #elif defined(USE_PTHREADS)
1749   pthread_t thread;
1750   tor_pthread_data_t *d;
1751   d = tor_malloc(sizeof(tor_pthread_data_t));
1752   d->data = data;
1753   d->func = func;
1754   if (pthread_create(&thread,NULL,tor_pthread_helper_fn,d))
1755     return -1;
1756   if (pthread_detach(thread))
1757     return -1;
1758   return 0;
1759 #else
1760   pid_t pid;
1761   pid = fork();
1762   if (pid<0)
1763     return -1;
1764   if (pid==0) {
1765     /* Child */
1766     func(data);
1767     tor_assert(0); /* Should never reach here. */
1768     return 0; /* suppress "control-reaches-end-of-non-void" warning. */
1769   } else {
1770     /* Parent */
1771     return 0;
1772   }
1773 #endif
1774 }
1775
1776 /** End the current thread/process.
1777  */
1778 void
1779 spawn_exit(void)
1780 {
1781 #if defined(USE_WIN32_THREADS)
1782   _endthread();
1783   //we should never get here. my compiler thinks that _endthread returns, this
1784   //is an attempt to fool it.
1785   tor_assert(0);
1786   _exit(0);
1787 #elif defined(USE_PTHREADS)
1788   pthread_exit(NULL);
1789 #else
1790   /* http://www.erlenstar.demon.co.uk/unix/faq_2.html says we should
1791    * call _exit, not exit, from child processes. */
1792   _exit(0);
1793 #endif
1794
1795 }
1796
1797 /** Set *timeval to the current time of day.  On error, log and terminate.
1798  * (Same as gettimeofday(timeval,NULL), but never returns -1.)
1799  */
1800 void
1801 tor_gettimeofday(struct timeval *timeval)
1802 {
1803 #ifdef MS_WINDOWS
1804   /* Epoch bias copied from perl: number of units between windows epoch and
1805    * Unix epoch. */
1806 #define EPOCH_BIAS U64_LITERAL(116444736000000000)
1807 #define UNITS_PER_SEC U64_LITERAL(10000000)
1808 #define USEC_PER_SEC U64_LITERAL(1000000)
1809 #define UNITS_PER_USEC U64_LITERAL(10)
1810   union {
1811     uint64_t ft_64;
1812     FILETIME ft_ft;
1813   } ft;
1814   /* number of 100-nsec units since Jan 1, 1601 */
1815   GetSystemTimeAsFileTime(&ft.ft_ft);
1816   if (ft.ft_64 < EPOCH_BIAS) {
1817     log_err(LD_GENERAL,"System time is before 1970; failing.");
1818     exit(1);
1819   }
1820   ft.ft_64 -= EPOCH_BIAS;
1821   timeval->tv_sec = (unsigned) (ft.ft_64 / UNITS_PER_SEC);
1822   timeval->tv_usec = (unsigned) ((ft.ft_64 / UNITS_PER_USEC) % USEC_PER_SEC);
1823 #elif defined(HAVE_GETTIMEOFDAY)
1824   if (gettimeofday(timeval, NULL)) {
1825     log_err(LD_GENERAL,"gettimeofday failed.");
1826     /* If gettimeofday dies, we have either given a bad timezone (we didn't),
1827        or segfaulted.*/
1828     exit(1);
1829   }
1830 #elif defined(HAVE_FTIME)
1831   struct timeb tb;
1832   ftime(&tb);
1833   timeval->tv_sec = tb.time;
1834   timeval->tv_usec = tb.millitm * 1000;
1835 #else
1836 #error "No way to get time."
1837 #endif
1838   return;
1839 }
1840
1841 #if defined(TOR_IS_MULTITHREADED) && !defined(MS_WINDOWS)
1842 /** Defined iff we need to add locks when defining fake versions of reentrant
1843  * versions of time-related functions. */
1844 #define TIME_FNS_NEED_LOCKS
1845 #endif
1846
1847 #ifndef HAVE_LOCALTIME_R
1848 #ifdef TIME_FNS_NEED_LOCKS
1849 struct tm *
1850 tor_localtime_r(const time_t *timep, struct tm *result)
1851 {
1852   struct tm *r;
1853   static tor_mutex_t *m=NULL;
1854   if (!m) { m=tor_mutex_new(); }
1855   tor_assert(result);
1856   tor_mutex_acquire(m);
1857   r = localtime(timep);
1858   memcpy(result, r, sizeof(struct tm));
1859   tor_mutex_release(m);
1860   return result;
1861 }
1862 #else
1863 struct tm *
1864 tor_localtime_r(const time_t *timep, struct tm *result)
1865 {
1866   struct tm *r;
1867   tor_assert(result);
1868   r = localtime(timep);
1869   memcpy(result, r, sizeof(struct tm));
1870   return result;
1871 }
1872 #endif
1873 #endif
1874
1875 #ifndef HAVE_GMTIME_R
1876 #ifdef TIME_FNS_NEED_LOCKS
1877 struct tm *
1878 tor_gmtime_r(const time_t *timep, struct tm *result)
1879 {
1880   struct tm *r;
1881   static tor_mutex_t *m=NULL;
1882   if (!m) { m=tor_mutex_new(); }
1883   tor_assert(result);
1884   tor_mutex_acquire(m);
1885   r = gmtime(timep);
1886   memcpy(result, r, sizeof(struct tm));
1887   tor_mutex_release(m);
1888   return result;
1889 }
1890 #else
1891 struct tm *
1892 tor_gmtime_r(const time_t *timep, struct tm *result)
1893 {
1894   struct tm *r;
1895   tor_assert(result);
1896   r = gmtime(timep);
1897   memcpy(result, r, sizeof(struct tm));
1898   return result;
1899 }
1900 #endif
1901 #endif
1902
1903 #if defined(USE_WIN32_THREADS)
1904 void
1905 tor_mutex_init(tor_mutex_t *m)
1906 {
1907   InitializeCriticalSection(&m->mutex);
1908 }
1909 void
1910 tor_mutex_uninit(tor_mutex_t *m)
1911 {
1912   DeleteCriticalSection(&m->mutex);
1913 }
1914 void
1915 tor_mutex_acquire(tor_mutex_t *m)
1916 {
1917   tor_assert(m);
1918   EnterCriticalSection(&m->mutex);
1919 }
1920 void
1921 tor_mutex_release(tor_mutex_t *m)
1922 {
1923   LeaveCriticalSection(&m->mutex);
1924 }
1925 unsigned long
1926 tor_get_thread_id(void)
1927 {
1928   return (unsigned long)GetCurrentThreadId();
1929 }
1930 #elif defined(USE_PTHREADS)
1931 /** A mutex attribute that we're going to use to tell pthreads that we want
1932  * "reentrant" mutexes (i.e., once we can re-lock if we're already holding
1933  * them.) */
1934 static pthread_mutexattr_t attr_reentrant;
1935 /** True iff we've called tor_threads_init() */
1936 static int threads_initialized = 0;
1937 /** Initialize <b>mutex</b> so it can be locked.  Every mutex must be set
1938  * up with tor_mutex_init() or tor_mutex_new(); not both. */
1939 void
1940 tor_mutex_init(tor_mutex_t *mutex)
1941 {
1942   int err;
1943   if (PREDICT_UNLIKELY(!threads_initialized))
1944     tor_threads_init();
1945   err = pthread_mutex_init(&mutex->mutex, &attr_reentrant);
1946   if (PREDICT_UNLIKELY(err)) {
1947     log_err(LD_GENERAL, "Error %d creating a mutex.", err);
1948     tor_fragile_assert();
1949   }
1950 }
1951 /** Wait until <b>m</b> is free, then acquire it. */
1952 void
1953 tor_mutex_acquire(tor_mutex_t *m)
1954 {
1955   int err;
1956   tor_assert(m);
1957   err = pthread_mutex_lock(&m->mutex);
1958   if (PREDICT_UNLIKELY(err)) {
1959     log_err(LD_GENERAL, "Error %d locking a mutex.", err);
1960     tor_fragile_assert();
1961   }
1962 }
1963 /** Release the lock <b>m</b> so another thread can have it. */
1964 void
1965 tor_mutex_release(tor_mutex_t *m)
1966 {
1967   int err;
1968   tor_assert(m);
1969   err = pthread_mutex_unlock(&m->mutex);
1970   if (PREDICT_UNLIKELY(err)) {
1971     log_err(LD_GENERAL, "Error %d unlocking a mutex.", err);
1972     tor_fragile_assert();
1973   }
1974 }
1975 /** Clean up the mutex <b>m</b> so that it no longer uses any system
1976  * resources.  Does not free <b>m</b>.  This function must only be called on
1977  * mutexes from tor_mutex_init(). */
1978 void
1979 tor_mutex_uninit(tor_mutex_t *m)
1980 {
1981   int err;
1982   tor_assert(m);
1983   err = pthread_mutex_destroy(&m->mutex);
1984   if (PREDICT_UNLIKELY(err)) {
1985     log_err(LD_GENERAL, "Error %d destroying a mutex.", err);
1986     tor_fragile_assert();
1987   }
1988 }
1989 /** Return an integer representing this thread. */
1990 unsigned long
1991 tor_get_thread_id(void)
1992 {
1993   union {
1994     pthread_t thr;
1995     unsigned long id;
1996   } r;
1997   r.thr = pthread_self();
1998   return r.id;
1999 }
2000 #endif
2001
2002 #ifdef TOR_IS_MULTITHREADED
2003 /** Return a newly allocated, ready-for-use mutex. */
2004 tor_mutex_t *
2005 tor_mutex_new(void)
2006 {
2007   tor_mutex_t *m = tor_malloc_zero(sizeof(tor_mutex_t));
2008   tor_mutex_init(m);
2009   return m;
2010 }
2011 /** Release all storage and system resources held by <b>m</b>. */
2012 void
2013 tor_mutex_free(tor_mutex_t *m)
2014 {
2015   if (!m)
2016     return;
2017   tor_mutex_uninit(m);
2018   tor_free(m);
2019 }
2020 #endif
2021
2022 /* Conditions. */
2023 #ifdef USE_PTHREADS
2024 #if 0
2025 /** Cross-platform condition implementation. */
2026 struct tor_cond_t {
2027   pthread_cond_t cond;
2028 };
2029 /** Return a newly allocated condition, with nobody waiting on it. */
2030 tor_cond_t *
2031 tor_cond_new(void)
2032 {
2033   tor_cond_t *cond = tor_malloc_zero(sizeof(tor_cond_t));
2034   if (pthread_cond_init(&cond->cond, NULL)) {
2035     tor_free(cond);
2036     return NULL;
2037   }
2038   return cond;
2039 }
2040 /** Release all resources held by <b>cond</b>. */
2041 void
2042 tor_cond_free(tor_cond_t *cond)
2043 {
2044   if (!cond)
2045     return;
2046   if (pthread_cond_destroy(&cond->cond)) {
2047     log_warn(LD_GENERAL,"Error freeing condition: %s", strerror(errno));
2048     return;
2049   }
2050   tor_free(cond);
2051 }
2052 /** Wait until one of the tor_cond_signal functions is called on <b>cond</b>.
2053  * All waiters on the condition must wait holding the same <b>mutex</b>.
2054  * Returns 0 on success, negative on failure. */
2055 int
2056 tor_cond_wait(tor_cond_t *cond, tor_mutex_t *mutex)
2057 {
2058   return pthread_cond_wait(&cond->cond, &mutex->mutex) ? -1 : 0;
2059 }
2060 /** Wake up one of the waiters on <b>cond</b>. */
2061 void
2062 tor_cond_signal_one(tor_cond_t *cond)
2063 {
2064   pthread_cond_signal(&cond->cond);
2065 }
2066 /** Wake up all of the waiters on <b>cond</b>. */
2067 void
2068 tor_cond_signal_all(tor_cond_t *cond)
2069 {
2070   pthread_cond_broadcast(&cond->cond);
2071 }
2072 #endif
2073 /** Set up common structures for use by threading. */
2074 void
2075 tor_threads_init(void)
2076 {
2077   if (!threads_initialized) {
2078     pthread_mutexattr_init(&attr_reentrant);
2079     pthread_mutexattr_settype(&attr_reentrant, PTHREAD_MUTEX_RECURSIVE);
2080     threads_initialized = 1;
2081     set_main_thread();
2082   }
2083 }
2084 #elif defined(USE_WIN32_THREADS)
2085 #if 0
2086 static DWORD cond_event_tls_index;
2087 struct tor_cond_t {
2088   CRITICAL_SECTION mutex;
2089   smartlist_t *events;
2090 };
2091 tor_cond_t *
2092 tor_cond_new(void)
2093 {
2094   tor_cond_t *cond = tor_malloc_zero(sizeof(tor_cond_t));
2095   InitializeCriticalSection(&cond->mutex);
2096   cond->events = smartlist_create();
2097   return cond;
2098 }
2099 void
2100 tor_cond_free(tor_cond_t *cond)
2101 {
2102   if (!cond)
2103     return;
2104   DeleteCriticalSection(&cond->mutex);
2105   /* XXXX notify? */
2106   smartlist_free(cond->events);
2107   tor_free(cond);
2108 }
2109 int
2110 tor_cond_wait(tor_cond_t *cond, tor_mutex_t *mutex)
2111 {
2112   HANDLE event;
2113   int r;
2114   tor_assert(cond);
2115   tor_assert(mutex);
2116   event = TlsGetValue(cond_event_tls_index);
2117   if (!event) {
2118     event = CreateEvent(0, FALSE, FALSE, NULL);
2119     TlsSetValue(cond_event_tls_index, event);
2120   }
2121   EnterCriticalSection(&cond->mutex);
2122
2123   tor_assert(WaitForSingleObject(event, 0) == WAIT_TIMEOUT);
2124   tor_assert(!smartlist_isin(cond->events, event));
2125   smartlist_add(cond->events, event);
2126
2127   LeaveCriticalSection(&cond->mutex);
2128
2129   tor_mutex_release(mutex);
2130   r = WaitForSingleObject(event, INFINITE);
2131   tor_mutex_acquire(mutex);
2132
2133   switch (r) {
2134     case WAIT_OBJECT_0: /* we got the mutex normally. */
2135       break;
2136     case WAIT_ABANDONED: /* holding thread exited. */
2137     case WAIT_TIMEOUT: /* Should never happen. */
2138       tor_assert(0);
2139       break;
2140     case WAIT_FAILED:
2141       log_warn(LD_GENERAL, "Failed to acquire mutex: %d",(int) GetLastError());
2142   }
2143   return 0;
2144 }
2145 void
2146 tor_cond_signal_one(tor_cond_t *cond)
2147 {
2148   HANDLE event;
2149   tor_assert(cond);
2150
2151   EnterCriticalSection(&cond->mutex);
2152
2153   if ((event = smartlist_pop_last(cond->events)))
2154     SetEvent(event);
2155
2156   LeaveCriticalSection(&cond->mutex);
2157 }
2158 void
2159 tor_cond_signal_all(tor_cond_t *cond)
2160 {
2161   tor_assert(cond);
2162
2163   EnterCriticalSection(&cond->mutex);
2164   SMARTLIST_FOREACH(cond->events, HANDLE, event, SetEvent(event));
2165   smartlist_clear(cond->events);
2166   LeaveCriticalSection(&cond->mutex);
2167 }
2168 #endif
2169 void
2170 tor_threads_init(void)
2171 {
2172 #if 0
2173   cond_event_tls_index = TlsAlloc();
2174 #endif
2175   set_main_thread();
2176 }
2177 #endif
2178
2179 #if defined(HAVE_MLOCKALL) && HAVE_DECL_MLOCKALL
2180 /** Attempt to raise the current and max rlimit to infinity for our process.
2181  * This only needs to be done once and can probably only be done when we have
2182  * not already dropped privileges.
2183  */
2184 static int
2185 tor_set_max_memlock(void)
2186 {
2187   /* Future consideration for Windows is probably SetProcessWorkingSetSize
2188    * This is similar to setting the memory rlimit of RLIMIT_MEMLOCK
2189    * http://msdn.microsoft.com/en-us/library/ms686234(VS.85).aspx
2190    */
2191
2192   struct rlimit limit;
2193   int ret;
2194
2195   /* Do we want to report current limits first? This is not really needed. */
2196   ret = getrlimit(RLIMIT_MEMLOCK, &limit);
2197   if (ret == -1) {
2198     log_warn(LD_GENERAL, "Could not get RLIMIT_MEMLOCK: %s", strerror(errno));
2199     return -1;
2200   }
2201
2202   /* RLIM_INFINITY is -1 on some platforms. */
2203   limit.rlim_cur = RLIM_INFINITY;
2204   limit.rlim_max = RLIM_INFINITY;
2205
2206   ret = setrlimit(RLIMIT_MEMLOCK, &limit);
2207   if (ret == -1) {
2208     if (errno == EPERM) {
2209       log_warn(LD_GENERAL, "You appear to lack permissions to change memory "
2210                            "limits. Are you root?");
2211       log_warn(LD_GENERAL, "Unable to raise RLIMIT_MEMLOCK: %s",
2212                strerror(errno));
2213     } else {
2214       log_warn(LD_GENERAL, "Could not raise RLIMIT_MEMLOCK: %s",
2215                strerror(errno));
2216     }
2217     return -1;
2218   }
2219
2220   return 0;
2221 }
2222 #endif
2223
2224 /** Attempt to lock all current and all future memory pages.
2225  * This should only be called once and while we're privileged.
2226  * Like mlockall() we return 0 when we're successful and -1 when we're not.
2227  * Unlike mlockall() we return 1 if we've already attempted to lock memory.
2228  */
2229 int
2230 tor_mlockall(void)
2231 {
2232   static int memory_lock_attempted = 0;
2233
2234   if (memory_lock_attempted) {
2235     return 1;
2236   }
2237
2238   memory_lock_attempted = 1;
2239
2240   /*
2241    * Future consideration for Windows may be VirtualLock
2242    * VirtualLock appears to implement mlock() but not mlockall()
2243    *
2244    * http://msdn.microsoft.com/en-us/library/aa366895(VS.85).aspx
2245    */
2246
2247 #if defined(HAVE_MLOCKALL) && HAVE_DECL_MLOCKALL
2248   if (tor_set_max_memlock() == 0) {
2249     /* Perhaps we only want to log this if we're in a verbose mode? */
2250     log_notice(LD_GENERAL, "RLIMIT_MEMLOCK is now set to RLIM_INFINITY.");
2251   }
2252
2253   if (mlockall(MCL_CURRENT|MCL_FUTURE) == 0) {
2254     log_notice(LD_GENERAL, "Insecure OS paging is effectively disabled.");
2255     return 0;
2256   } else {
2257     if (errno == ENOSYS) {
2258       /* Apple - it's 2009! I'm looking at you. Grrr. */
2259       log_notice(LD_GENERAL, "It appears that mlockall() is not available on "
2260                              "your platform.");
2261     } else if (errno == EPERM) {
2262       log_notice(LD_GENERAL, "It appears that you lack the permissions to "
2263                              "lock memory. Are you root?");
2264     }
2265     log_notice(LD_GENERAL, "Unable to lock all current and future memory "
2266                            "pages: %s", strerror(errno));
2267     return -1;
2268   }
2269 #else
2270   log_warn(LD_GENERAL, "Unable to lock memory pages. mlockall() unsupported?");
2271   return -1;
2272 #endif
2273 }
2274
2275 /** Identity of the "main" thread */
2276 static unsigned long main_thread_id = -1;
2277
2278 /** Start considering the current thread to be the 'main thread'.  This has
2279  * no effect on anything besides in_main_thread(). */
2280 void
2281 set_main_thread(void)
2282 {
2283   main_thread_id = tor_get_thread_id();
2284 }
2285 /** Return true iff called from the main thread. */
2286 int
2287 in_main_thread(void)
2288 {
2289   return main_thread_id == tor_get_thread_id();
2290 }
2291
2292 /**
2293  * On Windows, WSAEWOULDBLOCK is not always correct: when you see it,
2294  * you need to ask the socket for its actual errno.  Also, you need to
2295  * get your errors from WSAGetLastError, not errno.  (If you supply a
2296  * socket of -1, we check WSAGetLastError, but don't correct
2297  * WSAEWOULDBLOCKs.)
2298  *
2299  * The upshot of all of this is that when a socket call fails, you
2300  * should call tor_socket_errno <em>at most once</em> on the failing
2301  * socket to get the error.
2302  */
2303 #if defined(MS_WINDOWS)
2304 int
2305 tor_socket_errno(int sock)
2306 {
2307   int optval, optvallen=sizeof(optval);
2308   int err = WSAGetLastError();
2309   if (err == WSAEWOULDBLOCK && sock >= 0) {
2310     if (getsockopt(sock, SOL_SOCKET, SO_ERROR, (void*)&optval, &optvallen))
2311       return err;
2312     if (optval)
2313       return optval;
2314   }
2315   return err;
2316 }
2317 #endif
2318
2319 #if defined(MS_WINDOWS)
2320 #define E(code, s) { code, (s " [" #code " ]") }
2321 struct { int code; const char *msg; } windows_socket_errors[] = {
2322   E(WSAEINTR, "Interrupted function call"),
2323   E(WSAEACCES, "Permission denied"),
2324   E(WSAEFAULT, "Bad address"),
2325   E(WSAEINVAL, "Invalid argument"),
2326   E(WSAEMFILE, "Too many open files"),
2327   E(WSAEWOULDBLOCK,  "Resource temporarily unavailable"),
2328   E(WSAEINPROGRESS, "Operation now in progress"),
2329   E(WSAEALREADY, "Operation already in progress"),
2330   E(WSAENOTSOCK, "Socket operation on nonsocket"),
2331   E(WSAEDESTADDRREQ, "Destination address required"),
2332   E(WSAEMSGSIZE, "Message too long"),
2333   E(WSAEPROTOTYPE, "Protocol wrong for socket"),
2334   E(WSAENOPROTOOPT, "Bad protocol option"),
2335   E(WSAEPROTONOSUPPORT, "Protocol not supported"),
2336   E(WSAESOCKTNOSUPPORT, "Socket type not supported"),
2337   /* What's the difference between NOTSUPP and NOSUPPORT? :) */
2338   E(WSAEOPNOTSUPP, "Operation not supported"),
2339   E(WSAEPFNOSUPPORT,  "Protocol family not supported"),
2340   E(WSAEAFNOSUPPORT, "Address family not supported by protocol family"),
2341   E(WSAEADDRINUSE, "Address already in use"),
2342   E(WSAEADDRNOTAVAIL, "Cannot assign requested address"),
2343   E(WSAENETDOWN, "Network is down"),
2344   E(WSAENETUNREACH, "Network is unreachable"),
2345   E(WSAENETRESET, "Network dropped connection on reset"),
2346   E(WSAECONNABORTED, "Software caused connection abort"),
2347   E(WSAECONNRESET, "Connection reset by peer"),
2348   E(WSAENOBUFS, "No buffer space available"),
2349   E(WSAEISCONN, "Socket is already connected"),
2350   E(WSAENOTCONN, "Socket is not connected"),
2351   E(WSAESHUTDOWN, "Cannot send after socket shutdown"),
2352   E(WSAETIMEDOUT, "Connection timed out"),
2353   E(WSAECONNREFUSED, "Connection refused"),
2354   E(WSAEHOSTDOWN, "Host is down"),
2355   E(WSAEHOSTUNREACH, "No route to host"),
2356   E(WSAEPROCLIM, "Too many processes"),
2357   /* Yes, some of these start with WSA, not WSAE. No, I don't know why. */
2358   E(WSASYSNOTREADY, "Network subsystem is unavailable"),
2359   E(WSAVERNOTSUPPORTED, "Winsock.dll out of range"),
2360   E(WSANOTINITIALISED, "Successful WSAStartup not yet performed"),
2361   E(WSAEDISCON, "Graceful shutdown now in progress"),
2362 #ifdef WSATYPE_NOT_FOUND
2363   E(WSATYPE_NOT_FOUND, "Class type not found"),
2364 #endif
2365   E(WSAHOST_NOT_FOUND, "Host not found"),
2366   E(WSATRY_AGAIN, "Nonauthoritative host not found"),
2367   E(WSANO_RECOVERY, "This is a nonrecoverable error"),
2368   E(WSANO_DATA, "Valid name, no data record of requested type)"),
2369
2370   /* There are some more error codes whose numeric values are marked
2371    * <b>OS dependent</b>. They start with WSA_, apparently for the same
2372    * reason that practitioners of some craft traditions deliberately
2373    * introduce imperfections into their baskets and rugs "to allow the
2374    * evil spirits to escape."  If we catch them, then our binaries
2375    * might not report consistent results across versions of Windows.
2376    * Thus, I'm going to let them all fall through.
2377    */
2378   { -1, NULL },
2379 };
2380 /** There does not seem to be a strerror equivalent for Winsock errors.
2381  * Naturally, we have to roll our own.
2382  */
2383 const char *
2384 tor_socket_strerror(int e)
2385 {
2386   int i;
2387   for (i=0; windows_socket_errors[i].code >= 0; ++i) {
2388     if (e == windows_socket_errors[i].code)
2389       return windows_socket_errors[i].msg;
2390   }
2391   return strerror(e);
2392 }
2393 #endif
2394
2395 /** Called before we make any calls to network-related functions.
2396  * (Some operating systems require their network libraries to be
2397  * initialized.) */
2398 int
2399 network_init(void)
2400 {
2401 #ifdef MS_WINDOWS
2402   /* This silly exercise is necessary before windows will allow
2403    * gethostbyname to work. */
2404   WSADATA WSAData;
2405   int r;
2406   r = WSAStartup(0x101,&WSAData);
2407   if (r) {
2408     log_warn(LD_NET,"Error initializing windows network layer: code was %d",r);
2409     return -1;
2410   }
2411   /* WSAData.iMaxSockets might show the max sockets we're allowed to use.
2412    * We might use it to complain if we're trying to be a server but have
2413    * too few sockets available. */
2414 #endif
2415   return 0;
2416 }
2417
2418 #ifdef MS_WINDOWS
2419 /** Return a newly allocated string describing the windows system error code
2420  * <b>err</b>.  Note that error codes are different from errno.  Error codes
2421  * come from GetLastError() when a winapi call fails.  errno is set only when
2422  * ANSI functions fail.  Whee. */
2423 char *
2424 format_win32_error(DWORD err)
2425 {
2426   LPVOID str = NULL;
2427   char *result;
2428
2429   /* Somebody once decided that this interface was better than strerror(). */
2430   FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
2431                  FORMAT_MESSAGE_FROM_SYSTEM |
2432                  FORMAT_MESSAGE_IGNORE_INSERTS,
2433                  NULL, err,
2434                  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
2435                  (LPTSTR) &str,
2436                  0, NULL);
2437
2438   if (str) {
2439     result = tor_strdup((char*)str);
2440     LocalFree(str); /* LocalFree != free() */
2441   } else {
2442     result = tor_strdup("<unformattable error>");
2443   }
2444   return result;
2445 }
2446 #endif
2447