1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
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
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
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
|
/*-------------------------------------------------------------------------
*
* thread.c
*
* Prototypes and macros around system calls, used to help make
* threaded libraries reentrant and safe to use from threaded applications.
*
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
*
* $Id: thread.c,v 1.12 2003/10/26 04:29:15 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include <sys/types.h>
#include <errno.h>
#if defined(WIN32) && defined(_MSC_VER)
#undef ERROR
#else
#include <pwd.h>
#endif
#if defined(USE_THREADS)
#include <pthread.h>
#endif
/*
* Threading sometimes requires specially-named versions of functions
* that return data in static buffers, like strerror_r() instead of
* strerror(). Other operating systems use pthread_setspecific()
* and pthread_getspecific() internally to allow standard library
* functions to return static data to threaded applications. And some
* operating systems have neither, meaning we have to do our own locking.
*
* Additional confusion exists because many operating systems that
* use pthread_setspecific/pthread_getspecific() also have *_r versions
* of standard library functions for compatibility with operating systems
* that require them. However, internally, these *_r functions merely
* call the thread-safe standard library functions.
*
* For example, BSD/OS 4.3 uses Bind 8.2.3 for getpwuid(). Internally,
* getpwuid() calls pthread_setspecific/pthread_getspecific() to return
* static data to the caller in a thread-safe manner. However, BSD/OS
* also has getpwuid_r(), which merely calls getpwuid() and shifts
* around the arguments to match the getpwuid_r() function declaration.
* Therefore, while BSD/OS has getpwuid_r(), it isn't required. It also
* doesn't have strerror_r(), so we can't fall back to only using *_r
* functions for threaded programs.
*
* The current setup is to try threading in this order:
*
* use non-*_r function names if they are all thread-safe
* (NEED_REENTRANT_FUNCS=no)
* use *_r functions if they exist (configure test)
* do our own locking and copying of non-threadsafe functions
*
* The disadvantage of the last option is not the thread overhead but
* the fact that all function calls are serialized, and with gethostbyname()
* requiring a DNS lookup, that could be slow.
*
* One thread-safe solution for gethostbyname() might be to use getaddrinfo().
*
* See src/tools/thread to see if your operating system has thread-safe
* non-*_r functions.
*/
/*
* Wrapper around strerror and strerror_r to use the former if it is
* available and also return a more useful value (the error string).
*/
char *
pqStrerror(int errnum, char *strerrbuf, size_t buflen)
{
#if defined(FRONTEND) && defined(USE_THREADS) && defined(NEED_REENTRANT_FUNCS) && defined(HAVE_STRERROR_R)
/* reentrant strerror_r is available */
/* some early standards had strerror_r returning char * */
strerror_r(errnum, strerrbuf, buflen);
return strerrbuf;
#else
#if defined(FRONTEND) && defined(USE_THREADS) && defined(NEED_REENTRANT_FUNCS) && !defined(HAVE_STRERROR_R)
static pthread_mutex_t strerror_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&strerror_lock);
#endif
/* no strerror_r() available, just use strerror */
StrNCpy(strerrbuf, strerror(errnum), buflen);
#if defined(FRONTEND) && defined(USE_THREADS) && defined(NEED_REENTRANT_FUNCS) && !defined(HAVE_STRERROR_R)
pthread_mutex_unlock(&strerror_lock);
#endif
return strerrbuf;
#endif
}
/*
* Wrapper around getpwuid() or getpwuid_r() to mimic POSIX getpwuid_r()
* behaviour, if it is not available or required.
*/
#ifndef WIN32
int
pqGetpwuid(uid_t uid, struct passwd *resultbuf, char *buffer,
size_t buflen, struct passwd **result)
{
#if defined(FRONTEND) && defined(USE_THREADS) && defined(NEED_REENTRANT_FUNCS) && defined(HAVE_GETPWUID_R)
/*
* Early POSIX draft of getpwuid_r() returns 'struct passwd *'.
* getpwuid_r(uid, resultbuf, buffer, buflen)
* Do we need to support it? bjm 2003-08-14
*/
/* POSIX version */
getpwuid_r(uid, resultbuf, buffer, buflen, result);
#else
#if defined(FRONTEND) && defined(USE_THREADS) && defined(NEED_REENTRANT_FUNCS) && !defined(HAVE_GETPWUID_R)
static pthread_mutex_t getpwuid_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&getpwuid_lock);
#endif
/* no getpwuid_r() available, just use getpwuid() */
*result = getpwuid(uid);
#if defined(FRONTEND) && defined(USE_THREADS) && defined(NEED_REENTRANT_FUNCS) && !defined(HAVE_GETPWUID_R)
/* Use 'buffer' memory for storage of strings used by struct passwd */
if (*result &&
strlen((*result)->pw_name) + 1 +
strlen((*result)->pw_passwd) + 1 +
strlen((*result)->pw_gecos) + 1 +
/* skip class if it exists */
strlen((*result)->pw_dir) + 1 +
strlen((*result)->pw_shell) + 1 <= buflen)
{
memcpy(resultbuf, *result, sizeof(struct passwd));
strcpy(buffer, (*result)->pw_name);
resultbuf->pw_name = buffer;
buffer += strlen(resultbuf->pw_name) + 1;
strcpy(buffer, (*result)->pw_passwd);
resultbuf->pw_passwd = buffer;
buffer += strlen(resultbuf->pw_passwd) + 1;
strcpy(buffer, (*result)->pw_gecos);
resultbuf->pw_gecos = buffer;
buffer += strlen(resultbuf->pw_gecos) + 1;
strcpy(buffer, (*result)->pw_dir);
resultbuf->pw_dir = buffer;
buffer += strlen(resultbuf->pw_dir) + 1;
strcpy(buffer, (*result)->pw_shell);
resultbuf->pw_shell = buffer;
buffer += strlen(resultbuf->pw_shell) + 1;
*result = resultbuf;
}
else
{
*result = NULL;
errno = ERANGE;
}
pthread_mutex_unlock(&getpwuid_lock);
#endif
#endif
return (*result == NULL) ? -1 : 0;
}
#endif
/*
* Wrapper around gethostbyname() or gethostbyname_r() to mimic
* POSIX gethostbyname_r() behaviour, if it is not available or required.
* This function is called _only_ by our getaddinfo() portability function.
*/
#ifndef HAVE_GETADDRINFO
int
pqGethostbyname(const char *name,
struct hostent *resultbuf,
char *buffer, size_t buflen,
struct hostent **result,
int *herrno)
{
#if defined(FRONTEND) && defined(USE_THREADS) && defined(NEED_REENTRANT_FUNCS) && defined(HAVE_GETHOSTBYNAME_R)
/*
* broken (well early POSIX draft) gethostbyname_r() which returns
* 'struct hostent *'
*/
*result = gethostbyname_r(name, resbuf, buffer, buflen, herrno);
return (*result == NULL) ? -1 : 0;
#else
#if defined(FRONTEND) && defined(USE_THREADS) && defined(NEED_REENTRANT_FUNCS) && !defined(HAVE_GETHOSTBYNAME_R)
static pthread_mutex_t gethostbyname_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&gethostbyname_lock);
#endif
/* no gethostbyname_r(), just use gethostbyname() */
*result = gethostbyname(name);
#if defined(FRONTEND) && defined(USE_THREADS) && defined(NEED_REENTRANT_FUNCS) && !defined(HAVE_GETHOSTBYNAME_R)
/*
* Use 'buffer' memory for storage of structures used by struct hostent.
* The layout is:
*
* addr pointers
* alias pointers
* addr structures
* alias structures
* name
*/
if (*result)
{
int i, pointers = 2 /* for nulls */, len = 0;
char **pbuffer;
for (i = 0; (*result)->h_addr_list[i]; i++, pointers++)
len += (*result)->h_length;
for (i = 0; (*result)->h_aliases[i]; i++, pointers++)
len += (*result)->h_length;
if (pointers * sizeof(char *) + MAXALIGN(len) + strlen((*result)->h_name) + 1 <= buflen)
{
memcpy(resultbuf, *result, sizeof(struct hostent));
pbuffer = (char **)buffer;
resultbuf->h_addr_list = pbuffer;
buffer += pointers * sizeof(char *);
for (i = 0; (*result)->h_addr_list[i]; i++, pbuffer++)
{
memcpy(buffer, (*result)->h_addr_list[i], (*result)->h_length);
resultbuf->h_addr_list[i] = buffer;
buffer += (*result)->h_length;
}
resultbuf->h_addr_list[i] = NULL;
pbuffer++;
resultbuf->h_aliases = pbuffer;
for (i = 0; (*result)->h_aliases[i]; i++, pbuffer++)
{
memcpy(buffer, (*result)->h_aliases[i], (*result)->h_length);
resultbuf->h_aliases[i] = buffer;
buffer += (*result)->h_length;
}
resultbuf->h_aliases[i] = NULL;
pbuffer++;
/* Place at end for cleaner alignment */
buffer = MAXALIGN(buffer);
strcpy(buffer, (*result)->h_name);
resultbuf->h_name = buffer;
buffer += strlen(resultbuf->h_name) + 1;
*result = resultbuf;
}
else
{
*result = NULL;
errno = ERANGE;
}
}
#endif
if (*result != NULL)
*herrno = h_errno;
#if defined(FRONTEND) && defined(USE_THREADS) && defined(NEED_REENTRANT_FUNCS) && !defined(HAVE_GETHOSTBYNAME_R)
pthread_mutex_unlock(&gethostbyname_lock);
#endif
if (*result != NULL)
return 0;
else
return -1;
#endif
}
#endif
|
