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 1096
