util.c 16.1 KB
Newer Older
1
2
3
4
/* Copyright 2003 Roger Dingledine */
/* See LICENSE for licensing information */
/* $Id$ */

5
#include "../or/or.h"
Nick Mathewson's avatar
Nick Mathewson committed
6

7
8
9
#ifdef HAVE_UNAME
#include <sys/utsname.h>
#endif
10

11
/*
12
 *    Memory wrappers
13
14
 */

15
16
17
18
19
20
void *tor_malloc(size_t size) {
  void *result;

  result = malloc(size);

  if(!result) {
21
    log_fn(LOG_ERR, "Out of memory. Dying.");
22
23
    exit(1);
  }
24
//  memset(result,'X',size); /* deadbeef to encourage bugs */
25
26
27
  return result;
}

28
29
30
31
32
33
void *tor_malloc_zero(size_t size) {
  void *result = tor_malloc(size);
  memset(result, 0, size);
  return result;
}

34
35
36
37
38
39
40
41
42
43
44
void *tor_realloc(void *ptr, size_t size) {
  void *result;
  
  result = realloc(ptr, size);
  if (!result) {
    log_fn(LOG_ERR, "Out of memory. Dying.");
    exit(1);
  }
  return result;
}

45
46
47
48
49
50
51
52
53
54
55
56
char *tor_strdup(const char *s) {
  char *dup;
  assert(s);

  dup = strdup(s);
  if(!dup) {
    log_fn(LOG_ERR,"Out of memory. Dying.");
    exit(1);
  }
  return dup;
}

57
58
59
60
61
62
63
64
65
char *tor_strndup(const char *s, size_t n) {
  char *dup;
  assert(s);
  dup = tor_malloc(n+1);
  strncpy(dup, s, n);
  dup[n] = 0;
  return dup;
}

66
67
68
69
70
/*
 *    String manipulation
 */

/* return the first char of s that is not whitespace and not a comment */
71
const char *eat_whitespace(const char *s) {
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
  assert(s);

  while(isspace(*s) || *s == '#') {
    while(isspace(*s))
      s++;
    if(*s == '#') { /* read to a \n or \0 */
      while(*s && *s != '\n')
        s++;
      if(!*s)
        return s;
    }
  }
  return s;
}

87
const char *eat_whitespace_no_nl(const char *s) {
88
89
90
91
92
93
  while(*s == ' ' || *s == '\t') 
    ++s;
  return s;
}

/* return the first char of s that is whitespace or '#' or '\0 */
94
const char *find_whitespace(const char *s) {
95
96
97
98
99
100
101
102
  assert(s);

  while(*s && !isspace(*s) && *s != '#')
    s++;

  return s;
}

103
104
105
106
/*
 *    Time
 */

107
void tor_gettimeofday(struct timeval *timeval) {
108
#ifdef HAVE_GETTIMEOFDAY
109
  if (gettimeofday(timeval, NULL)) {
110
    log_fn(LOG_ERR, "gettimeofday failed.");
111
112
113
114
    /* If gettimeofday dies, we have either given a bad timezone (we didn't),
       or segfaulted.*/
    exit(1);
  }
115
116
117
118
119
#elif defined(HAVE_FTIME)
  ftime(timeval);
#else
#error "No way to get time."
#endif
120
121
122
123
124
125
  return;
}

long
tv_udiff(struct timeval *start, struct timeval *end)
{
Roger Dingledine's avatar
Roger Dingledine committed
126
  long udiff;
127
  long secdiff = end->tv_sec - start->tv_sec;
128

129
  if (secdiff+1 > LONG_MAX/1000000) {
Roger Dingledine's avatar
Roger Dingledine committed
130
    log_fn(LOG_WARN, "comparing times too far apart.");
131
132
    return LONG_MAX;
  }
133

Roger Dingledine's avatar
Roger Dingledine committed
134
  udiff = secdiff*1000000L + (end->tv_usec - start->tv_usec);
Roger Dingledine's avatar
Roger Dingledine committed
135
  if(udiff < 0) {
Roger Dingledine's avatar
Roger Dingledine committed
136
    log_fn(LOG_INFO, "start (%ld.%ld) is after end (%ld.%ld). Returning 0.",
137
           (long)start->tv_sec, (long)start->tv_usec, (long)end->tv_sec, (long)end->tv_usec);
Roger Dingledine's avatar
Roger Dingledine committed
138
139
140
    return 0;
  }
  return udiff;
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
}

int tv_cmp(struct timeval *a, struct timeval *b) {
  if (a->tv_sec > b->tv_sec)
    return 1;
  if (a->tv_sec < b->tv_sec)
    return -1;
  if (a->tv_usec > b->tv_usec)
    return 1;
  if (a->tv_usec < b->tv_usec)
    return -1;
  return 0;
}

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;
}

void tv_addms(struct timeval *a, long ms) {
  a->tv_usec += (ms * 1000) % 1000000;
  a->tv_sec += ((ms * 1000) / 1000000) + (a->tv_usec / 1000000);
  a->tv_usec %= 1000000;
}
166

167
168
169
170
171
172
173
174
175
176

#define IS_LEAPYEAR(y) (!(y % 4) && ((y % 100) || !(y % 400)))
static int n_leapdays(int y1, int y2) {
  --y1;
  --y2;
  return (y2/4 - y1/4) - (y2/100 - y1/100) + (y2/400 - y1/400);
}
static const int days_per_month[] = 
  { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

177
time_t tor_timegm (struct tm *tm) {
178
179
180
  /* This is a pretty ironclad timegm implementation, snarfed from Python2.2. 
   * It's way more brute-force than fiddling with tzset().
   */
181
  time_t ret;
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
  unsigned long year, days, hours, minutes;
  int i;
  year = tm->tm_year + 1900;
  assert(year >= 1970);
  assert(tm->tm_mon >= 0 && tm->tm_mon <= 11);
  days = 365 * (year-1970) + n_leapdays(1970,year);
  for (i = 0; i < tm->tm_mon; ++i)
    days += days_per_month[i];
  if (tm->tm_mon > 1 && IS_LEAPYEAR(year))
    ++days;
  days += tm->tm_mday - 1;
  hours = days*24 + tm->tm_hour;
  
  minutes = hours*60 + tm->tm_min;
  ret = minutes*60 + tm->tm_sec;
197
198
199
  return ret;
}

200
201
202
203
/*
 *   Low-level I/O.
 */

Roger Dingledine's avatar
Roger Dingledine committed
204
/* a wrapper for write(2) that makes sure to write all count bytes.
205
 * Only use if fd is a blocking fd. */
206
int write_all(int fd, const char *buf, size_t count) {
Roger Dingledine's avatar
Roger Dingledine committed
207
208
209
210
211
212
213
214
  int written = 0;
  int result;

  while(written != count) {
    result = write(fd, buf+written, count-written);
    if(result<0)
      return -1;
    written += result;
215
216
217
218
219
  }
  return count;
}

/* a wrapper for read(2) that makes sure to read all count bytes.
220
 * Only use if fd is a blocking fd. */
221
int read_all(int fd, char *buf, size_t count) {
222
223
224
225
226
227
228
229
  int numread = 0;
  int result;

  while(numread != count) {
    result = read(fd, buf+numread, count-numread);
    if(result<=0)
      return -1;
    numread += result;
Roger Dingledine's avatar
Roger Dingledine committed
230
231
232
233
  }
  return count;
}

234
235
void set_socket_nonblocking(int socket)
{
236
#ifdef MS_WINDOWS
237
238
239
240
241
242
243
	/* Yes means no and no means yes.  Do you not want to be nonblocking? */
	int nonblocking = 0;
	ioctlsocket(socket, FIONBIO, (unsigned long*) &nonblocking);
#else
	fcntl(socket, F_SETFL, O_NONBLOCK);
#endif
}
244

245
246
247
248
/*
 *   Process control
 */

249
250
251
252
/* Minimalist interface to run a void function in the background.  On
 * unix calls fork, on win32 calls beginthread.  Returns -1 on failure.
 * func should not return, but rather should call spawn_exit.
 */
253
254
int spawn_func(int (*func)(void *), void *data)
{
255
#ifdef MS_WINDOWS
256
257
258
259
260
261
262
263
264
265
266
267
268
269
  int rv;
  rv = _beginthread(func, 0, data);
  if (rv == (unsigned long) -1)
    return -1;
  return 0;
#else
  pid_t pid;
  pid = fork();
  if (pid<0)
    return -1;
  if (pid==0) {
    /* Child */
    func(data);
    assert(0); /* Should never reach here. */
Nick Mathewson's avatar
Nick Mathewson committed
270
    return 0; /* suppress "control-reaches-end-of-non-void" warning. */
271
272
273
274
275
276
277
278
279
  } else {
    /* Parent */
    return 0;
  }
#endif
}

void spawn_exit()
{
280
#ifdef MS_WINDOWS
281
282
283
284
285
  _endthread();
#else
  exit(0);
#endif
}
286
287


288
289
290
/*
 *   Windows compatibility.
 */
291
292
293
int
tor_socketpair(int family, int type, int protocol, int fd[2])
{
294
#ifdef HAVE_SOCKETPAIR_XXXX
295
296
297
298
299
300
301
302
    /* For testing purposes, we never fall back to real socketpairs. */
    return socketpair(family, type, protocol, fd);
#else
    int listener = -1;
    int connector = -1;
    int acceptor = -1;
    struct sockaddr_in listen_addr;
    struct sockaddr_in connect_addr;
303
    int size;
304
305
306
307
308
309
    
    if (protocol
#ifdef AF_UNIX
        || family != AF_UNIX
#endif
        ) {
310
311
#ifdef MS_WINDOWS
        errno = WSAEAFNOSUPPORT;
Nick Mathewson's avatar
Nick Mathewson committed
312
#else
313
        errno = EAFNOSUPPORT;
Nick Mathewson's avatar
Nick Mathewson committed
314
#endif
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
        return -1;
    }
    if (!fd) {
        errno = EINVAL;
        return -1;
    }

    listener = socket(AF_INET, type, 0);
    if (listener == -1)
      return -1;
    memset (&listen_addr, 0, sizeof (listen_addr));
    listen_addr.sin_family = AF_INET;
    listen_addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
    listen_addr.sin_port = 0;   /* kernel choses port.  */
    if (bind(listener, (struct sockaddr *) &listen_addr, sizeof (listen_addr))
        == -1)
        goto tidy_up_and_fail;
    if (listen(listener, 1) == -1)
        goto tidy_up_and_fail;

    connector = socket(AF_INET, type, 0);
    if (connector == -1)
        goto tidy_up_and_fail;
    /* We want to find out the port number to connect to.  */
    size = sizeof (connect_addr);
    if (getsockname(listener, (struct sockaddr *) &connect_addr, &size) == -1)
        goto tidy_up_and_fail;
    if (size != sizeof (connect_addr))
        goto abort_tidy_up_and_fail;
    if (connect(connector, (struct sockaddr *) &connect_addr,
                sizeof (connect_addr)) == -1)
        goto tidy_up_and_fail;

    size = sizeof (listen_addr);
    acceptor = accept(listener, (struct sockaddr *) &listen_addr, &size);
    if (acceptor == -1)
        goto tidy_up_and_fail;
    if (size != sizeof(listen_addr))
        goto abort_tidy_up_and_fail;
    close(listener);
    /* Now check we are talking to ourself by matching port and host on the
       two sockets.  */
    if (getsockname(connector, (struct sockaddr *) &connect_addr, &size) == -1)
        goto tidy_up_and_fail;
    if (size != sizeof (connect_addr)
        || listen_addr.sin_family != connect_addr.sin_family
        || listen_addr.sin_addr.s_addr != connect_addr.sin_addr.s_addr
        || listen_addr.sin_port != connect_addr.sin_port) {
        goto abort_tidy_up_and_fail;
    }
    fd[0] = connector;
    fd[1] = acceptor;
    return 0;

  abort_tidy_up_and_fail:
370
#ifdef MS_WINDOWS
Nick Mathewson's avatar
Nick Mathewson committed
371
372
  errno = WSAECONNABORTED;
#else
373
  errno = ECONNABORTED; /* I hope this is portable and appropriate.  */
Nick Mathewson's avatar
Nick Mathewson committed
374
#endif
375
376
377
378
379
380
381
382
383
384
385
386
387
388
  tidy_up_and_fail:
    {
        int save_errno = errno;
        if (listener != -1)
            close(listener);
        if (connector != -1)
	    close(connector);
        if (acceptor != -1)
            close(acceptor);
        errno = save_errno;
        return -1;
    }
#endif
}
389
390
391
392

#ifdef MS_WINDOWS
int correct_socket_errno(int s)
{
Nick Mathewson's avatar
Nick Mathewson committed
393
  int optval, optvallen=sizeof(optval);
394
395
396
397
398
399
400
401
  assert(errno == WSAEWOULDBLOCK);
  if (getsockopt(s, SOL_SOCKET, SO_ERROR, (void*)&optval, &optvallen))
    return errno;
  if (optval)
    return optval;
  return WSAEWOULDBLOCK;
}
#endif
402
403
404
405

/*
 *    Filesystem operations.
 */
406
407
408
409

/* Return FN_ERROR if filename can't be read, FN_NOENT if it doesn't
 * exist, FN_FILE if it is a regular file, or FN_DIR if it's a
 * directory. */
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
file_status_t file_status(const char *fname)
{
  struct stat st;
  if (stat(fname, &st)) {
    if (errno == ENOENT) {
      return FN_NOENT;
    }
    return FN_ERROR;
  }
  if (st.st_mode & S_IFDIR) 
    return FN_DIR;
  else if (st.st_mode & S_IFREG)
    return FN_FILE;
  else
    return FN_ERROR;
}

427
428
/* Check whether dirname exists and is private.  If yes returns
   0.  Else returns -1. */
429
430
431
432
433
int check_private_dir(const char *dirname, int create)
{
  struct stat st;
  if (stat(dirname, &st)) {
    if (errno != ENOENT) {
Roger Dingledine's avatar
Roger Dingledine committed
434
      log(LOG_WARN, "Directory %s cannot be read: %s", dirname, 
435
436
437
438
          strerror(errno));
      return -1;
    } 
    if (!create) {
Roger Dingledine's avatar
Roger Dingledine committed
439
      log(LOG_WARN, "Directory %s does not exist.", dirname);
440
441
442
443
      return -1;
    }
    log(LOG_INFO, "Creating directory %s", dirname); 
    if (mkdir(dirname, 0700)) {
Roger Dingledine's avatar
Roger Dingledine committed
444
      log(LOG_WARN, "Error creating directory %s: %s", dirname, 
445
446
447
448
449
450
451
          strerror(errno));
      return -1;
    } else {
      return 0;
    }
  }
  if (!(st.st_mode & S_IFDIR)) {
Roger Dingledine's avatar
Roger Dingledine committed
452
    log(LOG_WARN, "%s is not a directory", dirname);
453
454
455
    return -1;
  }
  if (st.st_uid != getuid()) {
Roger Dingledine's avatar
Roger Dingledine committed
456
    log(LOG_WARN, "%s is not owned by this UID (%d)", dirname, getuid());
457
458
459
    return -1;
  }
  if (st.st_mode & 0077) {
Roger Dingledine's avatar
Roger Dingledine committed
460
    log(LOG_WARN, "Fixing permissions on directory %s", dirname);
461
    if (chmod(dirname, 0700)) {
Roger Dingledine's avatar
Roger Dingledine committed
462
      log(LOG_WARN, "Could not chmod directory %s: %s", dirname, 
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
          strerror(errno));
      return -1;
    } else {
      return 0;
    }
  }
  return 0;
}

int
write_str_to_file(const char *fname, const char *str)
{
  char tempname[1024];
  int fd;
  FILE *file;
  if (strlen(fname) > 1000) {
Roger Dingledine's avatar
Roger Dingledine committed
479
    log(LOG_WARN, "Filename %s is too long.", fname);
480
481
482
483
484
    return -1;
  }
  strcpy(tempname,fname);
  strcat(tempname,".tmp");
  if ((fd = open(tempname, O_WRONLY|O_CREAT|O_TRUNC, 0600)) < 0) {
Roger Dingledine's avatar
Roger Dingledine committed
485
    log(LOG_WARN, "Couldn't open %s for writing: %s", tempname, 
486
487
488
489
        strerror(errno));
    return -1;
  }
  if (!(file = fdopen(fd, "w"))) {
Roger Dingledine's avatar
Roger Dingledine committed
490
    log(LOG_WARN, "Couldn't fdopen %s for writing: %s", tempname, 
491
492
493
        strerror(errno));
    close(fd); return -1;
  }
Roger Dingledine's avatar
Roger Dingledine committed
494
  if (fputs(str,file) == EOF) {
Roger Dingledine's avatar
Roger Dingledine committed
495
    log(LOG_WARN, "Error writing to %s: %s", tempname, strerror(errno));
496
497
498
499
    fclose(file); return -1;
  }
  fclose(file);
  if (rename(tempname, fname)) {
Roger Dingledine's avatar
Roger Dingledine committed
500
    log(LOG_WARN, "Error replacing %s: %s", fname, strerror(errno));
501
502
503
504
    return -1;
  }
  return 0;
}
505
506
507
508
509
510
511
512
513

char *read_file_to_str(const char *filename) {
  int fd; /* router file */
  struct stat statbuf;
  char *string;

  assert(filename);

  if(strcspn(filename,CONFIG_LEGAL_FILENAME_CHARACTERS) != 0) {
Roger Dingledine's avatar
Roger Dingledine committed
514
    log_fn(LOG_WARN,"Filename %s contains illegal characters.",filename);
515
516
517
518
    return NULL;
  }
  
  if(stat(filename, &statbuf) < 0) {
519
    log_fn(LOG_INFO,"Could not stat %s.",filename);
520
521
522
523
524
    return NULL;
  }

  fd = open(filename,O_RDONLY,0);
  if (fd<0) {
Roger Dingledine's avatar
Roger Dingledine committed
525
    log_fn(LOG_WARN,"Could not open %s.",filename);
526
527
528
529
530
531
    return NULL;
  }

  string = tor_malloc(statbuf.st_size+1);

  if(read_all(fd,string,statbuf.st_size) != statbuf.st_size) {
Roger Dingledine's avatar
Roger Dingledine committed
532
    log_fn(LOG_WARN,"Couldn't read all %ld bytes of file '%s'.",
533
534
535
536
537
538
539
540
541
542
543
           (long)statbuf.st_size,filename);
    free(string);
    close(fd);
    return NULL;
  }
  close(fd);
  
  string[statbuf.st_size] = 0; /* null terminate it */
  return string;
}

544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
/* read lines from f (no more than maxlen-1 bytes each) until we
 * get one with a well-formed "key value".
 * point *key to the first word in line, point *value to the second.
 * Put a \0 at the end of key, remove everything at the end of value
 * that is whitespace or comment.
 * Return 1 if success, 0 if no more lines, -1 if error.
 */
int parse_line_from_file(char *line, int maxlen, FILE *f, char **key_out, char **value_out) {
  char *s, *key, *end, *value;

try_next_line:
  if(!fgets(line, maxlen, f)) {
    if(feof(f))
      return 0;
    return -1; /* real error */
  }

  if((s = strchr(line,'#'))) /* strip comments */
    *s = 0; /* stop the line there */

  /* remove end whitespace */
  s = strchr(line, 0); /* now we're at the null */
  do {
    *s = 0;
    s--;
569
  } while (s >= line && isspace(*s));
570
571
572
573
574
575
576
577
578
579
580
581
582
583

  key = line;
  while(isspace(*key))
    key++;
  if(*key == 0)
    goto try_next_line; /* this line has nothing on it */
  end = key;
  while(*end && !isspace(*end))
    end++;
  value = end;
  while(*value && isspace(*value))
    value++;

  if(!*end || !*value) { /* only a key on this line. no value. */
Nick Mathewson's avatar
Nick Mathewson committed
584
585
    *end = 0;
    log_fn(LOG_WARN,"Line has keyword '%s' but no value. Skipping.",key);
586
587
588
589
590
591
592
593
594
    goto try_next_line;
  }
  *end = 0; /* null it out */

  log_fn(LOG_DEBUG,"got keyword '%s', value '%s'", key, value);
  *key_out = key, *value_out = value;
  return 1;
}

595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
static char uname_result[256];
static int uname_result_is_set = 0;

const char *
get_uname(void)
{
#ifdef HAVE_UNAME
  struct utsname u;
#endif
  if (!uname_result_is_set) {
#ifdef HAVE_UNAME
    if (!uname((&u))) {
      snprintf(uname_result, 255, "%s %s %s %s %s",
               u.sysname, u.nodename, u.release, u.version, u.machine);
      uname_result[255] = '\0';
    } else 
#endif
      {
        strcpy(uname_result, "Unknown platform");
      }
    uname_result_is_set = 1;
  }
  return uname_result;
}
      
620
void daemonize(void) {
621
622
623
624
625
626
627
#ifdef HAVE_DAEMON
  if (daemon(0 /* chdir to / */,
	     0 /* Redirect std* to /dev/null */)) {
    log_fn(LOG_ERR, "Daemon returned an error: %s", strerror(errno));
    exit(1);
  }
#elif ! defined(MS_WINDOWS)
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
  /* Fork; parent exits. */
  if (fork())
    exit(0);

  /* Create new session; make sure we never get a terminal */
  setsid();
  if (fork())
    exit(0);

  chdir("/");
  umask(000);

  fclose(stdin);
  fclose(stdout);
  fclose(stderr);
#endif
}

void write_pidfile(char *filename) {
#ifndef MS_WINDOWS
  FILE *pidfile;

  if ((pidfile = fopen(filename, "w")) == NULL) {
    log_fn(LOG_WARN, "unable to open %s for writing: %s", filename,
           strerror(errno));
  } else {
    fprintf(pidfile, "%d", getpid());
    fclose(pidfile);
  }
#endif
}

int switch_id(char *user, char *group) {
#ifndef MS_WINDOWS
  struct passwd *pw = NULL;
  struct group *gr = NULL;

  if (user) {
    pw = getpwnam(user);
    if (pw == NULL) {
      log_fn(LOG_ERR,"User '%s' not found.", user);
      return -1;
    }
  }

Roger Dingledine's avatar
Roger Dingledine committed
673
  /* switch the group first, while we still have the privileges to do so */
674
675
676
677
678
679
680
  if (group) {
    gr = getgrnam(group);
    if (gr == NULL) {
      log_fn(LOG_ERR,"Group '%s' not found.", group);
      return -1;
    }

681
    if (setgid(gr->gr_gid) != 0) {
682
683
684
685
      log_fn(LOG_ERR,"Error setting GID: %s", strerror(errno));
      return -1;
    }
  } else if (user) {
686
    if (setgid(pw->pw_gid) != 0) {
687
688
689
690
691
692
      log_fn(LOG_ERR,"Error setting GID: %s", strerror(errno));
      return -1;
    }
  }

  /* now that the group is switched, we can switch users and lose
693
     privileges */
694
  if (user) {
695
    if (setuid(pw->pw_uid) != 0) {
696
697
698
699
700
701
702
703
704
      log_fn(LOG_ERR,"Error setting UID: %s", strerror(errno));
      return -1;
    }
  }

  return 0;
#endif

  log_fn(LOG_ERR, 
705
         "User or group specified, but switching users is not supported.");
706
707
708

  return -1;
}
709