Xos_r.h@ 17236

Last change on this file since 17236 was 17236, checked in by vboxsync, 16 years ago
Additions/x11/x11include: blast! Reverted r43555 and r43556
Property svn:eol-style set to `native`
File size: 35.9 KB

Line
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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Additions/x11/x11include/7.0/X11/Xos_r.h@ 17236

Download in other formats: