compat.h 7.6 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
32
33
34
35
36
37
38
39
#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) \
40
   __attribute__ ((format(printf, formatIdx, firstArg)))
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#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

57
58
59
60
#if defined(__sgi) && !defined(__GNUC__) && defined(__c99)
#define __FUNCTION__ __func__
#endif

61
62
63
64
65
66
/* ===== String compatibility */
#ifdef MS_WINDOWS
/* Windows names string functions differently from most other platforms. */
#define strncasecmp strnicmp
#define strcasecmp stricmp
#endif
67
68
69
70
71
72
#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
73
74
75
76

#ifdef MS_WINDOWS
#define U64_PRINTF_ARG(a) (a)
#define U64_SCANF_ARG(a) (a)
77
#define U64_FORMAT "%I64u"
78
#define U64_LITERAL(n) (n ## ui64)
79
80
81
82
#else
#define U64_PRINTF_ARG(a) ((long long unsigned int)a)
#define U64_SCANF_ARG(a) ((long long unsigned int*)a)
#define U64_FORMAT "%llu"
83
#define U64_LITERAL(n) (n ## llu)
84
#endif
85
86
87
88
89

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

90
91
#define TOR_ISAPLHA(c)   isalpha((int)(unsigned char)(c))
#define TOR_ISALNUM(c)   isalnum((int)(unsigned char)(c))
92
93
94
#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
95
#define TOR_ISPRINT(c)   isprint((int)(unsigned char)(c))
96

97
98
99
#define _SHORT_FILE_ (_tor_fix_source_file(__FILE__))
const char *_tor_fix_source_file(const char *fname);

100
101
102
103
104
105
106
107
108
109
/* ===== 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);

110
111
112
113
114
115
116
117
118
119
120
121
#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

122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
/* ===== File compatibility */
int replace_file(const char *from, const char *to);

/* ===== 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

138
139
140
141
#if (SIZEOF_SOCKLEN_T == 0)
typedef int socklen_t;
#endif

142
143
144
145
/* 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)

146
147
struct in_addr;
int tor_inet_aton(const char *cp, struct in_addr *addr);
148
int tor_lookup_hostname(const char *name, uint32_t *addr);
149
150
void set_socket_nonblocking(int socket);
int tor_socketpair(int family, int type, int protocol, int fd[2]);
151
int network_init(void);
152
153
154
155
156
157
158
159
160
161
162
163
164
/* 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(). */
165
#define ERRNO_IS_CONN_EINPROGRESS(e) ((e) == WSAEINPROGRESS || (e)== WSAEINVAL || (e) == WSAEWOULDBLOCK)
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
/** 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

205
int set_max_file_descriptors(unsigned long limit, unsigned long cap);
206
int switch_id(char *user, char *group);
207
208
209
#ifdef HAVE_PWD_H
char *get_user_homedir(const char *username);
#endif
210
211
212
213

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

Nick Mathewson's avatar
Nick Mathewson committed
214
#if defined(ENABLE_THREADS) && defined(MS_WINDOWS)
215
216
#define USE_WIN32_THREADS
#define TOR_IS_MULTITHREADED 1
Nick Mathewson's avatar
Nick Mathewson committed
217
#elif defined(ENABLE_THREADS) && defined(HAVE_PTHREAD_H) && defined(HAVE_PTHREAD_CREATE)
218
#define USE_PTHREADS
219
220
221
222
223
#define TOR_IS_MULTITHREADED 1
#else
#undef TOR_IS_MULTITHREADED
#endif

224
225
226
227
228
229
230
231
232
233
234
235
236
/* Because we use threads instead of processes on Windows, we need locking on
 * Windows.  On Unixy platforms, these functions are no-ops. */
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
237
#define tor_mutex_free(m) do { tor_free(m); } while (0)
238
239
240
#define tor_get_thread_id() (1UL)
#endif

241
#endif
242