compat.h 15.1 KB
Newer Older
1
2
3
/* Copyright (c) 2003-2004, Roger Dingledinex
 * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
 * Copyright (c) 2007, The Tor Project, Inc. */
4
5
6
7
8
/* See LICENSE for licensing information */
/* $Id$ */

#ifndef __COMPAT_H
#define __COMPAT_H
9
#define COMPAT_H_ID "$Id$"
10
11
12
13
14
15
16

#include "orconfig.h"
#include "torint.h"
#ifdef MS_WINDOWS
#define WIN32_WINNT 0x400
#define _WIN32_WINNT 0x400
#define WIN32_LEAN_AND_MEAN
17
#if defined(_MSC_VER) && (_MSC_VER < 1300)
18
19
20
21
22
23
24
25
26
#include <winsock.h>
#else
#include <winsock2.h>
#include <ws2tcpip.h>
#endif
#endif
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
27
28
29
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
30
31
32
#ifdef HAVE_TIME_H
#include <time.h>
#endif
33
34
35
#ifdef HAVE_STRING_H
#include <string.h>
#endif
36
37
38
#ifdef HAVE_CTYPE_H
#include <ctype.h>
#endif
39
#include <stdarg.h>
40
41
42
43
44
45
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
46
47
#ifdef HAVE_NETINET6_IN6_H
#include <netinet6/in6.h>
48
#endif
49
50
51
52
53

#ifndef NULL_REP_IS_ZERO_BYTES
#error "It seems your platform does not represent NULL as zero. We can't cope."
#endif

54
55
56
57
#if 'a'!=97 || 'z'!=122 || 'A'!=65 || ' '!=32
#error "It seems that you encode characters in something other than ASCII."
#endif

58
59
60
61
62
/* ===== Compiler compatibility */

/* GCC can check printf types on arbitrary functions. */
#ifdef __GNUC__
#define CHECK_PRINTF(formatIdx, firstArg) \
63
   __attribute__ ((format(printf, formatIdx, firstArg)))
64
65
66
67
68
69
70
71
72
73
74
#else
#define CHECK_PRINTF(formatIdx, firstArg)
#endif

/* inline is __inline on windows. */
#ifdef MS_WINDOWS
#define INLINE __inline
#else
#define INLINE inline
#endif

75
76
77
78
79
80
81
82
/* Try to get a reasonable __func__ substitute in place. */
#if defined(_MSC_VER)
/* MSVC compilers before VC7 don't have __func__ at all; later ones call it
 * __FUNCTION__. */
#if _MSC_VER < 1300
#define __func__ "???"
#else
#define __func__ __FUNCTION__
83
84
#endif

85
86
87
88
89
90
91
92
93
94
#else
/* For platforms where autoconf works, make sure __func__ is defined
 * sanely. */
#ifndef HAVE_MACRO__func__
#ifdef HAVE_MACRO__FUNCTION__
#define __func__ __FUNCTION__
#elif HAVE_MACRO__FUNC__
#define __func__ __FUNC__
#else
#define __func__ "???"
95
#endif
96
#endif /* ifndef MAVE_MACRO__func__ */
Nick Mathewson's avatar
Nick Mathewson committed
97
#endif /* if not windows */
98

99
100
101
#if defined(_MSC_VER) && (_MSC_VER < 1300)
/* MSVC versions before 7 apparently don't believe that you can cast uint64_t
 * to double and really mean it. */
Nick Mathewson's avatar
Nick Mathewson committed
102
extern INLINE double U64_TO_DBL(uint64_t x) {
103
104
105
106
107
108
109
110
111
  int64_t i = (int64_t) x;
  return (i < 0) ? ((double) INT64_MAX) : (double) i;
}
#define DBL_TO_U64(x) ((uint64_t)(int64_t) (x))
#else
#define U64_TO_DBL(x) ((double) (x))
#define DBL_TO_U64(x) ((uint64_t) (x))
#endif

112
/* GCC has several useful attributes. */
113
#if defined(__GNUC__) && __GNUC__ >= 3
114
115
#define ATTR_NORETURN __attribute__((noreturn))
#define ATTR_PURE __attribute__((pure))
116
#define ATTR_CONST __attribute__((const))
117
#define ATTR_MALLOC __attribute__((malloc))
118
#define ATTR_NORETURN __attribute__((noreturn))
119
#define ATTR_NONNULL(x) __attribute__((nonnull x))
120
121
122
123
124
125
/** Macro: Evaluates to <b>exp</b> and hints the compiler that the value
 * of <b>exp</b> will probably be true. */
#define PREDICT_LIKELY(exp) __builtin_expect((exp), 1)
/** Macro: Evaluates to <b>exp</b> and hints the compiler that the value
 * of <b>exp</b> will probably be false. */
#define PREDICT_UNLIKELY(exp) __builtin_expect((exp), 0)
126
127
128
#else
#define ATTR_NORETURN
#define ATTR_PURE
129
#define ATTR_CONST
130
#define ATTR_MALLOC
131
#define ATTR_NORETURN
132
#define ATTR_NONNULL(x)
133
134
#define PREDICT_LIKELY(exp) (exp)
#define PREDICT_UNLIKELY(exp) (exp)
135
136
#endif

137
138
139
140
141
142
143
144
145
146
147
/* Ways to declare macros. */
#define STMT_NIL (void)0
#ifdef __GNUC__
#define STMT_BEGIN (void) ({
#define STMT_END })
#else
#if defined(sun) || defined(__sun__)
#define STMT_BEGIN if (1) {
#define STMT_END } else STMT_NIL
#else
#define STMT_BEGIN do {
148
#define STMT_END } while (0)
149
150
151
#endif
#endif

152
153
154
155
156
157
/* ===== String compatibility */
#ifdef MS_WINDOWS
/* Windows names string functions differently from most other platforms. */
#define strncasecmp strnicmp
#define strcasecmp stricmp
#endif
158
#ifndef HAVE_STRLCAT
159
size_t strlcat(char *dst, const char *src, size_t siz) ATTR_NONNULL((1,2));
160
161
#endif
#ifndef HAVE_STRLCPY
162
size_t strlcpy(char *dst, const char *src, size_t siz) ATTR_NONNULL((1,2));
163
#endif
164

165
#ifdef _MSC_VER
166
167
#define U64_PRINTF_ARG(a) (a)
#define U64_SCANF_ARG(a) (a)
168
#define U64_LITERAL(n) (n ## ui64)
169
#else
170
#define U64_PRINTF_ARG(a) ((long long unsigned int)(a))
Roger Dingledine's avatar
Roger Dingledine committed
171
#define U64_SCANF_ARG(a) ((long long unsigned int*)(a))
172
#define U64_LITERAL(n) (n ## llu)
173
#endif
174

175
176
177
178
179
180
#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__)
#define U64_FORMAT "%I64u"
#else
#define U64_FORMAT "%llu"
#endif

181
182
/** Represents an mmaped file. Allocated via tor_mmap_file; freed with
 * tor_munmap_file. */
183
typedef struct tor_mmap_t {
184
185
  const char *data; /**< Mapping of the file's contents. */
  size_t size; /**< Size of the file. */
186
} tor_mmap_t;
187

188
189
tor_mmap_t *tor_mmap_file(const char *filename) ATTR_NONNULL((1));
void tor_munmap_file(tor_mmap_t *handle) ATTR_NONNULL((1));
190

191
int tor_snprintf(char *str, size_t size, const char *format, ...)
192
193
194
  CHECK_PRINTF(3,4) ATTR_NONNULL((1,3));
int tor_vsnprintf(char *str, size_t size, const char *format, va_list args)
  ATTR_NONNULL((1,3));
195

Nick Mathewson's avatar
Nick Mathewson committed
196
const void *tor_memmem(const void *haystack, size_t hlen, const void *needle,
197
                       size_t nlen)  ATTR_PURE ATTR_NONNULL((1,3));
198
199
200
201
202
203
204
static const void *tor_memstr(const void *haystack, size_t hlen,
                           const char *needle) ATTR_PURE ATTR_NONNULL((1,3));
static INLINE const void *
tor_memstr(const void *haystack, size_t hlen, const char *needle)
{
  return tor_memmem(haystack, hlen, needle, strlen(needle));
}
Nick Mathewson's avatar
Nick Mathewson committed
205

206
#define TOR_ISALPHA(c)   isalpha((int)(unsigned char)(c))
207
#define TOR_ISALNUM(c)   isalnum((int)(unsigned char)(c))
208
209
210
#define TOR_ISSPACE(c)   isspace((int)(unsigned char)(c))
#define TOR_ISXDIGIT(c) isxdigit((int)(unsigned char)(c))
#define TOR_ISDIGIT(c)   isdigit((int)(unsigned char)(c))
Nick Mathewson's avatar
Nick Mathewson committed
211
#define TOR_ISPRINT(c)   isprint((int)(unsigned char)(c))
212
213
#define TOR_ISLOWER(c)   islower((int)(unsigned char)(c))
#define TOR_ISUPPER(c)   isupper((int)(unsigned char)(c))
214

215
216
217
#define TOR_TOLOWER(c)   ((char)tolower((int)(unsigned char)(c)))
#define TOR_TOUPPER(c)   ((char)toupper((int)(unsigned char)(c)))

218
219
220
221
222
223
224
#ifdef MS_WINDOWS
#define _SHORT_FILE_ (tor_fix_source_file(__FILE__))
const char *tor_fix_source_file(const char *fname);
#else
#define _SHORT_FILE_ (__FILE__)
#define tor_fix_source_file(s) (s)
#endif
225

226
227
228
229
230
231
232
233
234
235
/* ===== Time compatibility */
#if !defined(HAVE_GETTIMEOFDAY) && !defined(HAVE_STRUCT_TIMEVAL_TV_SEC)
struct timeval {
  time_t tv_sec;
  unsigned int tv_usec;
};
#endif

void tor_gettimeofday(struct timeval *timeval);

236
237
238
239
240
241
242
243
244
245
246
247
#ifdef HAVE_LOCALTIME_R
#define tor_localtime_r localtime_r
#else
struct tm *tor_localtime_r(const time_t *timep, struct tm *result);
#endif

#ifdef HAVE_GMTIME_R
#define tor_gmtime_r gmtime_r
#else
struct tm *tor_gmtime_r(const time_t *timep, struct tm *result);
#endif

248
249
/* ===== File compatibility */
int replace_file(const char *from, const char *to);
250
int touch_file(const char *fname);
251

252
253
254
255
256
257
#ifdef MS_WINDOWS
#define PATH_SEPARATOR "\\"
#else
#define PATH_SEPARATOR "/"
#endif

258
/* ===== Net compatibility */
259
260
261
262

void tor_close_socket(int s);
int tor_open_socket(int domain, int type, int protocol);
int get_n_open_sockets(void);
263

264
265
266
267
268
269
270
271
#ifdef USE_BSOCKETS
#define tor_socket_send(s, buf, len, flags) bsend(s, buf, len, flags)
#define tor_socket_recv(s, buf, len, flags) brecv(s, buf, len, flags)
#else
#define tor_socket_send(s, buf, len, flags) send(s, buf, len, flags)
#define tor_socket_recv(s, buf, len, flags) recv(s, buf, len, flags)
#endif

272
273
274
275
#if (SIZEOF_SOCKLEN_T == 0)
typedef int socklen_t;
#endif

276
277
/* XXXX020 detect in6_addr correctly on ms_windows; this is a hack. */
#if !defined(HAVE_STRUCT_IN6_ADDR) && !defined(MS_WINDOWS)
278
279
struct in6_addr
{
280
281
282
283
284
285
286
287
  union {
    uint8_t u6_addr8[16];
    uint16_t u6_addr16[8];
    uint32_t u6_addr32[4];
  } in6_u;
#define s6_addr   in6_u.u6_addr8
#define s6_addr16 in6_u.u6_addr16
#define s6_addr32 in6_u.u6_addr32
288
289
290
};
#endif

291
#if defined(__APPLE__) || defined(__darwin__) || defined(__FreeBSD__) \
292
    || defined(__NetBSD__) || defined(__OpenBSD__)
293
/* Many BSD variants seem not to define these. */
294
295
296
297
298
299
300
301
#ifndef s6_addr16
#define s6_addr16 __u6_addr.__u6_addr16
#endif
#ifndef s6_addr32
#define s6_addr32 __u6_addr.__u6_addr32
#endif
#endif

302
303
304
305
#ifndef HAVE_SA_FAMILY_T
typedef uint16_t sa_family_t;
#endif

306
307
/* Apparently, MS and Solaris don't define s6_addr16 or s6_addr32. */
#ifdef HAVE_STRUCT_IN6_ADDR_S6_ADDR32
308
#define S6_ADDR32(x) ((uint32_t*)(x).s6_addr32)
309
310
311
#else
#define S6_ADDR32(x) ((uint32_t*)((char*)&(x).s6_addr))
#endif
312
313
314
315
316
#ifdef HAVE_STRUCT_IN6_ADDR_S6_ADDR16
#define S6_ADDR16(x) ((uint16_t*)(x).s6_addr16)
#else
#define S6_ADDR16(x) ((uint16_t*)((char*)&(x).s6_addr))
#endif
317

318
319
/* XXXX020 detect sockaddr_in6 correctly on ms_windows; this is also a hack. */
#if !defined(HAVE_STRUCT_SOCKADDR_IN6) && !defined(MS_WINDOWS)
320
struct sockaddr_in6 {
321
  sa_family_t sin6_family;
322
323
324
325
326
327
328
329
  uint16_t sin6_port;
  // uint32_t sin6_flowinfo;
  struct in6_addr sin6_addr;
  // uint32_t sin6_scope_id;
};
#endif

typedef uint8_t maskbits_t;
330
struct in_addr;
331
typedef struct tor_addr_t
332
{
333
334
335
336
337
  sa_family_t family;
  union {
    struct in_addr in_addr;
    struct in6_addr in6_addr;
  } addr;
338
339
340
341
342
343
344
} tor_addr_t;

/* XXXX020 rename these. */
static INLINE uint32_t IPV4IP(const tor_addr_t *a);
static INLINE uint32_t IPV4IPh(const tor_addr_t *a);
static INLINE uint32_t IPV4MAPh(const tor_addr_t *a);
static INLINE uint16_t IN_FAMILY(const tor_addr_t *a);
345
346
static INLINE const struct in_addr *IN4_ADDRESS(const tor_addr_t *a);
static INLINE const struct in6_addr *IN6_ADDRESS(const tor_addr_t *a);
347

348
349
350
static INLINE const struct in6_addr *
IN6_ADDRESS(const tor_addr_t *a)
{
351
  return &a->addr.in6_addr;
352
353
354
355
356
}

#define IN6_ADDRESS16(x) S6_ADDR16(*IN6_ADDRESS(x))
#define IN6_ADDRESS32(x) S6_ADDR32(*IN6_ADDRESS(x))

357
358
359
static INLINE uint32_t
IPV4IP(const tor_addr_t *a)
{
360
  return a->addr.in_addr.s_addr;
361
362
363
364
365
366
367
368
369
}
static INLINE uint32_t IPV4IPh(const tor_addr_t *a)
{
  /*XXXX020 remove this function */
  return ntohl(IPV4IP(a));
}
static INLINE uint32_t
IPV4MAPh(const tor_addr_t *a)
{
370
  return ntohl(IN6_ADDRESS32(a)[3]);
371
372
373
374
}
static INLINE uint16_t
IN_FAMILY(const tor_addr_t *a)
{
375
  return a->family;
376
377
}
static INLINE const struct in_addr *
378
IN4_ADDRESS(const tor_addr_t *a)
379
{
380
  return &a->addr.in_addr;
381
382
383
384
385
}

#define INET_NTOA_BUF_LEN 16 /* 255.255.255.255 */
#define TOR_ADDR_BUF_LEN 46 /* ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255 */

386
int tor_inet_aton(const char *cp, struct in_addr *addr) ATTR_NONNULL((1,2));
387
388
const char *tor_inet_ntop(int af, const void *src, char *dst, size_t len);
int tor_inet_pton(int af, const char *src, void *dst);
389
int tor_lookup_hostname(const char *name, uint32_t *addr) ATTR_NONNULL((1,2));
390
391
void set_socket_nonblocking(int socket);
int tor_socketpair(int family, int type, int protocol, int fd[2]);
392
int network_init(void);
393
394
395

int tor_addr_lookup(const char *name, uint16_t family, tor_addr_t *addr_out);

396
397
398
399
400
401
/* For stupid historical reasons, windows sockets have an independent
 * set of errnos, and an independent way to get them.  Also, you can't
 * always believe WSAEWOULDBLOCK.  Use the macros below to compare
 * errnos against expected values, and use tor_socket_errno to find
 * the actual errno after a socket operation fails.
 */
402
#if defined(MS_WINDOWS) && !defined(USE_BSOCKETS)
403
404
405
406
407
408
/** Return true if e is EAGAIN or the local equivalent. */
#define ERRNO_IS_EAGAIN(e)           ((e) == EAGAIN || (e) == WSAEWOULDBLOCK)
/** Return true if e is EINPROGRESS or the local equivalent. */
#define ERRNO_IS_EINPROGRESS(e)      ((e) == WSAEINPROGRESS)
/** Return true if e is EINPROGRESS or the local equivalent as returned by
 * a call to connect(). */
409
410
#define ERRNO_IS_CONN_EINPROGRESS(e) \
  ((e) == WSAEINPROGRESS || (e)== WSAEINVAL || (e) == WSAEWOULDBLOCK)
411
412
413
414
415
416
417
/** Return true if e is EAGAIN or another error indicating that a call to
 * accept() has no pending connections to return. */
#define ERRNO_IS_ACCEPT_EAGAIN(e)    ERRNO_IS_EAGAIN(e)
/** Return true if e is EMFILE or another error indicating that a call to
 * accept() has failed because we're out of fds or something. */
#define ERRNO_IS_ACCEPT_RESOURCE_LIMIT(e) \
  ((e) == WSAEMFILE || (e) == WSAENOBUFS)
418
419
/** Return true if e is EADDRINUSE or the local equivalent. */
#define ERRNO_IS_EADDRINUSE(e)      ((e) == WSAEADDRINUSE)
420
421
422
423
424
425
426
427
428
int tor_socket_errno(int sock);
const char *tor_socket_strerror(int e);
#else
#define ERRNO_IS_EAGAIN(e)           ((e) == EAGAIN)
#define ERRNO_IS_EINPROGRESS(e)      ((e) == EINPROGRESS)
#define ERRNO_IS_CONN_EINPROGRESS(e) ((e) == EINPROGRESS)
#define ERRNO_IS_ACCEPT_EAGAIN(e)    ((e) == EAGAIN || (e) == ECONNABORTED)
#define ERRNO_IS_ACCEPT_RESOURCE_LIMIT(e) \
  ((e) == EMFILE || (e) == ENFILE || (e) == ENOBUFS || (e) == ENOMEM)
429
#define ERRNO_IS_EADDRINUSE(e)       ((e) == EADDRINUSE)
430
431
432
433
434
435
436
#define tor_socket_errno(sock)       (errno)
#define tor_socket_strerror(e)       strerror(e)
#endif

/* ===== OS compatibility */
const char *get_uname(void);

437
438
439
440
uint16_t get_uint16(const char *cp) ATTR_PURE ATTR_NONNULL((1));
uint32_t get_uint32(const char *cp) ATTR_PURE ATTR_NONNULL((1));
void set_uint16(char *cp, uint16_t v) ATTR_NONNULL((1));
void set_uint32(char *cp, uint32_t v) ATTR_NONNULL((1));
441

442
int set_max_file_descriptors(unsigned long limit, unsigned long cap);
443
int switch_id(const char *user, const char *group);
444
445
446
#ifdef HAVE_PWD_H
char *get_user_homedir(const char *username);
#endif
447

448
int spawn_func(void (*func)(void *), void *data);
449
void spawn_exit(void) ATTR_NORETURN;
450

Nick Mathewson's avatar
Nick Mathewson committed
451
#if defined(ENABLE_THREADS) && defined(MS_WINDOWS)
452
453
#define USE_WIN32_THREADS
#define TOR_IS_MULTITHREADED 1
454
455
#elif (defined(ENABLE_THREADS) && defined(HAVE_PTHREAD_H) && \
       defined(HAVE_PTHREAD_CREATE))
456
#define USE_PTHREADS
457
458
459
460
461
#define TOR_IS_MULTITHREADED 1
#else
#undef TOR_IS_MULTITHREADED
#endif

Roger Dingledine's avatar
Roger Dingledine committed
462
463
464
/* Because we use threads instead of processes on most platforms (Windows,
 * Linux, etc), we need locking for them.  On platforms with poor thread
 * support or broken gethostbyname_r, these functions are no-ops. */
465

466
467
468
469
470
471
472
typedef struct tor_mutex_t tor_mutex_t;
#ifdef TOR_IS_MULTITHREADED
tor_mutex_t *tor_mutex_new(void);
void tor_mutex_acquire(tor_mutex_t *m);
void tor_mutex_release(tor_mutex_t *m);
void tor_mutex_free(tor_mutex_t *m);
unsigned long tor_get_thread_id(void);
473
void tor_threads_init(void);
474
475
#else
#define tor_mutex_new() ((tor_mutex_t*)tor_malloc(sizeof(int)))
476
477
478
#define tor_mutex_acquire(m) STMT_NIL
#define tor_mutex_release(m) STMT_NIL
#define tor_mutex_free(m) STMT_BEGIN tor_free(m); STMT_END
479
#define tor_get_thread_id() (1UL)
480
#define tor_threads_init() STMT_NIL
481
482
#endif

483
484
485
#ifdef TOR_IS_MULTITHREADED
typedef struct tor_cond_t tor_cond_t;
tor_cond_t *tor_cond_new(void);
486
void tor_cond_free(tor_cond_t *cond);
487
488
489
490
491
int tor_cond_wait(tor_cond_t *cond, tor_mutex_t *mutex);
void tor_cond_signal_one(tor_cond_t *cond);
void tor_cond_signal_all(tor_cond_t *cond);
#endif

492
493
494
495
496
/* Platform-specific helpers. */
#ifdef MS_WINDOWS
char *format_win32_error(DWORD err);
#endif

497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
/*for some reason my compiler doesn't have these version flags defined
  a nice homework assignment for someone one day is to define the rest*/
//these are the values as given on MSDN
#ifdef MS_WINDOWS

#ifndef VER_SUITE_EMBEDDEDNT
#define VER_SUITE_EMBEDDEDNT 0x00000040
#endif

#ifndef VER_SUITE_SINGLEUSERTS
#define VER_SUITE_SINGLEUSERTS 0x00000100
#endif

#endif

512
#endif
513