compat.h 7.97 KB
Newer Older
Nick Mathewson's avatar
Nick Mathewson committed
1
2
/* Copyright 2003-2004 Roger Dingledinex
 * Copyright 2004-2005 Roger Dingledine, Nick Mathewson */
3
4
5
6
7
/* See LICENSE for licensing information */
/* $Id$ */

#ifndef __COMPAT_H
#define __COMPAT_H
8
#define COMPAT_H_ID "$Id$"
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include "orconfig.h"
#include "torint.h"
#ifdef MS_WINDOWS
#define WIN32_WINNT 0x400
#define _WIN32_WINNT 0x400
#define WIN32_LEAN_AND_MEAN
#if (_MSC_VER <= 1300)
#include <winsock.h>
#else
#include <winsock2.h>
#include <ws2tcpip.h>
#endif
#endif
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
26
27
28
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
29
30
31
#ifdef HAVE_TIME_H
#include <time.h>
#endif
32
33
34
35
36
37
38
39
40
41
42
#include <stdarg.h>

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

/* ===== Compiler compatibility */

/* GCC can check printf types on arbitrary functions. */
#ifdef __GNUC__
#define CHECK_PRINTF(formatIdx, firstArg) \
43
   __attribute__ ((format(printf, formatIdx, firstArg)))
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#else
#define CHECK_PRINTF(formatIdx, firstArg)
#endif

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

/* Windows compilers before VC7 don't have __FUNCTION__. */
#if defined(_MSC_VER) && _MSC_VER < 1300
#define __FUNCTION__ "???"
#endif

60
61
62
63
#if defined(__sgi) && !defined(__GNUC__) && defined(__c99)
#define __FUNCTION__ __func__
#endif

64
65
66
67
68
69
/* ===== String compatibility */
#ifdef MS_WINDOWS
/* Windows names string functions differently from most other platforms. */
#define strncasecmp strnicmp
#define strcasecmp stricmp
#endif
70
71
72
73
74
75
#ifndef HAVE_STRLCAT
size_t strlcat(char *dst, const char *src, size_t siz);
#endif
#ifndef HAVE_STRLCPY
size_t strlcpy(char *dst, const char *src, size_t siz);
#endif
76
77
78
79

#ifdef MS_WINDOWS
#define U64_PRINTF_ARG(a) (a)
#define U64_SCANF_ARG(a) (a)
80
#define U64_FORMAT "%I64u"
81
#define U64_LITERAL(n) (n ## ui64)
82
#else
83
#define U64_PRINTF_ARG(a) ((long long unsigned int)(a))
Roger Dingledine's avatar
Roger Dingledine committed
84
#define U64_SCANF_ARG(a) ((long long unsigned int*)(a))
85
#define U64_FORMAT "%llu"
86
#define U64_LITERAL(n) (n ## llu)
87
#endif
88
89
90
91
92

int tor_snprintf(char *str, size_t size, const char *format, ...)
     CHECK_PRINTF(3,4);
int tor_vsnprintf(char *str, size_t size, const char *format, va_list args);

Nick Mathewson's avatar
Nick Mathewson committed
93
94
95
const void *tor_memmem(const void *haystack, size_t hlen, const void *needle,
                       size_t nlen);

96
97
#define TOR_ISAPLHA(c)   isalpha((int)(unsigned char)(c))
#define TOR_ISALNUM(c)   isalnum((int)(unsigned char)(c))
98
99
100
#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
101
#define TOR_ISPRINT(c)   isprint((int)(unsigned char)(c))
102

103
104
105
106
107
108
109
#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
110

111
112
113
114
115
116
117
118
119
120
/* ===== 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);

121
122
123
124
125
126
127
128
129
130
131
132
#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

133
134
/* ===== File compatibility */
int replace_file(const char *from, const char *to);
135
int touch_file(const char *fname);
136

137
138
139
140
141
142
#ifdef MS_WINDOWS
#define PATH_SEPARATOR "\\"
#else
#define PATH_SEPARATOR "/"
#endif

143
144
145
146
147
148
149
150
151
152
153
154
155
/* ===== Net compatibility */
#ifdef MS_WINDOWS
/** On windows, you have to call close() on fds returned by open(),
 * and closesocket() on fds returned by socket().  On Unix, everything
 * gets close()'d.  We abstract this difference by always using
 * tor_close_socket to close sockets, and always using close() on
 * files.
 */
#define tor_close_socket(s) closesocket(s)
#else
#define tor_close_socket(s) close(s)
#endif

156
157
158
159
#if (SIZEOF_SOCKLEN_T == 0)
typedef int socklen_t;
#endif

160
161
162
163
/* Now that we use libevent, all real sockets are safe for polling ... or
 * if they aren't, libevent will help us. */
#define SOCKET_IS_POLLABLE(fd) ((fd)>=0)

164
165
struct in_addr;
int tor_inet_aton(const char *cp, struct in_addr *addr);
166
int tor_lookup_hostname(const char *name, uint32_t *addr);
167
168
void set_socket_nonblocking(int socket);
int tor_socketpair(int family, int type, int protocol, int fd[2]);
169
int network_init(void);
170
171
172
173
174
175
176
177
178
179
180
181
182
/* 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.
 */
#ifdef MS_WINDOWS
/** 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(). */
183
#define ERRNO_IS_CONN_EINPROGRESS(e) ((e) == WSAEINPROGRESS || (e)== WSAEINVAL || (e) == WSAEWOULDBLOCK)
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
/** 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)
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)
#define tor_socket_errno(sock)       (errno)
#define tor_socket_strerror(e)       strerror(e)
#endif

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

/* Some platforms segfault when you try to access a multi-byte type
 * that isn't aligned to a word boundary.  The macros and/or functions
 * below can be used to access unaligned data on any platform.
 */
#ifdef UNALIGNED_INT_ACCESS_OK
#define get_uint16(cp) (*(uint16_t*)(cp))
#define get_uint32(cp) (*(uint32_t*)(cp))
#define set_uint16(cp,v) do { *(uint16_t*)(cp) = (v); } while (0)
#define set_uint32(cp,v) do { *(uint32_t*)(cp) = (v); } while (0)
#else
uint16_t get_uint16(const char *cp);
uint32_t get_uint32(const char *cp);
void set_uint16(char *cp, uint16_t v);
void set_uint32(char *cp, uint32_t v);
#endif

223
int set_max_file_descriptors(unsigned long limit, unsigned long cap);
224
int switch_id(char *user, char *group);
225
226
227
#ifdef HAVE_PWD_H
char *get_user_homedir(const char *username);
#endif
228
229
230
231

int spawn_func(int (*func)(void *), void *data);
void spawn_exit(void);

Nick Mathewson's avatar
Nick Mathewson committed
232
#if defined(ENABLE_THREADS) && defined(MS_WINDOWS)
233
234
#define USE_WIN32_THREADS
#define TOR_IS_MULTITHREADED 1
Nick Mathewson's avatar
Nick Mathewson committed
235
#elif defined(ENABLE_THREADS) && defined(HAVE_PTHREAD_H) && defined(HAVE_PTHREAD_CREATE)
236
#define USE_PTHREADS
237
238
239
240
241
#define TOR_IS_MULTITHREADED 1
#else
#undef TOR_IS_MULTITHREADED
#endif

242
243
/* Because we use threads instead of processes on Windows, we need locking on
 * Windows.  On Unixy platforms, these functions are no-ops. */
244

245
246
247
248
249
250
251
252
253
254
255
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);
#else
#define tor_mutex_new() ((tor_mutex_t*)tor_malloc(sizeof(int)))
#define tor_mutex_acquire(m) do { } while (0)
#define tor_mutex_release(m) do { } while (0)
Nick Mathewson's avatar
Nick Mathewson committed
256
#define tor_mutex_free(m) do { tor_free(m); } while (0)
257
258
259
#define tor_get_thread_id() (1UL)
#endif

260
#endif
261