Xos_r.h@ 83531

Last change on this file since 83531 was 32163, checked in by vboxsync, 14 years ago
Additions/x11/x11include: additional headers for building drivers for X.Org Server 1.9
Property svn:eol-style set to `native`
File size: 32.9 KB

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

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

source: vbox/trunk/src/VBox/Additions/x11/x11include/xproto-7.0.18/X11/Xos_r.h@ 83531

Download in other formats: