projects / openwrt / svn-archive / archive.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
added new XOrg folders/makefiles
[openwrt/svn-archive/archive.git] / XOrg / headers / native / src / X11 / Xos_r.h
1 /* $Xorg: Xos_r.h,v 1.4 2001/02/09 02:03:22 xorgcvs Exp $ */
2 /* $XdotOrg: proto/X11/Xos_r.h,v 1.6 2006/04/20 01:24:25 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_isThreadInitialized. 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 appropriate _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
OpenWrt SVN history