« back to all changes in this revision
Viewing changes to Xos_r.h
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Bazaar Package Importer
- Author(s): Daniel Stone
- Date: 2005-07-22 18:25:10 UTC
- Revision ID: james.westby@ubuntu.com-20050722182510-t2zzpzgwtbs5bpa9
Tags: upstream-6.8.99.15+cvs.20050722
Import upstream version 6.8.99.15+cvs.20050722
- files added:
added
removed
Xos_r.h
1
/* $Xorg: Xos_r.h,v 1.4 2001/02/09 02:03:22 xorgcvs Exp $ */
2
/* $XdotOrg: xc/include/Xos_r.h,v 1.4 2005/03/02 19:29:31 alanc Exp $ */
3
/*
4
Copyright 1996, 1998 The Open Group
5
6
Permission to use, copy, modify, distribute, and sell this software and its
7
documentation for any purpose is hereby granted without fee, provided that
8
the above copyright notice appear in all copies and that both that
9
copyright notice and this permission notice appear in supporting
10
documentation.
11
12
The above copyright notice and this permission notice shall be included in
13
all copies or substantial portions of the Software.
14
15
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
19
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21
22
Except as contained in this notice, the name of The Open Group shall not be
23
used in advertising or otherwise to promote the sale, use or other dealings
24
in this Software without prior written authorization from The Open Group.
25
*/
26
/* $XFree86: xc/include/Xos_r.h,v 1.18tsi Exp $ */
27
28
/*
29
* Various and sundry Thread-Safe functions used by X11, Motif, and CDE.
30
*
31
* Use this file in MT-safe code where you would have included
32
* <dirent.h> for readdir()
33
* <grp.h> for getgrgid() or getgrnam()
34
* <netdb.h> for gethostbyname(), gethostbyaddr(), or getservbyname()
35
* <pwd.h> for getpwnam() or getpwuid()
36
* <string.h> for strtok()
37
* <time.h> for asctime(), ctime(), localtime(), or gmtime()
38
* <unistd.h> for getlogin() or ttyname()
39
* or their thread-safe analogs.
40
*
41
* If you are on a platform that defines XTHREADS but does not have
42
* MT-safe system API (e.g. UnixWare) you must define _Xos_processLock
43
* and _Xos_processUnlock macros before including this header. If
44
* you are on OSF/1 V3.2 and plan to use readdir(), you must also define
45
* _Xos_isThreadsInitialized. For convenience XOS_USE_XLIB_LOCKING or
46
* XOS_USE_XT_LOCKING may be defined to obtain either Xlib-only or
47
* Xt-based versions of these macros. These macros won't result in
48
* truly thread-safe calls, but they are better than nothing. If you
49
* do not want locking in this situation define XOS_USE_NO_LOCKING.
50
*
51
* NOTE: On systems lacking approriate _r functions Gethostbyname(),
52
* Gethostbyaddr(), and Getservbyname() do NOT copy the host or
53
* protocol lists!
54
*
55
* NOTE: On systems lacking appropriate _r functions Getgrgid() and
56
* Getgrnam() do NOT copy the list of group members!
57
*
58
* This header is nominally intended to simplify porting X11, Motif, and
59
* CDE; it may be useful to other people too. The structure below is
60
* complicated, mostly because P1003.1c (the IEEE POSIX Threads spec)
61
* went through lots of drafts, and some vendors shipped systems based
62
* on draft API that were changed later. Unfortunately POSIX did not
63
* provide a feature-test macro for distinguishing each of the drafts.
64
*/
65
66
/*
67
* This header has several parts. Search for "Effective prototypes"
68
* to locate the beginning of a section.
69
*/
70
71
/* This header can be included multiple times with different defines! */
72
#ifndef _XOS_R_H_
73
# define _XOS_R_H_
74
75
# include <X11/Xos.h>
76
# include <X11/Xfuncs.h>
77
78
# ifndef X_NOT_POSIX
79
# ifdef _POSIX_SOURCE
80
# include <limits.h>
81
# else
82
# define _POSIX_SOURCE
83
# include <limits.h>
84
# undef _POSIX_SOURCE
85
# endif
86
# ifndef LINE_MAX
87
# define X_LINE_MAX 2048
88
# else
89
# define X_LINE_MAX LINE_MAX
90
# endif
91
# endif
92
#endif /* _XOS_R_H */
93
94
#ifndef WIN32
95
96
#ifdef __cplusplus
97
extern "C" {
98
#endif
99
100
# if defined(XOS_USE_XLIB_LOCKING)
101
# ifndef XAllocIDs /* Xlibint.h does not have multiple include protection */
102
typedef struct _LockInfoRec *LockInfoPtr;
103
extern LockInfoPtr _Xglobal_lock;
104
# endif
105
# ifndef _Xos_isThreadInitialized
106
# define _Xos_isThreadInitialized (_Xglobal_lock)
107
# endif
108
# if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
109
# ifndef XAllocIDs /* Xlibint.h does not have multiple include protection */
110
# include <X11/Xfuncproto.h> /* for NeedFunctionPrototypes */
111
extern void (*_XLockMutex_fn)(
112
# if NeedFunctionPrototypes
113
LockInfoPtr /* lock */, char * /* file */, int /* line */
114
# endif
115
);
116
extern void (*_XUnlockMutex_fn)(
117
# if NeedFunctionPrototypes
118
LockInfoPtr /* lock */, char * /* file */, int /* line */
119
# endif
120
);
121
# endif
122
# ifndef _Xos_processLock
123
# define _Xos_processLock \
124
(_XLockMutex_fn ? (*_XLockMutex_fn)(_Xglobal_lock,__FILE__,__LINE__) : 0)
125
# endif
126
# ifndef _Xos_processUnlock
127
# define _Xos_processUnlock \
128
(_XUnlockMutex_fn ? (*_XUnlockMutex_fn)(_Xglobal_lock,__FILE__,__LINE__) : 0)
129
# endif
130
# else
131
# ifndef XAllocIDs /* Xlibint.h does not have multiple include protection */
132
# include <X11/Xfuncproto.h> /* for NeedFunctionPrototypes */
133
extern void (*_XLockMutex_fn)(
134
# if NeedFunctionPrototypes
135
LockInfoPtr /* lock */
136
# endif
137
);
138
extern void (*_XUnlockMutex_fn)(
139
# if NeedFunctionPrototypes
140
LockInfoPtr /* lock */
141
# endif
142
);
143
# endif
144
# ifndef _Xos_processLock
145
# define _Xos_processLock \
146
(_XLockMutex_fn ? ((*_XLockMutex_fn)(_Xglobal_lock), 0) : 0)
147
# endif
148
# ifndef _Xos_processUnlock
149
# define _Xos_processUnlock \
150
(_XUnlockMutex_fn ? ((*_XUnlockMutex_fn)(_Xglobal_lock), 0) : 0)
151
# endif
152
# endif
153
# elif defined(XOS_USE_XT_LOCKING)
154
# ifndef _XtThreadsI_h
155
extern void (*_XtProcessLock)(void);
156
# endif
157
# ifndef _XtintrinsicP_h
158
# include <X11/Xfuncproto.h> /* for NeedFunctionPrototypes */
159
extern void XtProcessLock(
160
# if NeedFunctionPrototypes
161
void
162
# endif
163
);
164
extern void XtProcessUnlock(
165
# if NeedFunctionPrototypes
166
void
167
# endif
168
);
169
# endif
170
# ifndef _Xos_isThreadInitialized
171
# define _Xos_isThreadInitialized _XtProcessLock
172
# endif
173
# ifndef _Xos_processLock
174
# define _Xos_processLock XtProcessLock()
175
# endif
176
# ifndef _Xos_processUnlock
177
# define _Xos_processUnlock XtProcessUnlock()
178
# endif
179
# elif defined(XOS_USE_NO_LOCKING)
180
# ifndef _Xos_isThreadInitialized
181
# define _Xos_isThreadInitialized 0
182
# endif
183
# ifndef _Xos_processLock
184
# define _Xos_processLock 0
185
# endif
186
# ifndef _Xos_processUnlock
187
# define _Xos_processUnlock 0
188
# endif
189
# endif
190
191
#endif /* !defined WIN32 */
192
193
/*
194
* Solaris defines the POSIX thread-safe feature test macro, but
195
* uses the older SVR4 thread-safe functions unless the POSIX ones
196
* are specifically requested. Fix the feature test macro.
197
*/
198
#if defined(sun) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && \
199
(_POSIX_C_SOURCE - 0 < 199506L) && !defined(_POSIX_PTHREAD_SEMANTICS)
200
# undef _POSIX_THREAD_SAFE_FUNCTIONS
201
#endif
202
203
/*
204
* LynxOS 3.1 defines _POSIX_THREAD_SAFE_FUNCTIONS but
205
* getpwuid_r has different semantics than defined by POSIX
206
*/
207
#if defined(Lynx) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
208
# undef _POSIX_THREAD_SAFE_FUNCTIONS
209
#endif
210
211
212
/***** <pwd.h> wrappers *****/
213
214
/*
215
* Effective prototypes for <pwd.h> wrappers:
216
*
217
* #define X_INCLUDE_PWD_H
218
* #define XOS_USE_..._LOCKING
219
* #include <X11/Xos_r.h>
220
*
221
* typedef ... _Xgetpwparams;
222
*
223
* struct passwd* _XGetpwnam(const char *name, _Xgetpwparams);
224
* struct passwd* _XGetpwuid(uid_t uid, _Xgetpwparams);
225
*/
226
227
#if defined(X_INCLUDE_PWD_H) && !defined(_XOS_INCLUDED_PWD_H)
228
# include <pwd.h>
229
# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_PWDAPI)
230
# define XOS_USE_MTSAFE_PWDAPI 1
231
# endif
232
#endif
233
234
#undef X_NEEDS_PWPARAMS
235
#if !defined(X_INCLUDE_PWD_H) || defined(_XOS_INCLUDED_PWD_H)
236
/* Do nothing */
237
238
#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API)
239
/* Use regular, unsafe API. */
240
# if defined(X_NOT_POSIX) && !defined(i386) && !defined(SYSV)
241
extern struct passwd *getpwuid(), *getpwnam();
242
# endif
243
typedef int _Xgetpwparams; /* dummy */
244
# define _XGetpwuid(u,p) getpwuid((u))
245
# define _XGetpwnam(u,p) getpwnam((u))
246
247
#elif !defined(XOS_USE_MTSAFE_PWDAPI) || defined(XNO_MTSAFE_PWDAPI)
248
/* UnixWare 2.0, or other systems with thread support but no _r API. */
249
# define X_NEEDS_PWPARAMS
250
typedef struct {
251
struct passwd pws;
252
char pwbuf[1024];
253
struct passwd* pwp;
254
size_t len;
255
} _Xgetpwparams;
256
257
/*
258
* NetBSD and FreeBSD, at least, are missing several of the unixware passwd
259
* fields.
260
*/
261
262
#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || \
263
defined(__APPLE__) || defined(__DragonFly__)
264
static __inline__ void _Xpw_copyPasswd(_Xgetpwparams p)
265
{
266
memcpy(&(p).pws, (p).pwp, sizeof(struct passwd));
267
268
(p).pws.pw_name = (p).pwbuf;
269
(p).len = strlen((p).pwp->pw_name);
270
strcpy((p).pws.pw_name, (p).pwp->pw_name);
271
272
(p).pws.pw_passwd = (p).pws.pw_name + (p).len + 1;
273
(p).len = strlen((p).pwp->pw_passwd);
274
strcpy((p).pws.pw_passwd,(p).pwp->pw_passwd);
275
276
(p).pws.pw_class = (p).pws.pw_passwd + (p).len + 1;
277
(p).len = strlen((p).pwp->pw_class);
278
strcpy((p).pws.pw_class, (p).pwp->pw_class);
279
280
(p).pws.pw_gecos = (p).pws.pw_class + (p).len + 1;
281
(p).len = strlen((p).pwp->pw_gecos);
282
strcpy((p).pws.pw_gecos, (p).pwp->pw_gecos);
283
284
(p).pws.pw_dir = (p).pws.pw_gecos + (p).len + 1;
285
(p).len = strlen((p).pwp->pw_dir);
286
strcpy((p).pws.pw_dir, (p).pwp->pw_dir);
287
288
(p).pws.pw_shell = (p).pws.pw_dir + (p).len + 1;
289
(p).len = strlen((p).pwp->pw_shell);
290
strcpy((p).pws.pw_shell, (p).pwp->pw_shell);
291
292
(p).pwp = &(p).pws;
293
}
294
295
#else
296
# define _Xpw_copyPasswd(p) \
297
(memcpy(&(p).pws, (p).pwp, sizeof(struct passwd)), \
298
((p).pws.pw_name = (p).pwbuf), \
299
((p).len = strlen((p).pwp->pw_name)), \
300
strcpy((p).pws.pw_name, (p).pwp->pw_name), \
301
((p).pws.pw_passwd = (p).pws.pw_name + (p).len + 1), \
302
((p).len = strlen((p).pwp->pw_passwd)), \
303
strcpy((p).pws.pw_passwd,(p).pwp->pw_passwd), \
304
((p).pws.pw_age = (p).pws.pw_passwd + (p).len + 1), \
305
((p).len = strlen((p).pwp->pw_age)), \
306
strcpy((p).pws.pw_age, (p).pwp->pw_age), \
307
((p).pws.pw_comment = (p).pws.pw_age + (p).len + 1), \
308
((p).len = strlen((p).pwp->pw_comment)), \
309
strcpy((p).pws.pw_comment, (p).pwp->pw_comment), \
310
((p).pws.pw_gecos = (p).pws.pw_comment + (p).len + 1), \
311
((p).len = strlen((p).pwp->pw_gecos)), \
312
strcpy((p).pws.pw_gecos, (p).pwp->pw_gecos), \
313
((p).pws.pw_dir = (p).pws.pw_comment + (p).len + 1), \
314
((p).len = strlen((p).pwp->pw_dir)), \
315
strcpy((p).pws.pw_dir, (p).pwp->pw_dir), \
316
((p).pws.pw_shell = (p).pws.pw_dir + (p).len + 1), \
317
((p).len = strlen((p).pwp->pw_shell)), \
318
strcpy((p).pws.pw_shell, (p).pwp->pw_shell), \
319
((p).pwp = &(p).pws), \
320
0 )
321
#endif
322
# define _XGetpwuid(u,p) \
323
( (_Xos_processLock), \
324
(((p).pwp = getpwuid((u))) ? _Xpw_copyPasswd(p), 0 : 0), \
325
(_Xos_processUnlock), \
326
(p).pwp )
327
# define _XGetpwnam(u,p) \
328
( (_Xos_processLock), \
329
(((p).pwp = getpwnam((u))) ? _Xpw_copyPasswd(p), 0 : 0), \
330
(_Xos_processUnlock), \
331
(p).pwp )
332
333
#elif !defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(__APPLE__)
334
/* SVR4 threads, AIX 4.2.0 and earlier and OSF/1 3.2 and earlier pthreads */
335
# define X_NEEDS_PWPARAMS
336
typedef struct {
337
struct passwd pws;
338
char pwbuf[X_LINE_MAX];
339
} _Xgetpwparams;
340
# if defined(_POSIX_REENTRANT_FUNCTIONS) || !defined(SVR4) || defined(Lynx)
341
# ifndef Lynx
342
# define _XGetpwuid(u,p) \
343
((getpwuid_r((u),&(p).pws,(p).pwbuf,sizeof((p).pwbuf)) == -1) ? NULL : &(p).pws)
344
# define _XGetpwnam(u,p) \
345
((getpwnam_r((u),&(p).pws,(p).pwbuf,sizeof((p).pwbuf)) == -1) ? NULL : &(p).pws)
346
# else /* Lynx */
347
# define _XGetpwuid(u,p) \
348
((getpwuid_r(&(p).pws,(u),(p).pwbuf,sizeof((p).pwbuf)) == -1) ? NULL : &(p).pws)
349
# define _XGetpwnam(u,p) \
350
((getpwnam_r(&(p).pws,(u),(p).pwbuf,sizeof((p).pwbuf)) == -1) ? NULL : &(p).pws)
351
# endif
352
# else /* SVR4 */
353
# define _XGetpwuid(u,p) \
354
((getpwuid_r((u),&(p).pws,(p).pwbuf,sizeof((p).pwbuf)) == NULL) ? NULL : &(p).pws)
355
# define _XGetpwnam(u,p) \
356
((getpwnam_r((u),&(p).pws,(p).pwbuf,sizeof((p).pwbuf)) == NULL) ? NULL : &(p).pws)
357
# endif /* SVR4 */
358
359
#else /* _POSIX_THREAD_SAFE_FUNCTIONS */
360
/* Digital UNIX 4.0, but not (beta) T4.0-1 */
361
# if defined(__osf__)
362
/* OSF/1 V4.0 <pwd.h> doesn't declare the _P routines, breaking under C++. */
363
extern int _Pgetpwuid_r(uid_t, struct passwd *, char *, size_t, struct passwd **);
364
extern int _Pgetpwnam_r(const char *, struct passwd *, char *, size_t, struct passwd **);
365
# endif
366
# define X_NEEDS_PWPARAMS
367
typedef struct {
368
struct passwd pws;
369
char pwbuf[X_LINE_MAX];
370
struct passwd* pwp;
371
} _Xgetpwparams;
372
typedef int _Xgetpwret;
373
# define _XGetpwuid(u,p) \
374
((getpwuid_r((u),&(p).pws,(p).pwbuf,sizeof((p).pwbuf),&(p).pwp) == 0) ? \
375
(p).pwp : NULL)
376
# define _XGetpwnam(u,p) \
377
((getpwnam_r((u),&(p).pws,(p).pwbuf,sizeof((p).pwbuf),&(p).pwp) == 0) ? \
378
(p).pwp : NULL)
379
#endif /* X_INCLUDE_PWD_H */
380
381
#if defined(X_INCLUDE_PWD_H) && !defined(_XOS_INCLUDED_PWD_H)
382
# define _XOS_INCLUDED_PWD_H
383
#endif
384
385
386
/***** <netdb.h> wrappers *****/
387
388
/*
389
* Effective prototypes for <netdb.h> wrappers:
390
*
391
* NOTE: On systems lacking the appropriate _r functions Gethostbyname(),
392
* Gethostbyaddr(), and Getservbyname() do NOT copy the host or
393
* protocol lists!
394
*
395
* #define X_INCLUDE_NETDB_H
396
* #define XOS_USE_..._LOCKING
397
* #include <X11/Xos_r.h>
398
*
399
* typedef ... _Xgethostbynameparams;
400
* typedef ... _Xgetservbynameparams;
401
*
402
* struct hostent* _XGethostbyname(const char* name,_Xgethostbynameparams);
403
* struct hostent* _XGethostbyaddr(const char* addr, int len, int type,
404
* _Xgethostbynameparams);
405
* struct servent* _XGetservbyname(const char* name, const char* proto,
406
* _Xgetservbynameparams);
407
*/
408
409
#undef XTHREADS_NEEDS_BYNAMEPARAMS
410
#if defined(X_INCLUDE_NETDB_H) && !defined(_XOS_INCLUDED_NETDB_H) \
411
&& !defined(WIN32)
412
# include <netdb.h>
413
# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_NETDBAPI)
414
# define XOS_USE_MTSAFE_NETDBAPI 1
415
# endif
416
#endif
417
418
#if !defined(X_INCLUDE_NETDB_H) || defined(_XOS_INCLUDED_NETDB_H)
419
/* Do nothing. */
420
421
#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API)
422
/* Use regular, unsafe API. */
423
typedef int _Xgethostbynameparams; /* dummy */
424
typedef int _Xgetservbynameparams; /* dummy */
425
# define _XGethostbyname(h,hp) gethostbyname((h))
426
# define _XGethostbyaddr(a,al,t,hp) gethostbyaddr((a),(al),(t))
427
# define _XGetservbyname(s,p,sp) getservbyname((s),(p))
428
429
#elif !defined(XOS_USE_MTSAFE_NETDBAPI) || defined(XNO_MTSAFE_NETDBAPI)
430
/* UnixWare 2.0, or other systems with thread support but no _r API. */
431
/* WARNING: The h_addr_list and s_aliases values are *not* copied! */
432
433
#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
434
#include <sys/param.h>
435
#endif
436
437
typedef struct {
438
struct hostent hent;
439
char h_name[MAXHOSTNAMELEN];
440
struct hostent *hptr;
441
} _Xgethostbynameparams;
442
typedef struct {
443
struct servent sent;
444
char s_name[255];
445
char s_proto[255];
446
struct servent *sptr;
447
} _Xgetservbynameparams;
448
449
# define XTHREADS_NEEDS_BYNAMEPARAMS
450
451
# define _Xg_copyHostent(hp) \
452
(memcpy(&(hp).hent, (hp).hptr, sizeof(struct hostent)), \
453
strcpy((hp).h_name, (hp).hptr->h_name), \
454
((hp).hent.h_name = (hp).h_name), \
455
((hp).hptr = &(hp).hent), \
456
0 )
457
# define _Xg_copyServent(sp) \
458
(memcpy(&(sp).sent, (sp).sptr, sizeof(struct servent)), \
459
strcpy((sp).s_name, (sp).sptr->s_name), \
460
((sp).sent.s_name = (sp).s_name), \
461
strcpy((sp).s_proto, (sp).sptr->s_proto), \
462
((sp).sent.s_proto = (sp).s_proto), \
463
((sp).sptr = &(sp).sent), \
464
0 )
465
# define _XGethostbyname(h,hp) \
466
((_Xos_processLock), \
467
(((hp).hptr = gethostbyname((h))) ? _Xg_copyHostent(hp) : 0), \
468
(_Xos_processUnlock), \
469
(hp).hptr )
470
# define _XGethostbyaddr(a,al,t,hp) \
471
((_Xos_processLock), \
472
(((hp).hptr = gethostbyaddr((a),(al),(t))) ? _Xg_copyHostent(hp) : 0), \
473
(_Xos_processUnlock), \
474
(hp).hptr )
475
# define _XGetservbyname(s,p,sp) \
476
((_Xos_processLock), \
477
(((sp).sptr = getservbyname((s),(p))) ? _Xg_copyServent(sp) : 0), \
478
(_Xos_processUnlock), \
479
(sp).sptr )
480
481
#elif defined(XUSE_NETDB_R_API)
482
/*
483
* POSIX does not specify _r equivalents for <netdb.h> API, but some
484
* vendors provide them anyway. Use them only when explicitly asked.
485
*/
486
# ifdef _POSIX_REENTRANT_FUNCTIONS
487
# ifndef _POSIX_THREAD_SAFE_FUNCTIONS
488
# if defined(AIXV3) || defined(AIXV4) || defined(__osf__)
489
# define X_POSIX_THREAD_SAFE_FUNCTIONS 1
490
# endif
491
# endif
492
# endif
493
# ifdef _POSIX_THREAD_SAFE_FUNCTIONS
494
# define X_POSIX_THREAD_SAFE_FUNCTIONS 1
495
# endif
496
497
# define XTHREADS_NEEDS_BYNAMEPARAMS
498
499
# ifndef X_POSIX_THREAD_SAFE_FUNCTIONS
500
typedef struct {
501
struct hostent hent;
502
char hbuf[X_LINE_MAX];
503
int herr;
504
} _Xgethostbynameparams;
505
typedef struct {
506
struct servent sent;
507
char sbuf[X_LINE_MAX];
508
} _Xgetservbynameparams;
509
# define _XGethostbyname(h,hp) \
510
gethostbyname_r((h),&(hp).hent,(hp).hbuf,sizeof((hp).hbuf),&(hp).herr)
511
# define _XGethostbyaddr(a,al,t,hp) \
512
gethostbyaddr_r((a),(al),(t),&(hp).hent,(hp).hbuf,sizeof((hp).hbuf),&(hp).herr)
513
# define _XGetservbyname(s,p,sp) \
514
getservbyname_r((s),(p),&(sp).sent,(sp).sbuf,sizeof((sp).sbuf))
515
# else
516
typedef struct {
517
struct hostent hent;
518
struct hostent_data hdata;
519
} _Xgethostbynameparams;
520
typedef struct {
521
struct servent sent;
522
struct servent_data sdata;
523
} _Xgetservbynameparams;
524
# define _XGethostbyname(h,hp) \
525
(bzero((char*)&(hp).hdata,sizeof((hp).hdata)), \
526
((gethostbyname_r((h),&(hp).hent,&(hp).hdata) == -1) ? NULL : &(hp).hent))
527
# define _XGethostbyaddr(a,al,t,hp) \
528
(bzero((char*)&(hp).hdata,sizeof((hp).hdata)), \
529
((gethostbyaddr_r((a),(al),(t),&(hp).hent,&(hp).hdata) == -1) ? NULL : &(hp).hent))
530
# define _XGetservbyname(s,p,sp) \
531
(bzero((char*)&(sp).sdata,sizeof((sp).sdata)), \
532
((getservbyname_r((s),(p),&(sp).sent,&(sp).sdata) == -1) ? NULL : &(sp).sent) )
533
# endif
534
# ifdef X_POSIX_THREAD_SAFE_FUNCTIONS
535
# undef X_POSIX_THREAD_SAFE_FUNCTIONS
536
# endif
537
538
#else
539
/* The regular API is assumed to be MT-safe under POSIX. */
540
typedef int _Xgethostbynameparams; /* dummy */
541
typedef int _Xgetservbynameparams; /* dummy */
542
# define _XGethostbyname(h,hp) gethostbyname((h))
543
# define _XGethostbyaddr(a,al,t,hp) gethostbyaddr((a),(al),(t))
544
# define _XGetservbyname(s,p,sp) getservbyname((s),(p))
545
#endif /* X_INCLUDE_NETDB_H */
546
547
#if defined(X_INCLUDE_NETDB_H) && !defined(_XOS_INCLUDED_NETDB_H)
548
# define _XOS_INCLUDED_NETDB_H
549
#endif
550
551
552
/***** <dirent.h> wrappers *****/
553
554
/*
555
* Effective prototypes for <dirent.h> wrappers:
556
*
557
* #define X_INCLUDE_DIRENT_H
558
* #define XOS_USE_..._LOCKING
559
* #include <X11/Xos_r.h>
560
*
561
* typedef ... _Xreaddirparams;
562
*
563
* struct dirent *_XReaddir(DIR *dir_pointer, _Xreaddirparams);
564
*/
565
566
#if defined(X_INCLUDE_DIRENT_H) && !defined(_XOS_INCLUDED_DIRENT_H)
567
# include <sys/types.h>
568
# if !defined(X_NOT_POSIX) || defined(SYSV) || defined(USG)
569
# include <dirent.h>
570
# else
571
# include <sys/dir.h>
572
# ifndef dirent
573
# define dirent direct
574
# endif
575
# endif
576
# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_DIRENTAPI)
577
# define XOS_USE_MTSAFE_DIRENTAPI 1
578
# endif
579
#endif
580
581
#if !defined(X_INCLUDE_DIRENT_H) || defined(_XOS_INCLUDED_DIRENT_H)
582
/* Do nothing. */
583
584
#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API)
585
/* Use regular, unsafe API. */
586
typedef int _Xreaddirparams; /* dummy */
587
# define _XReaddir(d,p) readdir(d)
588
589
#elif !defined(XOS_USE_MTSAFE_DIRENTAPI) || defined(XNO_MTSAFE_DIRENTAPI)
590
/* Systems with thread support but no _r API. */
591
typedef struct {
592
struct dirent *result;
593
struct dirent dir_entry;
594
# ifdef _POSIX_PATH_MAX
595
char buf[_POSIX_PATH_MAX];
596
# elif defined(NAME_MAX)
597
char buf[NAME_MAX];
598
# else
599
char buf[255];
600
# endif
601
} _Xreaddirparams;
602
603
# define _XReaddir(d,p) \
604
( (_Xos_processLock), \
605
(((p).result = readdir((d))) ? \
606
(memcpy(&((p).dir_entry), (p).result, (p).result->d_reclen), \
607
((p).result = &(p).dir_entry), 0) : \
608
0), \
609
(_Xos_processUnlock), \
610
(p).result )
611
612
#else
613
typedef struct {
614
struct dirent *result;
615
struct dirent dir_entry;
616
# ifdef _POSIX_PATH_MAX
617
char buf[_POSIX_PATH_MAX];
618
# elif defined(NAME_MAX)
619
char buf[NAME_MAX];
620
# else
621
char buf[255];
622
# endif
623
} _Xreaddirparams;
624
625
# if defined(_POSIX_THREAD_SAFE_FUNCTIONS) || defined(AIXV3) || \
626
defined(AIXV4) || defined(__APPLE__)
627
/* AIX defines the draft POSIX symbol, but uses the final API. */
628
/* POSIX final API, returns (int)0 on success. */
629
# if defined(__osf__)
630
/* OSF/1 V4.0 <dirent.h> doesn't declare _Preaddir_r, breaking under C++. */
631
extern int _Preaddir_r(DIR *, struct dirent *, struct dirent **);
632
# endif
633
# define _XReaddir(d,p) \
634
(readdir_r((d), &((p).dir_entry), &((p).result)) ? NULL : (p).result)
635
# elif defined(_POSIX_REENTRANT_FUNCTIONS) && defined(__osf__)
636
/*
637
* OSF/1 V3.2 readdir_r() will SEGV if the main program is not
638
* explicitly linked with -lc_r. The library REQUIREDLIBS don't help.
639
* Assume that if threads have been initialized we're linked properly.
640
*/
641
# define _XReaddir(d,p) \
642
( (_Xos_isThreadInitialized) ? \
643
(readdir_r((d), &((p).dir_entry)) ? NULL : &((p).dir_entry)) : \
644
((_Xos_processLock), \
645
(((p).result = readdir((d))) ? \
646
(memcpy(&((p).dir_entry), (p).result, (p).result->d_reclen), \
647
((p).result = &(p).dir_entry), 0) : \
648
0), \
649
(_Xos_processUnlock), \
650
(p).result) )
651
# elif defined(_POSIX_REENTRANT_FUNCTIONS)
652
/* POSIX draft API, returns (int)0 on success. */
653
# define _XReaddir(d,p) \
654
(readdir_r((d),&((p).dir_entry)) ? NULL : &((p).dir_entry))
655
# elif defined(SVR4)
656
/* Pre-POSIX API, returns non-NULL on success. */
657
# define _XReaddir(d,p) (readdir_r((d), &(p).dir_entry))
658
# else
659
/* We have no idea what is going on. Fake it all using process locks. */
660
# define _XReaddir(d,p) \
661
( (_Xos_processLock), \
662
(((p).result = readdir((d))) ? \
663
(memcpy(&((p).dir_entry), (p).result, (p).result->d_reclen), \
664
((p).result = &(p).dir_entry), 0) : \
665
0), \
666
(_Xos_processUnlock), \
667
(p).result )
668
# endif
669
#endif /* X_INCLUDE_DIRENT_H */
670
671
#if defined(X_INCLUDE_DIRENT_H) && !defined(_XOS_INCLUDED_DIRENT_H)
672
# define _XOS_INCLUDED_DIRENT_H
673
#endif
674
675
676
/***** <unistd.h> wrappers *****/
677
678
/*
679
* Effective prototypes for <unistd.h> wrappers:
680
*
681
* #define X_INCLUDE_UNISTD_H
682
* #define XOS_USE_..._LOCKING
683
* #include <X11/Xos_r.h>
684
*
685
* typedef ... _Xgetloginparams;
686
* typedef ... _Xttynameparams;
687
*
688
* char *_XGetlogin(_Xgetloginparams);
689
* char *_XTtyname(int, _Xttynameparams);
690
*/
691
692
#if defined(X_INCLUDE_UNISTD_H) && !defined(_XOS_INCLUDED_UNISTD_H)
693
/* <unistd.h> already included by <X11/Xos.h> */
694
# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_UNISTDAPI)
695
# define XOS_USE_MTSAFE_UNISTDAPI 1
696
# endif
697
#endif
698
699
#if !defined(X_INCLUDE_UNISTD_H) || defined(_XOS_INCLUDED_UNISTD_H)
700
/* Do nothing. */
701
702
#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API)
703
/* Use regular, unsafe API. */
704
typedef int _Xgetloginparams; /* dummy */
705
typedef int _Xttynameparams; /* dummy */
706
# define _XGetlogin(p) getlogin()
707
# define _XTtyname(f) ttyname((f))
708
709
#elif !defined(XOS_USE_MTSAFE_UNISTDAPI) || defined(XNO_MTSAFE_UNISTDAPI)
710
/* Systems with thread support but no _r API. */
711
typedef struct {
712
char *result;
713
# if defined(MAXLOGNAME)
714
char buf[MAXLOGNAME];
715
# elif defined(LOGIN_NAME_MAX)
716
char buf[LOGIN_NAME_MAX];
717
# else
718
char buf[64];
719
# endif
720
} _Xgetloginparams;
721
typedef struct {
722
char *result;
723
# ifdef TTY_NAME_MAX
724
char buf[TTY_NAME_MAX];
725
# elif defined(_POSIX_TTY_NAME_MAX)
726
char buf[_POSIX_TTY_NAME_MAX];
727
# elif defined(_POSIX_PATH_MAX)
728
char buf[_POSIX_PATH_MAX];
729
# else
730
char buf[256];
731
# endif
732
} _Xttynameparams;
733
734
# define _XGetlogin(p) \
735
( (_Xos_processLock), \
736
(((p).result = getlogin()) ? \
737
(strncpy((p).buf, (p).result, sizeof((p).buf)), \
738
((p).buf[sizeof((p).buf)-1] = '\0'), \
739
((p).result = (p).buf), 0) : 0), \
740
(_Xos_processUnlock), \
741
(p).result )
742
#define _XTtyname(f,p) \
743
( (_Xos_processLock), \
744
(((p).result = ttyname(f)) ? \
745
(strncpy((p).buf, (p).result, sizeof((p).buf)), \
746
((p).buf[sizeof((p).buf)-1] = '\0'), \
747
((p).result = (p).buf), 0) : 0), \
748
(_Xos_processUnlock), \
749
(p).result )
750
751
#elif defined(_POSIX_THREAD_SAFE_FUNCTIONS) || defined(_POSIX_REENTRANT_FUNCTIONS)
752
/* POSIX API.
753
*
754
* extern int getlogin_r(char *, size_t);
755
* extern int ttyname_r(int, char *, size_t);
756
*/
757
typedef struct {
758
# if defined(MAXLOGNAME)
759
char buf[MAXLOGNAME];
760
# elif defined(LOGIN_NAME_MAX)
761
char buf[LOGIN_NAME_MAX];
762
# else
763
char buf[64];
764
# endif
765
} _Xgetloginparams;
766
typedef struct {
767
# ifdef TTY_NAME_MAX
768
char buf[TTY_NAME_MAX];
769
# elif defined(_POSIX_TTY_NAME_MAX)
770
char buf[_POSIX_TTY_NAME_MAX];
771
# elif defined(_POSIX_PATH_MAX)
772
char buf[_POSIX_PATH_MAX];
773
# else
774
char buf[256];
775
# endif
776
} _Xttynameparams;
777
778
# define _XGetlogin(p) (getlogin_r((p).buf, sizeof((p).buf)) ? NULL : (p).buf)
779
# define _XTtyname(f,p) \
780
(ttyname_r((f), (p).buf, sizeof((p).buf)) ? NULL : (p).buf)
781
782
#else
783
/* Pre-POSIX API.
784
*
785
* extern char *getlogin_r(char *, size_t);
786
* extern char *ttyname_r(int, char *, size_t);
787
*/
788
typedef struct {
789
# if defined(MAXLOGNAME)
790
char buf[MAXLOGNAME];
791
# elif defined(LOGIN_NAME_MAX)
792
char buf[LOGIN_NAME_MAX];
793
# else
794
char buf[64];
795
# endif
796
} _Xgetloginparams;
797
typedef struct {
798
# ifdef TTY_NAME_MAX
799
char buf[TTY_NAME_MAX];
800
# elif defined(_POSIX_TTY_NAME_MAX)
801
char buf[_POSIX_TTY_NAME_MAX];
802
# elif defined(_POSIX_PATH_MAX)
803
char buf[_POSIX_PATH_MAX];
804
# else
805
char buf[256];
806
# endif
807
} _Xttynameparams;
808
809
# define _XGetlogin(p) getlogin_r((p).buf, sizeof((p).buf))
810
# define _XTtyname(f,p) ttyname_r((f), (p).buf, sizeof((p).buf))
811
#endif /* X_INCLUDE_UNISTD_H */
812
813
#if defined(X_INCLUDE_UNISTD_H) && !defined(_XOS_INCLUDED_UNISTD_H)
814
# define _XOS_INCLUDED_UNISTD_H
815
#endif
816
817
818
/***** <string.h> wrappers *****/
819
820
/*
821
* Effective prototypes for <string.h> wrappers:
822
*
823
* #define X_INCLUDE_STRING_H
824
* #define XOS_USE_..._LOCKING
825
* #include <X11/Xos_r.h>
826
*
827
* typedef ... _Xstrtokparams;
828
*
829
* char *_XStrtok(char *, const char*, _Xstrtokparams);
830
*/
831
832
#if defined(X_INCLUDE_STRING_H) && !defined(_XOS_INCLUDED_STRING_H)
833
/* <string.h> has already been included by <X11/Xos.h> */
834
# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_STRINGAPI)
835
# define XOS_USE_MTSAFE_STRINGAPI 1
836
# endif
837
#endif
838
839
#if !defined(X_INCLUDE_STRING_H) || defined(_XOS_INCLUDED_STRING_H)
840
/* Do nothing. */
841
842
#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API)
843
/* Use regular, unsafe API. */
844
typedef int _Xstrtokparams; /* dummy */
845
# define _XStrtok(s1,s2,p) \
846
( p = 0, (void)p, strtok((s1),(s2)) )
847
848
#elif !defined(XOS_USE_MTSAFE_STRINGAPI) || defined(XNO_MTSAFE_STRINGAPI)
849
/* Systems with thread support but no _r API. */
850
typedef char *_Xstrtokparams;
851
# define _XStrtok(s1,s2,p) \
852
( (_Xos_processLock), \
853
((p) = strtok((s1),(s2))), \
854
(_Xos_processUnlock), \
855
(p) )
856
857
#else
858
/* POSIX or pre-POSIX API. */
859
typedef char * _Xstrtokparams;
860
# define _XStrtok(s1,s2,p) strtok_r((s1),(s2),&(p))
861
#endif /* X_INCLUDE_STRING_H */
862
863
864
/***** <time.h> wrappers *****/
865
866
/*
867
* Effective prototypes for <time.h> wrappers:
868
*
869
* #define X_INCLUDE_TIME_H
870
* #define XOS_USE_..._LOCKING
871
* #include <X11/Xos_r.h>
872
*
873
* typedef ... _Xatimeparams;
874
* typedef ... _Xctimeparams;
875
* typedef ... _Xgtimeparams;
876
* typedef ... _Xltimeparams;
877
*
878
* char *_XAsctime(const struct tm *, _Xatimeparams);
879
* char *_XCtime(const time_t *, _Xctimeparams);
880
* struct tm *_XGmtime(const time_t *, _Xgtimeparams);
881
* struct tm *_XLocaltime(const time_t *, _Xltimeparams);
882
*/
883
884
#if defined(X_INCLUDE_TIME_H) && !defined(_XOS_INCLUDED_TIME_H)
885
# include <time.h>
886
# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_TIMEAPI)
887
# define XOS_USE_MTSAFE_TIMEAPI 1
888
# endif
889
#endif
890
891
#if !defined(X_INCLUDE_TIME_H) || defined(_XOS_INCLUDED_TIME_H)
892
/* Do nothing. */
893
894
#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API)
895
/* Use regular, unsafe API. */
896
typedef int _Xatimeparams; /* dummy */
897
# define _XAsctime(t,p) asctime((t))
898
typedef int _Xctimeparams; /* dummy */
899
# define _XCtime(t,p) ctime((t))
900
typedef int _Xgtimeparams; /* dummy */
901
# define _XGmtime(t,p) gmtime((t))
902
typedef int _Xltimeparams; /* dummy */
903
# define _XLocaltime(t,p) localtime((t))
904
905
#elif !defined(XOS_USE_MTSAFE_TIMEAPI) || defined(XNO_MTSAFE_TIMEAPI)
906
/* Systems with thread support but no _r API. */
907
typedef struct {
908
# ifdef TIMELEN
909
char buf[TIMELEN];
910
# else
911
char buf[26];
912
# endif
913
char *result;
914
} _Xctimeparams, _Xatimeparams;
915
typedef struct {
916
struct tm buf;
917
struct tm *result;
918
} _Xgtimeparams, _Xltimeparams;
919
# define _XAsctime(t,p) \
920
( (_Xos_processLock), \
921
(((p).result = asctime((t))) ? \
922
(strncpy((p).buf, (p).result, sizeof((p).buf)), (p).result = &(p).buf) : \
923
0), \
924
(_Xos_processUnlock), \
925
(p).result )
926
# define _XCtime(t,p) \
927
( (_Xos_processLock), \
928
(((p).result = ctime((t))) ? \
929
(strncpy((p).buf, (p).result, sizeof((p).buf)), (p).result = &(p).buf) : \
930
0), \
931
(_Xos_processUnlock), \
932
(p).result )
933
# define _XGmtime(t,p) \
934
( (_Xos_processLock), \
935
(((p).result = gmtime(t)) ? \
936
(memcpy(&(p).buf, (p).result, sizeof((p).buf)), (p).result = &(p).buf) : \
937
0), \
938
(_Xos_processUnlock), \
939
(p).result )
940
# define _XLocaltime(t,p) \
941
( (_Xos_processLock), \
942
(((p).result = localtime(t)) ? \
943
(memcpy(&(p).buf, (p).result, sizeof((p).buf)), (p).result = &(p).buf) : \
944
0), \
945
(_Xos_processUnlock), \
946
(p).result )
947
948
#elif !defined(_POSIX_THREAD_SAFE_FUNCTIONS) && (defined(__osf__) || defined(hpV4))
949
/* Returns (int)0 on success. OSF/1 v3.2, HP/UX 10
950
*
951
* extern int asctime_r(const struct tm *timeptr, char *buffer, int buflen);
952
* extern int ctime_r(const time_t *timer, char *buffer, int buflen);
953
* extern int gmtime_r(const time_t *timer, struct tm *result);
954
* extern int localtime_r(const time_t *timer, struct tm *result);
955
*/
956
# ifdef TIMELEN
957
typedef char _Xatimeparams[TIMELEN];
958
typedef char _Xctimeparams[TIMELEN];
959
# else
960
typedef char _Xatimeparams[26];
961
typedef char _Xctimeparams[26];
962
# endif
963
typedef struct tm _Xgtimeparams;
964
typedef struct tm _Xltimeparams;
965
# define _XAsctime(t,p) (asctime_r((t),(p),sizeof((p))) ? NULL : (p))
966
# define _XCtime(t,p) (ctime_r((t),(p),sizeof((p))) ? NULL : (p))
967
# define _XGmtime(t,p) (gmtime_r((t),&(p)) ? NULL : &(p))
968
# define _XLocaltime(t,p) (localtime_r((t),&(p)) ? NULL : &(p))
969
970
#elif !defined(_POSIX_THREAD_SAFE_FUNCTIONS) && defined(sun)
971
/* Returns NULL on failure. Solaris 2.5
972
*
973
* extern char *asctime_r(const struct tm *tm,char *buf, int buflen);
974
* extern char *ctime_r(const time_t *clock, char *buf, int buflen);
975
* extern struct tm *gmtime_r(const time_t *clock, struct tm *res);
976
* extern struct tm *localtime_r(const time_t *clock, struct tm *res);
977
*/
978
# ifdef TIMELEN
979
typedef char _Xatimeparams[TIMELEN];
980
typedef char _Xctimeparams[TIMELEN];
981
# else
982
typedef char _Xatimeparams[26];
983
typedef char _Xctimeparams[26];
984
# endif
985
typedef struct tm _Xgtimeparams;
986
typedef struct tm _Xltimeparams;
987
# define _XAsctime(t,p) asctime_r((t),(p),sizeof((p)))
988
# define _XCtime(t,p) ctime_r((t),(p),sizeof((p)))
989
# define _XGmtime(t,p) gmtime_r((t),&(p))
990
# define _XLocaltime(t,p) localtime_r((t),&(p))
991
992
#else /* defined(_POSIX_THREAD_SAFE_FUNCTIONS) */
993
/* POSIX final API. OSF/1 v4.0, AIX, etc.
994
*
995
* extern char *asctime_r(const struct tm *timeptr, char *buffer);
996
* extern char *ctime_r(const time_t *timer, char *buffer);
997
* extern struct tm *gmtime_r(const time_t *timer, struct tm *result);
998
* extern struct tm *localtime_r(const time_t *timer, struct tm *result);
999
*/
1000
# if defined(__osf__)
1001
/* OSF/1 V4.0 <time.h> doesn't declare the _P routines, breaking under C++. */
1002
extern char *_Pasctime_r(const struct tm *, char *);
1003
extern char *_Pctime_r(const time_t *, char *);
1004
extern struct tm *_Plocaltime_r(const time_t *, struct tm *);
1005
# endif
1006
# ifdef TIMELEN
1007
typedef char _Xatimeparams[TIMELEN];
1008
typedef char _Xctimeparams[TIMELEN];
1009
# else
1010
typedef char _Xatimeparams[26];
1011
typedef char _Xctimeparams[26];
1012
# endif
1013
typedef struct tm _Xgtimeparams;
1014
typedef struct tm _Xltimeparams;
1015
# define _XAsctime(t,p) asctime_r((t),(p))
1016
# define _XCtime(t,p) ctime_r((t),(p))
1017
# define _XGmtime(t,p) gmtime_r((t),&(p))
1018
# define _XLocaltime(t,p) localtime_r((t),&(p))
1019
#endif /* X_INCLUDE_TIME_H */
1020
1021
#if defined(X_INCLUDE_TIME_H) && !defined(_XOS_INCLUDED_TIME_H)
1022
# define _XOS_INCLUDED_TIME_H
1023
#endif
1024
1025
1026
/***** <grp.h> wrappers *****/
1027
1028
/*
1029
* Effective prototypes for <grp.h> wrappers:
1030
*
1031
* NOTE: On systems lacking appropriate _r functions Getgrgid() and
1032
* Getgrnam() do NOT copy the list of group members!
1033
*
1034
* Remember that fgetgrent(), setgrent(), getgrent(), and endgrent()
1035
* are not included in POSIX.
1036
*
1037
* #define X_INCLUDE_GRP_H
1038
* #define XOS_USE_..._LOCKING
1039
* #include <X11/Xos_r.h>
1040
*
1041
* typedef ... _Xgetgrparams;
1042
*
1043
* struct group *_XGetgrgid(gid_t, _Xgetgrparams);
1044
* struct group *_XGetgrnam(const char *, _Xgetgrparams);
1045
*/
1046
1047
#if defined(X_INCLUDE_GRP_H) && !defined(_XOS_INCLUDED_GRP_H)
1048
# include <grp.h>
1049
# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_GRPAPI)
1050
# define XOS_USE_MTSAFE_GRPAPI 1
1051
# endif
1052
#endif
1053
1054
#if !defined(X_INCLUDE_GRP_H) || defined(_XOS_INCLUDED_GRP_H)
1055
/* Do nothing. */
1056
1057
#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API)
1058
/* Use regular, unsafe API. */
1059
typedef int _Xgetgrparams; /* dummy */
1060
#define _XGetgrgid(g,p) getgrgid((g))
1061
#define _XGetgrnam(n,p) getgrnam((n))
1062
1063
#elif !defined(XOS_USE_MTSAFE_GRPAPI) || defined(XNO_MTSAFE_GRPAPI)
1064
/* Systems with thread support but no _r API. UnixWare 2.0. */
1065
typedef struct {
1066
struct group grp;
1067
char buf[X_LINE_MAX]; /* Should be sysconf(_SC_GETGR_R_SIZE_MAX)? */
1068
struct group *pgrp;
1069
size_t len;
1070
} _Xgetgrparams;
1071
#ifdef SVR4
1072
/* Copy the gr_passwd field too. */
1073
# define _Xgrp_copyGroup(p) \
1074
( memcpy(&(p).grp, (p).pgrp, sizeof(struct group)), \
1075
((p).grp.gr_name = (p).buf), \
1076
((p).len = strlen((p).pgrp->gr_name)), \
1077
strcpy((p).grp.gr_name, (p).pgrp->gr_name), \
1078
((p).grp.gr_passwd = (p).grp.gr_name + (p).len + 1), \
1079
((p).pgrp = &(p).grp), \
1080
0 )
1081
#else
1082
# define _Xgrp_copyGroup(p) \
1083
( memcpy(&(p).grp, (p).pgrp, sizeof(struct group)), \
1084
((p).grp.gr_name = (p).buf), \
1085
strcpy((p).grp.gr_name, (p).pgrp->gr_name), \
1086
((p).pgrp = &(p).grp), \
1087
0 )
1088
#endif
1089
#define _XGetgrgid(g,p) \
1090
( (_Xos_processLock), \
1091
(((p).pgrp = getgrgid((g))) ? _Xgrp_copyGroup(p) : 0), \
1092
(_Xos_processUnlock), \
1093
(p).pgrp )
1094
#define _XGetgrnam(n,p) \
1095
( (_Xos_processLock), \
1096
(((p).pgrp = getgrnam((n))) ? _Xgrp_copyGroup(p) : 0), \
1097
(_Xos_processUnlock), \
1098
(p).pgrp )
1099
1100
#elif !defined(_POSIX_THREAD_SAFE_FUNCTIONS) && (defined(sun) || defined(__osf__))
1101
/* Non-POSIX API. Solaris, DEC v3.2.
1102
*
1103
* extern struct group *getgrgid_r(gid_t, struct group *, char *, int);
1104
* extern struct group *getgrnam_r(const char *, struct group *, char *, int);
1105
*/
1106
typedef struct {
1107
struct group grp;
1108
char buf[X_LINE_MAX]; /* Should be sysconf(_SC_GETGR_R_SIZE_MAX)? */
1109
} _Xgetgrparams;
1110
#define _XGetgrgid(g,p) getgrgid_r((g), &(p).grp, (p).buf, sizeof((p).buf))
1111
#define _XGetgrnam(n,p) getgrnam_r((n), &(p).grp, (p).buf, sizeof((p).buf))
1112
1113
#elif !defined(_POSIX_THREAD_SAFE_FUNCTIONS)
1114
/* Non-POSIX API. HP/UX 10, AIX 4.
1115
*
1116
* extern int getgrgid_r(gid_t, struct group *, char *, int);
1117
* extern int getgrnam_r(const char *, struct group *, char *, int);
1118
*/
1119
typedef struct {
1120
struct group grp;
1121
char buf[X_LINE_MAX]; /* Should be sysconf(_SC_GETGR_R_SIZE_MAX)? */
1122
} _Xgetgrparams;
1123
#define _XGetgrgid(g,p) \
1124
((getgrgid_r((g), &(p).grp, (p).buf, sizeof((p).buf)) ? NULL : &(p).grp))
1125
#define _XGetgrnam(n,p) \
1126
((getgrnam_r((n), &(p).grp, (p).buf, sizeof((p).buf)) ? NULL : &(p).grp))
1127
1128
#else
1129
/* POSIX final API. DEC v4.0, IRIX 6.2.
1130
*
1131
* int getgrgid_r(gid_t, struct group *, char *, size_t, struct group **);
1132
* int getgrnam_r(const char *, struct group *, char *, size_t, struct group **);
1133
*/
1134
# if defined(__osf__)
1135
/* OSF/1 V4.0 <grp.h> doesn't declare the _P routines, breaking under C++. */
1136
extern int _Pgetgrgid_r(gid_t, struct group *, char *, size_t, struct group **);
1137
extern int _Pgetgrnam_r(const char *, struct group *, char *, size_t, struct group **);
1138
# endif
1139
typedef struct {
1140
struct group grp;
1141
char buf[X_LINE_MAX]; /* Should be sysconf(_SC_GETGR_R_SIZE_MAX)? */
1142
struct group *result;
1143
} _Xgetgrparams;
1144
1145
#define _XGetgrgid(g,p) \
1146
((getgrgid_r((g), &(p).grp, (p).buf, sizeof((p).buf), &(p).result) ? \
1147
NULL : (p).result))
1148
#define _XGetgrnam(n,p) \
1149
((getgrnam_r((n), &(p).grp, (p).buf, sizeof((p).buf), &(p).result) ? \
1150
NULL : (p).result))
1151
#endif
1152
1153
#if defined(X_INCLUDE_GRP_H) && !defined(_XOS_INCLUDED_GRP_H)
1154
# define _XOS_INCLUDED_GRP_H
1155
#endif
1156
1157
1158
#ifdef __cplusplus
1159
} /* Close scope of 'extern "C"' declaration which encloses file. */
1160
#endif
Loggerhead is a web-based interface for Breezy
Version: 2.0.1