diff options
Diffstat (limited to 'include/X11/Xos_r.h')
| -rw-r--r-- | include/X11/Xos_r.h | 1095 |
1 files changed, 1095 insertions, 0 deletions
diff --git a/include/X11/Xos_r.h b/include/X11/Xos_r.h new file mode 100644 index 0000000..f963b64 --- /dev/null +++ b/include/X11/Xos_r.h @@ -0,0 +1,1095 @@ +/* +Copyright 1996, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. +*/ + +/* + * Various and sundry Thread-Safe functions used by X11, Motif, and CDE. + * + * Use this file in MT-safe code where you would have included + * <dirent.h> for readdir() + * <grp.h> for getgrgid() or getgrnam() + * <netdb.h> for gethostbyname(), gethostbyaddr(), or getservbyname() + * <pwd.h> for getpwnam() or getpwuid() + * <string.h> for strtok() + * <time.h> for asctime(), ctime(), localtime(), or gmtime() + * <unistd.h> for getlogin() or ttyname() + * or their thread-safe analogs. + * + * If you are on a platform that defines XTHREADS but does not have + * MT-safe system API (e.g. UnixWare) you must define _Xos_processLock + * and _Xos_processUnlock macros before including this header. + * + * For convenience XOS_USE_XLIB_LOCKING or XOS_USE_XT_LOCKING may be defined + * to obtain either Xlib-only or Xt-based versions of these macros. These + * macros won't result in truly thread-safe calls, but they are better than + * nothing. If you do not want locking in this situation define + * XOS_USE_NO_LOCKING. + * + * NOTE: On systems lacking appropriate _r functions Gethostbyname(), + * Gethostbyaddr(), and Getservbyname() do NOT copy the host or + * protocol lists! + * + * NOTE: On systems lacking appropriate _r functions Getgrgid() and + * Getgrnam() do NOT copy the list of group members! + * + * This header is nominally intended to simplify porting X11, Motif, and + * CDE; it may be useful to other people too. The structure below is + * complicated, mostly because P1003.1c (the IEEE POSIX Threads spec) + * went through lots of drafts, and some vendors shipped systems based + * on draft API that were changed later. Unfortunately POSIX did not + * provide a feature-test macro for distinguishing each of the drafts. + */ + +/* + * This header has several parts. Search for "Effective prototypes" + * to locate the beginning of a section. + */ + +/* This header can be included multiple times with different defines! */ +#ifndef _XOS_R_H_ +# define _XOS_R_H_ + +# include <X11/Xos.h> +# include <X11/Xfuncs.h> + +# ifndef X_NOT_POSIX +# ifdef _POSIX_SOURCE +# include <limits.h> +# else +# define _POSIX_SOURCE +# include <limits.h> +# undef _POSIX_SOURCE +# endif +# ifndef LINE_MAX +# define X_LINE_MAX 2048 +# else +# define X_LINE_MAX LINE_MAX +# endif +# endif +#endif /* _XOS_R_H */ + +#ifndef WIN32 + +#ifdef __cplusplus +extern "C" { +#endif + +# if defined(XOS_USE_XLIB_LOCKING) +# ifndef XAllocIDs /* Xlibint.h does not have multiple include protection */ +typedef struct _LockInfoRec *LockInfoPtr; +extern LockInfoPtr _Xglobal_lock; +# endif +# ifndef _Xos_isThreadInitialized +# define _Xos_isThreadInitialized (_Xglobal_lock) +# endif +# if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE) +# ifndef XAllocIDs /* Xlibint.h does not have multiple include protection */ +# include <X11/Xfuncproto.h> /* for NeedFunctionPrototypes */ +extern void (*_XLockMutex_fn)( +# if NeedFunctionPrototypes + LockInfoPtr /* lock */, char * /* file */, int /* line */ +# endif +); +extern void (*_XUnlockMutex_fn)( +# if NeedFunctionPrototypes + LockInfoPtr /* lock */, char * /* file */, int /* line */ +# endif +); +# endif +# ifndef _Xos_processLock +# define _Xos_processLock \ + (_XLockMutex_fn ? (*_XLockMutex_fn)(_Xglobal_lock,__FILE__,__LINE__) : 0) +# endif +# ifndef _Xos_processUnlock +# define _Xos_processUnlock \ + (_XUnlockMutex_fn ? (*_XUnlockMutex_fn)(_Xglobal_lock,__FILE__,__LINE__) : 0) +# endif +# else +# ifndef XAllocIDs /* Xlibint.h does not have multiple include protection */ +# include <X11/Xfuncproto.h> /* for NeedFunctionPrototypes */ +extern void (*_XLockMutex_fn)( +# if NeedFunctionPrototypes + LockInfoPtr /* lock */ +# endif +); +extern void (*_XUnlockMutex_fn)( +# if NeedFunctionPrototypes + LockInfoPtr /* lock */ +# endif +); +# endif +# ifndef _Xos_processLock +# define _Xos_processLock \ + (_XLockMutex_fn ? ((*_XLockMutex_fn)(_Xglobal_lock), 0) : 0) +# endif +# ifndef _Xos_processUnlock +# define _Xos_processUnlock \ + (_XUnlockMutex_fn ? ((*_XUnlockMutex_fn)(_Xglobal_lock), 0) : 0) +# endif +# endif +# elif defined(XOS_USE_XT_LOCKING) +# ifndef _XtThreadsI_h +extern void (*_XtProcessLock)(void); +# endif +# ifndef _XtintrinsicP_h +# include <X11/Xfuncproto.h> /* for NeedFunctionPrototypes */ +extern void XtProcessLock( +# if NeedFunctionPrototypes + void +# endif +); +extern void XtProcessUnlock( +# if NeedFunctionPrototypes + void +# endif +); +# endif +# ifndef _Xos_isThreadInitialized +# define _Xos_isThreadInitialized _XtProcessLock +# endif +# ifndef _Xos_processLock +# define _Xos_processLock XtProcessLock() +# endif +# ifndef _Xos_processUnlock +# define _Xos_processUnlock XtProcessUnlock() +# endif +# elif defined(XOS_USE_NO_LOCKING) +# ifndef _Xos_isThreadInitialized +# define _Xos_isThreadInitialized 0 +# endif +# ifndef _Xos_processLock +# define _Xos_processLock 0 +# endif +# ifndef _Xos_processUnlock +# define _Xos_processUnlock 0 +# endif +# endif + +#endif /* !defined WIN32 */ + +/* + * Solaris defines the POSIX thread-safe feature test macro, but + * uses the older SVR4 thread-safe functions unless the POSIX ones + * are specifically requested. Fix the feature test macro. + */ +#if defined(__sun) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && \ + (_POSIX_C_SOURCE - 0 < 199506L) && !defined(_POSIX_PTHREAD_SEMANTICS) +# undef _POSIX_THREAD_SAFE_FUNCTIONS +#endif + +/***** <pwd.h> wrappers *****/ + +/* + * Effective prototypes for <pwd.h> wrappers: + * + * #define X_INCLUDE_PWD_H + * #define XOS_USE_..._LOCKING + * #include <X11/Xos_r.h> + * + * typedef ... _Xgetpwparams; + * + * struct passwd* _XGetpwnam(const char *name, _Xgetpwparams); + * struct passwd* _XGetpwuid(uid_t uid, _Xgetpwparams); + */ + +#if defined(X_INCLUDE_PWD_H) && !defined(_XOS_INCLUDED_PWD_H) +# include <pwd.h> +# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_PWDAPI) +# define XOS_USE_MTSAFE_PWDAPI 1 +# endif +#endif + +#undef X_NEEDS_PWPARAMS +#if !defined(X_INCLUDE_PWD_H) || defined(_XOS_INCLUDED_PWD_H) +/* Do nothing */ + +#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API) +/* Use regular, unsafe API. */ +# if defined(X_NOT_POSIX) && !defined(__i386__) && !defined(SYSV) +extern struct passwd *getpwuid(), *getpwnam(); +# endif +typedef int _Xgetpwparams; /* dummy */ +# define _XGetpwuid(u,p) getpwuid((u)) +# define _XGetpwnam(u,p) getpwnam((u)) + +#elif !defined(XOS_USE_MTSAFE_PWDAPI) || defined(XNO_MTSAFE_PWDAPI) +/* UnixWare 2.0, or other systems with thread support but no _r API. */ +# define X_NEEDS_PWPARAMS +typedef struct { + struct passwd pws; + char pwbuf[1024]; + struct passwd* pwp; + size_t len; +} _Xgetpwparams; + +/* + * NetBSD and FreeBSD, at least, are missing several of the unixware passwd + * fields. + */ + +#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || \ + defined(__APPLE__) || defined(__DragonFly__) +static __inline__ void _Xpw_copyPasswd(_Xgetpwparams p) +{ + memcpy(&(p).pws, (p).pwp, sizeof(struct passwd)); + + (p).pws.pw_name = (p).pwbuf; + (p).len = strlen((p).pwp->pw_name); + strcpy((p).pws.pw_name, (p).pwp->pw_name); + + (p).pws.pw_passwd = (p).pws.pw_name + (p).len + 1; + (p).len = strlen((p).pwp->pw_passwd); + strcpy((p).pws.pw_passwd,(p).pwp->pw_passwd); + + (p).pws.pw_class = (p).pws.pw_passwd + (p).len + 1; + (p).len = strlen((p).pwp->pw_class); + strcpy((p).pws.pw_class, (p).pwp->pw_class); + + (p).pws.pw_gecos = (p).pws.pw_class + (p).len + 1; + (p).len = strlen((p).pwp->pw_gecos); + strcpy((p).pws.pw_gecos, (p).pwp->pw_gecos); + + (p).pws.pw_dir = (p).pws.pw_gecos + (p).len + 1; + (p).len = strlen((p).pwp->pw_dir); + strcpy((p).pws.pw_dir, (p).pwp->pw_dir); + + (p).pws.pw_shell = (p).pws.pw_dir + (p).len + 1; + (p).len = strlen((p).pwp->pw_shell); + strcpy((p).pws.pw_shell, (p).pwp->pw_shell); + + (p).pwp = &(p).pws; +} + +#else +# define _Xpw_copyPasswd(p) \ + (memcpy(&(p).pws, (p).pwp, sizeof(struct passwd)), \ + ((p).pws.pw_name = (p).pwbuf), \ + ((p).len = strlen((p).pwp->pw_name)), \ + strcpy((p).pws.pw_name, (p).pwp->pw_name), \ + ((p).pws.pw_passwd = (p).pws.pw_name + (p).len + 1), \ + ((p).len = strlen((p).pwp->pw_passwd)), \ + strcpy((p).pws.pw_passwd,(p).pwp->pw_passwd), \ + ((p).pws.pw_age = (p).pws.pw_passwd + (p).len + 1), \ + ((p).len = strlen((p).pwp->pw_age)), \ + strcpy((p).pws.pw_age, (p).pwp->pw_age), \ + ((p).pws.pw_comment = (p).pws.pw_age + (p).len + 1), \ + ((p).len = strlen((p).pwp->pw_comment)), \ + strcpy((p).pws.pw_comment, (p).pwp->pw_comment), \ + ((p).pws.pw_gecos = (p).pws.pw_comment + (p).len + 1), \ + ((p).len = strlen((p).pwp->pw_gecos)), \ + strcpy((p).pws.pw_gecos, (p).pwp->pw_gecos), \ + ((p).pws.pw_dir = (p).pws.pw_comment + (p).len + 1), \ + ((p).len = strlen((p).pwp->pw_dir)), \ + strcpy((p).pws.pw_dir, (p).pwp->pw_dir), \ + ((p).pws.pw_shell = (p).pws.pw_dir + (p).len + 1), \ + ((p).len = strlen((p).pwp->pw_shell)), \ + strcpy((p).pws.pw_shell, (p).pwp->pw_shell), \ + ((p).pwp = &(p).pws), \ + 0 ) +#endif +# define _XGetpwuid(u,p) \ +( (_Xos_processLock), \ + (((p).pwp = getpwuid((u))) ? _Xpw_copyPasswd(p), 0 : 0), \ + (_Xos_processUnlock), \ + (p).pwp ) +# define _XGetpwnam(u,p) \ +( (_Xos_processLock), \ + (((p).pwp = getpwnam((u))) ? _Xpw_copyPasswd(p), 0 : 0), \ + (_Xos_processUnlock), \ + (p).pwp ) + +#elif !defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(__APPLE__) +# define X_NEEDS_PWPARAMS +typedef struct { + struct passwd pws; + char pwbuf[X_LINE_MAX]; +} _Xgetpwparams; +# if defined(_POSIX_REENTRANT_FUNCTIONS) || !defined(SVR4) +# define _XGetpwuid(u,p) \ +((getpwuid_r((u),&(p).pws,(p).pwbuf,sizeof((p).pwbuf)) == -1) ? NULL : &(p).pws) +# define _XGetpwnam(u,p) \ +((getpwnam_r((u),&(p).pws,(p).pwbuf,sizeof((p).pwbuf)) == -1) ? NULL : &(p).pws) +# else /* SVR4 */ +# define _XGetpwuid(u,p) \ +((getpwuid_r((u),&(p).pws,(p).pwbuf,sizeof((p).pwbuf)) == NULL) ? NULL : &(p).pws) +# define _XGetpwnam(u,p) \ +((getpwnam_r((u),&(p).pws,(p).pwbuf,sizeof((p).pwbuf)) == NULL) ? NULL : &(p).pws) +# endif /* SVR4 */ + +#else /* _POSIX_THREAD_SAFE_FUNCTIONS */ +# define X_NEEDS_PWPARAMS +typedef struct { + struct passwd pws; + char pwbuf[X_LINE_MAX]; + struct passwd* pwp; +} _Xgetpwparams; +typedef int _Xgetpwret; +# define _XGetpwuid(u,p) \ +((getpwuid_r((u),&(p).pws,(p).pwbuf,sizeof((p).pwbuf),&(p).pwp) == 0) ? \ + (p).pwp : NULL) +# define _XGetpwnam(u,p) \ +((getpwnam_r((u),&(p).pws,(p).pwbuf,sizeof((p).pwbuf),&(p).pwp) == 0) ? \ + (p).pwp : NULL) +#endif /* X_INCLUDE_PWD_H */ + +#if defined(X_INCLUDE_PWD_H) && !defined(_XOS_INCLUDED_PWD_H) +# define _XOS_INCLUDED_PWD_H +#endif + + +/***** <netdb.h> wrappers *****/ + +/* + * Effective prototypes for <netdb.h> wrappers: + * + * NOTE: On systems lacking the appropriate _r functions Gethostbyname(), + * Gethostbyaddr(), and Getservbyname() do NOT copy the host or + * protocol lists! + * + * #define X_INCLUDE_NETDB_H + * #define XOS_USE_..._LOCKING + * #include <X11/Xos_r.h> + * + * typedef ... _Xgethostbynameparams; + * typedef ... _Xgetservbynameparams; + * + * struct hostent* _XGethostbyname(const char* name,_Xgethostbynameparams); + * struct hostent* _XGethostbyaddr(const char* addr, int len, int type, + * _Xgethostbynameparams); + * struct servent* _XGetservbyname(const char* name, const char* proto, + * _Xgetservbynameparams); + */ + +#undef XTHREADS_NEEDS_BYNAMEPARAMS +#if defined(X_INCLUDE_NETDB_H) && !defined(_XOS_INCLUDED_NETDB_H) \ + && !defined(WIN32) +# include <netdb.h> +# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_NETDBAPI) +# define XOS_USE_MTSAFE_NETDBAPI 1 +# endif +#endif + +#if !defined(X_INCLUDE_NETDB_H) || defined(_XOS_INCLUDED_NETDB_H) +/* Do nothing. */ + +#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API) +/* Use regular, unsafe API. */ +typedef int _Xgethostbynameparams; /* dummy */ +typedef int _Xgetservbynameparams; /* dummy */ +# define _XGethostbyname(h,hp) gethostbyname((h)) +# define _XGethostbyaddr(a,al,t,hp) gethostbyaddr((a),(al),(t)) +# define _XGetservbyname(s,p,sp) getservbyname((s),(p)) + +#elif !defined(XOS_USE_MTSAFE_NETDBAPI) || defined(XNO_MTSAFE_NETDBAPI) +/* WARNING: The h_addr_list and s_aliases values are *not* copied! */ + +#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) +#include <sys/param.h> +#endif + +typedef struct { + struct hostent hent; + char h_name[MAXHOSTNAMELEN]; + struct hostent *hptr; +} _Xgethostbynameparams; +typedef struct { + struct servent sent; + char s_name[255]; + char s_proto[255]; + struct servent *sptr; +} _Xgetservbynameparams; + +# define XTHREADS_NEEDS_BYNAMEPARAMS + +# define _Xg_copyHostent(hp) \ + (memcpy(&(hp).hent, (hp).hptr, sizeof(struct hostent)), \ + strcpy((hp).h_name, (hp).hptr->h_name), \ + ((hp).hent.h_name = (hp).h_name), \ + ((hp).hptr = &(hp).hent), \ + 0 ) +# define _Xg_copyServent(sp) \ + (memcpy(&(sp).sent, (sp).sptr, sizeof(struct servent)), \ + strcpy((sp).s_name, (sp).sptr->s_name), \ + ((sp).sent.s_name = (sp).s_name), \ + strcpy((sp).s_proto, (sp).sptr->s_proto), \ + ((sp).sent.s_proto = (sp).s_proto), \ + ((sp).sptr = &(sp).sent), \ + 0 ) +# define _XGethostbyname(h,hp) \ + ((_Xos_processLock), \ + (((hp).hptr = gethostbyname((h))) ? _Xg_copyHostent(hp) : 0), \ + (_Xos_processUnlock), \ + (hp).hptr ) +# define _XGethostbyaddr(a,al,t,hp) \ + ((_Xos_processLock), \ + (((hp).hptr = gethostbyaddr((a),(al),(t))) ? _Xg_copyHostent(hp) : 0), \ + (_Xos_processUnlock), \ + (hp).hptr ) +# define _XGetservbyname(s,p,sp) \ + ((_Xos_processLock), \ + (((sp).sptr = getservbyname((s),(p))) ? _Xg_copyServent(sp) : 0), \ + (_Xos_processUnlock), \ + (sp).sptr ) + +#elif defined(XUSE_NETDB_R_API) +/* + * POSIX does not specify _r equivalents for <netdb.h> API, but some + * vendors provide them anyway. Use them only when explicitly asked. + */ +# ifdef _POSIX_REENTRANT_FUNCTIONS +# ifndef _POSIX_THREAD_SAFE_FUNCTIONS +# endif +# endif +# ifdef _POSIX_THREAD_SAFE_FUNCTIONS +# define X_POSIX_THREAD_SAFE_FUNCTIONS 1 +# endif + +# define XTHREADS_NEEDS_BYNAMEPARAMS + +# ifndef X_POSIX_THREAD_SAFE_FUNCTIONS +typedef struct { + struct hostent hent; + char hbuf[X_LINE_MAX]; + int herr; +} _Xgethostbynameparams; +typedef struct { + struct servent sent; + char sbuf[X_LINE_MAX]; +} _Xgetservbynameparams; +# define _XGethostbyname(h,hp) \ + gethostbyname_r((h),&(hp).hent,(hp).hbuf,sizeof((hp).hbuf),&(hp).herr) +# define _XGethostbyaddr(a,al,t,hp) \ + gethostbyaddr_r((a),(al),(t),&(hp).hent,(hp).hbuf,sizeof((hp).hbuf),&(hp).herr) +# define _XGetservbyname(s,p,sp) \ + getservbyname_r((s),(p),&(sp).sent,(sp).sbuf,sizeof((sp).sbuf)) +# else +typedef struct { + struct hostent hent; + struct hostent_data hdata; +} _Xgethostbynameparams; +typedef struct { + struct servent sent; + struct servent_data sdata; +} _Xgetservbynameparams; +# define _XGethostbyname(h,hp) \ + (bzero((char*)&(hp).hdata,sizeof((hp).hdata)), \ + ((gethostbyname_r((h),&(hp).hent,&(hp).hdata) == -1) ? NULL : &(hp).hent)) +# define _XGethostbyaddr(a,al,t,hp) \ + (bzero((char*)&(hp).hdata,sizeof((hp).hdata)), \ + ((gethostbyaddr_r((a),(al),(t),&(hp).hent,&(hp).hdata) == -1) ? NULL : &(hp).hent)) +# define _XGetservbyname(s,p,sp) \ + (bzero((char*)&(sp).sdata,sizeof((sp).sdata)), \ + ((getservbyname_r((s),(p),&(sp).sent,&(sp).sdata) == -1) ? NULL : &(sp).sent) ) +# endif +# ifdef X_POSIX_THREAD_SAFE_FUNCTIONS +# undef X_POSIX_THREAD_SAFE_FUNCTIONS +# endif + +#else +/* The regular API is assumed to be MT-safe under POSIX. */ +typedef int _Xgethostbynameparams; /* dummy */ +typedef int _Xgetservbynameparams; /* dummy */ +# define _XGethostbyname(h,hp) gethostbyname((h)) +# define _XGethostbyaddr(a,al,t,hp) gethostbyaddr((a),(al),(t)) +# define _XGetservbyname(s,p,sp) getservbyname((s),(p)) +#endif /* X_INCLUDE_NETDB_H */ + +#if defined(X_INCLUDE_NETDB_H) && !defined(_XOS_INCLUDED_NETDB_H) +# define _XOS_INCLUDED_NETDB_H +#endif + + +/***** <dirent.h> wrappers *****/ + +/* + * Effective prototypes for <dirent.h> wrappers: + * + * #define X_INCLUDE_DIRENT_H + * #define XOS_USE_..._LOCKING + * #include <X11/Xos_r.h> + * + * typedef ... _Xreaddirparams; + * + * struct dirent *_XReaddir(DIR *dir_pointer, _Xreaddirparams); + */ + +#if defined(X_INCLUDE_DIRENT_H) && !defined(_XOS_INCLUDED_DIRENT_H) +# include <sys/types.h> +# if !defined(X_NOT_POSIX) || defined(SYSV) +# include <dirent.h> +# else +# include <sys/dir.h> +# ifndef dirent +# define dirent direct +# endif +# endif +# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_DIRENTAPI) +# define XOS_USE_MTSAFE_DIRENTAPI 1 +# endif +#endif + +#if !defined(X_INCLUDE_DIRENT_H) || defined(_XOS_INCLUDED_DIRENT_H) +/* Do nothing. */ + +#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API) +/* Use regular, unsafe API. */ +typedef int _Xreaddirparams; /* dummy */ +# define _XReaddir(d,p) readdir(d) + +#elif !defined(XOS_USE_MTSAFE_DIRENTAPI) || defined(XNO_MTSAFE_DIRENTAPI) +/* Systems with thread support but no _r API. */ +typedef struct { + struct dirent *result; + struct dirent dir_entry; +# ifdef _POSIX_PATH_MAX + char buf[_POSIX_PATH_MAX]; +# elif defined(NAME_MAX) + char buf[NAME_MAX]; +# else + char buf[255]; +# endif +} _Xreaddirparams; + +# define _XReaddir(d,p) \ + ( (_Xos_processLock), \ + (((p).result = readdir((d))) ? \ + (memcpy(&((p).dir_entry), (p).result, (p).result->d_reclen), \ + ((p).result = &(p).dir_entry), 0) : \ + 0), \ + (_Xos_processUnlock), \ + (p).result ) + +#else +typedef struct { + struct dirent *result; + struct dirent dir_entry; +# ifdef _POSIX_PATH_MAX + char buf[_POSIX_PATH_MAX]; +# elif defined(NAME_MAX) + char buf[NAME_MAX]; +# else + char buf[255]; +# endif +} _Xreaddirparams; + +# if defined(_POSIX_THREAD_SAFE_FUNCTIONS) || defined(__APPLE__) +/* POSIX final API, returns (int)0 on success. */ +# define _XReaddir(d,p) \ + (readdir_r((d), &((p).dir_entry), &((p).result)) ? NULL : (p).result) +# elif defined(_POSIX_REENTRANT_FUNCTIONS) +/* POSIX draft API, returns (int)0 on success. */ +# define _XReaddir(d,p) \ + (readdir_r((d),&((p).dir_entry)) ? NULL : &((p).dir_entry)) +# elif defined(SVR4) +/* Pre-POSIX API, returns non-NULL on success. */ +# define _XReaddir(d,p) (readdir_r((d), &(p).dir_entry)) +# else +/* We have no idea what is going on. Fake it all using process locks. */ +# define _XReaddir(d,p) \ + ( (_Xos_processLock), \ + (((p).result = readdir((d))) ? \ + (memcpy(&((p).dir_entry), (p).result, (p).result->d_reclen), \ + ((p).result = &(p).dir_entry), 0) : \ + 0), \ + (_Xos_processUnlock), \ + (p).result ) +# endif +#endif /* X_INCLUDE_DIRENT_H */ + +#if defined(X_INCLUDE_DIRENT_H) && !defined(_XOS_INCLUDED_DIRENT_H) +# define _XOS_INCLUDED_DIRENT_H +#endif + + +/***** <unistd.h> wrappers *****/ + +/* + * Effective prototypes for <unistd.h> wrappers: + * + * #define X_INCLUDE_UNISTD_H + * #define XOS_USE_..._LOCKING + * #include <X11/Xos_r.h> + * + * typedef ... _Xgetloginparams; + * typedef ... _Xttynameparams; + * + * char *_XGetlogin(_Xgetloginparams); + * char *_XTtyname(int, _Xttynameparams); + */ + +#if defined(X_INCLUDE_UNISTD_H) && !defined(_XOS_INCLUDED_UNISTD_H) +/* <unistd.h> already included by <X11/Xos.h> */ +# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_UNISTDAPI) +# define XOS_USE_MTSAFE_UNISTDAPI 1 +# endif +#endif + +#if !defined(X_INCLUDE_UNISTD_H) || defined(_XOS_INCLUDED_UNISTD_H) +/* Do nothing. */ + +#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API) +/* Use regular, unsafe API. */ +typedef int _Xgetloginparams; /* dummy */ +typedef int _Xttynameparams; /* dummy */ +# define _XGetlogin(p) getlogin() +# define _XTtyname(f) ttyname((f)) + +#elif !defined(XOS_USE_MTSAFE_UNISTDAPI) || defined(XNO_MTSAFE_UNISTDAPI) +/* Systems with thread support but no _r API. */ +typedef struct { + char *result; +# if defined(MAXLOGNAME) + char buf[MAXLOGNAME]; +# elif defined(LOGIN_NAME_MAX) + char buf[LOGIN_NAME_MAX]; +# else + char buf[64]; +# endif +} _Xgetloginparams; +typedef struct { + char *result; +# ifdef TTY_NAME_MAX + char buf[TTY_NAME_MAX]; +# elif defined(_POSIX_TTY_NAME_MAX) + char buf[_POSIX_TTY_NAME_MAX]; +# elif defined(_POSIX_PATH_MAX) + char buf[_POSIX_PATH_MAX]; +# else + char buf[256]; +# endif +} _Xttynameparams; + +# define _XGetlogin(p) \ + ( (_Xos_processLock), \ + (((p).result = getlogin()) ? \ + (strncpy((p).buf, (p).result, sizeof((p).buf)), \ + ((p).buf[sizeof((p).buf)-1] = '\0'), \ + ((p).result = (p).buf), 0) : 0), \ + (_Xos_processUnlock), \ + (p).result ) +#define _XTtyname(f,p) \ + ( (_Xos_processLock), \ + (((p).result = ttyname(f)) ? \ + (strncpy((p).buf, (p).result, sizeof((p).buf)), \ + ((p).buf[sizeof((p).buf)-1] = '\0'), \ + ((p).result = (p).buf), 0) : 0), \ + (_Xos_processUnlock), \ + (p).result ) + +#elif defined(_POSIX_THREAD_SAFE_FUNCTIONS) || defined(_POSIX_REENTRANT_FUNCTIONS) +/* POSIX API. + * + * extern int getlogin_r(char *, size_t); + * extern int ttyname_r(int, char *, size_t); + */ +typedef struct { +# if defined(MAXLOGNAME) + char buf[MAXLOGNAME]; +# elif defined(LOGIN_NAME_MAX) + char buf[LOGIN_NAME_MAX]; +# else + char buf[64]; +# endif +} _Xgetloginparams; +typedef struct { +# ifdef TTY_NAME_MAX + char buf[TTY_NAME_MAX]; +# elif defined(_POSIX_TTY_NAME_MAX) + char buf[_POSIX_TTY_NAME_MAX]; +# elif defined(_POSIX_PATH_MAX) + char buf[_POSIX_PATH_MAX]; +# else + char buf[256]; +# endif +} _Xttynameparams; + +# define _XGetlogin(p) (getlogin_r((p).buf, sizeof((p).buf)) ? NULL : (p).buf) +# define _XTtyname(f,p) \ + (ttyname_r((f), (p).buf, sizeof((p).buf)) ? NULL : (p).buf) + +#else +/* Pre-POSIX API. + * + * extern char *getlogin_r(char *, size_t); + * extern char *ttyname_r(int, char *, size_t); + */ +typedef struct { +# if defined(MAXLOGNAME) + char buf[MAXLOGNAME]; +# elif defined(LOGIN_NAME_MAX) + char buf[LOGIN_NAME_MAX]; +# else + char buf[64]; +# endif +} _Xgetloginparams; +typedef struct { +# ifdef TTY_NAME_MAX + char buf[TTY_NAME_MAX]; +# elif defined(_POSIX_TTY_NAME_MAX) + char buf[_POSIX_TTY_NAME_MAX]; +# elif defined(_POSIX_PATH_MAX) + char buf[_POSIX_PATH_MAX]; +# else + char buf[256]; +# endif +} _Xttynameparams; + +# define _XGetlogin(p) getlogin_r((p).buf, sizeof((p).buf)) +# define _XTtyname(f,p) ttyname_r((f), (p).buf, sizeof((p).buf)) +#endif /* X_INCLUDE_UNISTD_H */ + +#if defined(X_INCLUDE_UNISTD_H) && !defined(_XOS_INCLUDED_UNISTD_H) +# define _XOS_INCLUDED_UNISTD_H +#endif + + +/***** <string.h> wrappers *****/ + +/* + * Effective prototypes for <string.h> wrappers: + * + * #define X_INCLUDE_STRING_H + * #define XOS_USE_..._LOCKING + * #include <X11/Xos_r.h> + * + * typedef ... _Xstrtokparams; + * + * char *_XStrtok(char *, const char*, _Xstrtokparams); + */ + +#if defined(X_INCLUDE_STRING_H) && !defined(_XOS_INCLUDED_STRING_H) +/* <string.h> has already been included by <X11/Xos.h> */ +# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_STRINGAPI) +# define XOS_USE_MTSAFE_STRINGAPI 1 +# endif +#endif + +#if !defined(X_INCLUDE_STRING_H) || defined(_XOS_INCLUDED_STRING_H) +/* Do nothing. */ + +#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API) +/* Use regular, unsafe API. */ +typedef int _Xstrtokparams; /* dummy */ +# define _XStrtok(s1,s2,p) \ + ( p = 0, (void)p, strtok((s1),(s2)) ) + +#elif !defined(XOS_USE_MTSAFE_STRINGAPI) || defined(XNO_MTSAFE_STRINGAPI) +/* Systems with thread support but no _r API. */ +typedef char *_Xstrtokparams; +# define _XStrtok(s1,s2,p) \ + ( (_Xos_processLock), \ + ((p) = strtok((s1),(s2))), \ + (_Xos_processUnlock), \ + (p) ) + +#else +/* POSIX or pre-POSIX API. */ +typedef char * _Xstrtokparams; +# define _XStrtok(s1,s2,p) strtok_r((s1),(s2),&(p)) +#endif /* X_INCLUDE_STRING_H */ + + +/***** <time.h> wrappers *****/ + +/* + * Effective prototypes for <time.h> wrappers: + * + * #define X_INCLUDE_TIME_H + * #define XOS_USE_..._LOCKING + * #include <X11/Xos_r.h> + * + * typedef ... _Xatimeparams; + * typedef ... _Xctimeparams; + * typedef ... _Xgtimeparams; + * typedef ... _Xltimeparams; + * + * char *_XAsctime(const struct tm *, _Xatimeparams); + * char *_XCtime(const time_t *, _Xctimeparams); + * struct tm *_XGmtime(const time_t *, _Xgtimeparams); + * struct tm *_XLocaltime(const time_t *, _Xltimeparams); + */ + +#if defined(X_INCLUDE_TIME_H) && !defined(_XOS_INCLUDED_TIME_H) +# include <time.h> +# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_TIMEAPI) +# define XOS_USE_MTSAFE_TIMEAPI 1 +# endif +#endif + +#if !defined(X_INCLUDE_TIME_H) || defined(_XOS_INCLUDED_TIME_H) +/* Do nothing. */ + +#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API) +/* Use regular, unsafe API. */ +typedef int _Xatimeparams; /* dummy */ +# define _XAsctime(t,p) asctime((t)) +typedef int _Xctimeparams; /* dummy */ +# define _XCtime(t,p) ctime((t)) +typedef int _Xgtimeparams; /* dummy */ +# define _XGmtime(t,p) gmtime((t)) +typedef int _Xltimeparams; /* dummy */ +# define _XLocaltime(t,p) localtime((t)) + +#elif !defined(XOS_USE_MTSAFE_TIMEAPI) || defined(XNO_MTSAFE_TIMEAPI) +/* Systems with thread support but no _r API. */ +typedef struct { +# ifdef TIMELEN + char buf[TIMELEN]; +# else + char buf[26]; +# endif + char *result; +} _Xctimeparams, _Xatimeparams; +typedef struct { + struct tm buf; + struct tm *result; +} _Xgtimeparams, _Xltimeparams; +# define _XAsctime(t,p) \ + ( (_Xos_processLock), \ + (((p).result = asctime((t))) ? \ + (strncpy((p).buf, (p).result, sizeof((p).buf)), (p).result = &(p).buf) : \ + 0), \ + (_Xos_processUnlock), \ + (p).result ) +# define _XCtime(t,p) \ + ( (_Xos_processLock), \ + (((p).result = ctime((t))) ? \ + (strncpy((p).buf, (p).result, sizeof((p).buf)), (p).result = &(p).buf) : \ + 0), \ + (_Xos_processUnlock), \ + (p).result ) +# define _XGmtime(t,p) \ + ( (_Xos_processLock), \ + (((p).result = gmtime(t)) ? \ + (memcpy(&(p).buf, (p).result, sizeof((p).buf)), (p).result = &(p).buf) : \ + 0), \ + (_Xos_processUnlock), \ + (p).result ) +# define _XLocaltime(t,p) \ + ( (_Xos_processLock), \ + (((p).result = localtime(t)) ? \ + (memcpy(&(p).buf, (p).result, sizeof((p).buf)), (p).result = &(p).buf) : \ + 0), \ + (_Xos_processUnlock), \ + (p).result ) + +#elif !defined(_POSIX_THREAD_SAFE_FUNCTIONS) && defined(hpV4) +/* Returns (int)0 on success. + * + * extern int asctime_r(const struct tm *timeptr, char *buffer, int buflen); + * extern int ctime_r(const time_t *timer, char *buffer, int buflen); + * extern int gmtime_r(const time_t *timer, struct tm *result); + * extern int localtime_r(const time_t *timer, struct tm *result); + */ +# ifdef TIMELEN +typedef char _Xatimeparams[TIMELEN]; +typedef char _Xctimeparams[TIMELEN]; +# else +typedef char _Xatimeparams[26]; +typedef char _Xctimeparams[26]; +# endif +typedef struct tm _Xgtimeparams; +typedef struct tm _Xltimeparams; +# define _XAsctime(t,p) (asctime_r((t),(p),sizeof((p))) ? NULL : (p)) +# define _XCtime(t,p) (ctime_r((t),(p),sizeof((p))) ? NULL : (p)) +# define _XGmtime(t,p) (gmtime_r((t),&(p)) ? NULL : &(p)) +# define _XLocaltime(t,p) (localtime_r((t),&(p)) ? NULL : &(p)) + +#elif !defined(_POSIX_THREAD_SAFE_FUNCTIONS) && defined(__sun) +/* Returns NULL on failure. Solaris 2.5 + * + * extern char *asctime_r(const struct tm *tm,char *buf, int buflen); + * extern char *ctime_r(const time_t *clock, char *buf, int buflen); + * extern struct tm *gmtime_r(const time_t *clock, struct tm *res); + * extern struct tm *localtime_r(const time_t *clock, struct tm *res); + */ +# ifdef TIMELEN +typedef char _Xatimeparams[TIMELEN]; +typedef char _Xctimeparams[TIMELEN]; +# else +typedef char _Xatimeparams[26]; +typedef char _Xctimeparams[26]; +# endif +typedef struct tm _Xgtimeparams; +typedef struct tm _Xltimeparams; +# define _XAsctime(t,p) asctime_r((t),(p),sizeof((p))) +# define _XCtime(t,p) ctime_r((t),(p),sizeof((p))) +# define _XGmtime(t,p) gmtime_r((t),&(p)) +# define _XLocaltime(t,p) localtime_r((t),&(p)) + +#else /* defined(_POSIX_THREAD_SAFE_FUNCTIONS) */ +/* POSIX final API. + * extern char *asctime_r(const struct tm *timeptr, char *buffer); + * extern char *ctime_r(const time_t *timer, char *buffer); + * extern struct tm *gmtime_r(const time_t *timer, struct tm *result); + * extern struct tm *localtime_r(const time_t *timer, struct tm *result); + */ +# ifdef TIMELEN +typedef char _Xatimeparams[TIMELEN]; +typedef char _Xctimeparams[TIMELEN]; +# else +typedef char _Xatimeparams[26]; +typedef char _Xctimeparams[26]; +# endif +typedef struct tm _Xgtimeparams; +typedef struct tm _Xltimeparams; +# define _XAsctime(t,p) asctime_r((t),(p)) +# define _XCtime(t,p) ctime_r((t),(p)) +# define _XGmtime(t,p) gmtime_r((t),&(p)) +# define _XLocaltime(t,p) localtime_r((t),&(p)) +#endif /* X_INCLUDE_TIME_H */ + +#if defined(X_INCLUDE_TIME_H) && !defined(_XOS_INCLUDED_TIME_H) +# define _XOS_INCLUDED_TIME_H +#endif + + +/***** <grp.h> wrappers *****/ + +/* + * Effective prototypes for <grp.h> wrappers: + * + * NOTE: On systems lacking appropriate _r functions Getgrgid() and + * Getgrnam() do NOT copy the list of group members! + * + * Remember that fgetgrent(), setgrent(), getgrent(), and endgrent() + * are not included in POSIX. + * + * #define X_INCLUDE_GRP_H + * #define XOS_USE_..._LOCKING + * #include <X11/Xos_r.h> + * + * typedef ... _Xgetgrparams; + * + * struct group *_XGetgrgid(gid_t, _Xgetgrparams); + * struct group *_XGetgrnam(const char *, _Xgetgrparams); + */ + +#if defined(X_INCLUDE_GRP_H) && !defined(_XOS_INCLUDED_GRP_H) +# include <grp.h> +# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_GRPAPI) +# define XOS_USE_MTSAFE_GRPAPI 1 +# endif +#endif + +#if !defined(X_INCLUDE_GRP_H) || defined(_XOS_INCLUDED_GRP_H) +/* Do nothing. */ + +#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API) +/* Use regular, unsafe API. */ +typedef int _Xgetgrparams; /* dummy */ +#define _XGetgrgid(g,p) getgrgid((g)) +#define _XGetgrnam(n,p) getgrnam((n)) + +#elif !defined(XOS_USE_MTSAFE_GRPAPI) || defined(XNO_MTSAFE_GRPAPI) +/* Systems with thread support but no _r API. UnixWare 2.0. */ +typedef struct { + struct group grp; + char buf[X_LINE_MAX]; /* Should be sysconf(_SC_GETGR_R_SIZE_MAX)? */ + struct group *pgrp; + size_t len; +} _Xgetgrparams; +#ifdef SVR4 +/* Copy the gr_passwd field too. */ +# define _Xgrp_copyGroup(p) \ + ( memcpy(&(p).grp, (p).pgrp, sizeof(struct group)), \ + ((p).grp.gr_name = (p).buf), \ + ((p).len = strlen((p).pgrp->gr_name)), \ + strcpy((p).grp.gr_name, (p).pgrp->gr_name), \ + ((p).grp.gr_passwd = (p).grp.gr_name + (p).len + 1), \ + ((p).pgrp = &(p).grp), \ + 0 ) +#else +# define _Xgrp_copyGroup(p) \ + ( memcpy(&(p).grp, (p).pgrp, sizeof(struct group)), \ + ((p).grp.gr_name = (p).buf), \ + strcpy((p).grp.gr_name, (p).pgrp->gr_name), \ + ((p).pgrp = &(p).grp), \ + 0 ) +#endif +#define _XGetgrgid(g,p) \ + ( (_Xos_processLock), \ + (((p).pgrp = getgrgid((g))) ? _Xgrp_copyGroup(p) : 0), \ + (_Xos_processUnlock), \ + (p).pgrp ) +#define _XGetgrnam(n,p) \ + ( (_Xos_processLock), \ + (((p).pgrp = getgrnam((n))) ? _Xgrp_copyGroup(p) : 0), \ + (_Xos_processUnlock), \ + (p).pgrp ) + +#elif !defined(_POSIX_THREAD_SAFE_FUNCTIONS) && defined(__sun) +/* Non-POSIX API. Solaris. + * + * extern struct group *getgrgid_r(gid_t, struct group *, char *, int); + * extern struct group *getgrnam_r(const char *, struct group *, char *, int); + */ +typedef struct { + struct group grp; + char buf[X_LINE_MAX]; /* Should be sysconf(_SC_GETGR_R_SIZE_MAX)? */ +} _Xgetgrparams; +#define _XGetgrgid(g,p) getgrgid_r((g), &(p).grp, (p).buf, sizeof((p).buf)) +#define _XGetgrnam(n,p) getgrnam_r((n), &(p).grp, (p).buf, sizeof((p).buf)) + +#elif !defined(_POSIX_THREAD_SAFE_FUNCTIONS) +/* Non-POSIX API. + * extern int getgrgid_r(gid_t, struct group *, char *, int); + * extern int getgrnam_r(const char *, struct group *, char *, int); + */ +typedef struct { + struct group grp; + char buf[X_LINE_MAX]; /* Should be sysconf(_SC_GETGR_R_SIZE_MAX)? */ +} _Xgetgrparams; +#define _XGetgrgid(g,p) \ + ((getgrgid_r((g), &(p).grp, (p).buf, sizeof((p).buf)) ? NULL : &(p).grp)) +#define _XGetgrnam(n,p) \ + ((getgrnam_r((n), &(p).grp, (p).buf, sizeof((p).buf)) ? NULL : &(p).grp)) + +#else +/* POSIX final API. + * + * int getgrgid_r(gid_t, struct group *, char *, size_t, struct group **); + * int getgrnam_r(const char *, struct group *, char *, size_t, struct group **); + */ +typedef struct { + struct group grp; + char buf[X_LINE_MAX]; /* Should be sysconf(_SC_GETGR_R_SIZE_MAX)? */ + struct group *result; +} _Xgetgrparams; + +#define _XGetgrgid(g,p) \ + ((getgrgid_r((g), &(p).grp, (p).buf, sizeof((p).buf), &(p).result) ? \ + NULL : (p).result)) +#define _XGetgrnam(n,p) \ + ((getgrnam_r((n), &(p).grp, (p).buf, sizeof((p).buf), &(p).result) ? \ + NULL : (p).result)) +#endif + +#if defined(X_INCLUDE_GRP_H) && !defined(_XOS_INCLUDED_GRP_H) +# define _XOS_INCLUDED_GRP_H +#endif + + +#ifdef __cplusplus +} /* Close scope of 'extern "C"' declaration which encloses file. */ +#endif |