/*

  * tclUnixCompat.c

  *

  * Written by: Zoran Vasiljevic (vasiljevic@users.sourceforge.net).

  *

  * See the file "license.terms" for information on usage and redistribution

  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

  *

  * RCS: @(#) $Id: tclUnixCompat.c,v 1.1.2.10 2006/09/12 22:05:03 andreas_kupries Exp $

  *

  */

 #include "tclInt.h"

 #include "tclPort.h"

 #include <pwd.h>

 #include <grp.h>

 #include <errno.h>

 #include <string.h>

 /*

  * Used to pad structures at size'd boundaries

  *

  * This macro assumes that the pointer 'buffer' was created from an

  * aligned pointer by adding the 'length'. If this 'length' was not a

  * multiple of the 'size' the result is unaligned and PadBuffer

  * corrects both the pointer, _and_ the 'length'. The latter means

  * that future increments of 'buffer' by 'length' stay aligned.

  */

 #define PadBuffer(buffer, length, size)             \

     if (((length) % (size))) {                      \

 	(buffer) += ((size) - ((length) % (size))); \

 	(length) += ((size) - ((length) % (size))); \

     }

 /*

  * Per-thread private storage used to store values

  * returned from MT-unsafe library calls.

  */

 #ifdef TCL_THREADS

 typedef struct ThreadSpecificData {

     struct passwd pwd;

     char pbuf[2048];

     struct group grp;

     char gbuf[2048];

 #if !defined(HAVE_MTSAFE_GETHOSTBYNAME) || !defined(HAVE_MTSAFE_GETHOSTBYADDR)

     struct hostent hent;

     char hbuf[2048];

 #endif

 }  ThreadSpecificData;

 static Tcl_ThreadDataKey dataKey;

 #if ((!defined(HAVE_GETHOSTBYNAME_R) || !defined(HAVE_GETHOSTBYADDR_R)) && \

      (!defined(HAVE_MTSAFE_GETHOSTBYNAME) || !defined(HAVE_MTSAFE_GETHOSTBYADDR))) || \

       !defined(HAVE_GETPWNAM_R) || !defined(HAVE_GETPWUID_R) || \

       !defined(HAVE_GETGRNAM_R) || !defined(HAVE_GETGRGID_R)

 /*

  * Mutex to lock access to MT-unsafe calls. This is just to protect

  * our own usage. It does not protect us from others calling the

  * same functions without (or using some different) lock.

  */

 static Tcl_Mutex compatLock;

 /*

  *---------------------------------------------------------------------------

  *

  * CopyArray --

  *

  *      Copies array of NULL-terminated or fixed-length strings

  *      to the private buffer, honouring the size of the buffer.

  *

  * Results:

  *      Number of bytes copied on success or -1 on error (errno = ERANGE)

  *

  * Side effects:

  *      None.

  *

  *---------------------------------------------------------------------------

  */

 static int

 CopyArray(char **src, int elsize, char *buf, int buflen)

 {

     int i, j, len = 0;

     char *p, **new;

     if (src == NULL) {

 	return 0;

     }

     for (i = 0; src[i] != NULL; i++) {

 	/* Empty loop to count howmany */

     }

     if ((sizeof(char *)*(i + 1)) >  buflen) {

 	return -1;

     }

     len = (sizeof(char *)*(i + 1)); /* Leave place for the array */

     new = (char **)buf;

     p = buf + (sizeof(char *)*(i + 1));

     for (j = 0; j < i; j++) {

 	if (elsize < 0) {

 	    len += strlen(src[j]) + 1;

 	} else {

 	    len += elsize;

 	}

 	if (len > buflen) {

 	    return -1;

 	}

 	if (elsize < 0) {

 	    strcpy(p, src[j]);

 	} else {

 	    memcpy(p, src[j], elsize);

 	}

 	new[j] = p;

 	p = buf + len;

     }

     new[j] = NULL;

     return len;

 }

 /*

  *---------------------------------------------------------------------------

  *

  * CopyString --

  *

  *      Copies a NULL-terminated string to the private buffer,

  *      honouring the size of the buffer

  *

  * Results:

  *      0 success or -1 on error (errno = ERANGE)

  *

  * Side effects:

  *      None

  *

  *---------------------------------------------------------------------------

  */

 static int

 CopyString(char *src, char *buf, int buflen)

 {

     int len = 0;

     if (src != NULL) {

 	len += strlen(src) + 1;

 	if (len > buflen) {

 	    return -1;

 	}

 	strcpy(buf, src);

     }

     return len;

 }

 #endif /* ((!defined(HAVE_GETHOSTBYNAME_R) || !defined(HAVE_GETHOSTBYADDR_R)) && \

 	   (!defined(HAVE_MTSAFE_GETHOSTBYNAME) || !defined(HAVE_MTSAFE_GETHOSTBYADDR))) || \

 	    !defined(HAVE_GETPWNAM_R) || !defined(HAVE_GETPWUID_R) || \

 	    !defined(HAVE_GETGRNAM_R) || !defined(HAVE_GETGRGID_R) */

 #if (!defined(HAVE_GETHOSTBYNAME_R) || !defined(HAVE_GETHOSTBYADDR_R)) && \

     (!defined(HAVE_MTSAFE_GETHOSTBYNAME) || !defined(HAVE_MTSAFE_GETHOSTBYADDR))

 /*

  *---------------------------------------------------------------------------

  *

  * CopyHostnent --

  *

  *      Copies string fields of the hostnent structure to the

  *      private buffer, honouring the size of the buffer.

  *

  * Results:

  *      Number of bytes copied on success or -1 on error (errno = ERANGE)

  *

  * Side effects:

  *      None

  *

  *---------------------------------------------------------------------------

  */

 static int

 CopyHostent(struct hostent *tgtPtr, char *buf, int buflen)

 {

     char *p = buf;

     int copied, len = 0;

     copied = CopyString(tgtPtr->h_name, p, buflen - len);

     if (copied == -1) {

     range:

 	errno = ERANGE;

 	return -1;

     }

     tgtPtr->h_name = (copied > 0) ? p : NULL;

     len += copied;

     p = buf + len;

     PadBuffer(p, len, sizeof(char *));

     copied = CopyArray(tgtPtr->h_aliases, -1, p, buflen - len);

     if (copied == -1) {

 	goto range;

     }

     tgtPtr->h_aliases = (copied > 0) ? (char **)p : NULL;

     len += copied;

     p += len;

     PadBuffer(p, len, sizeof(char *));

     copied = CopyArray(tgtPtr->h_addr_list, tgtPtr->h_length, p, buflen - len);

     if (copied == -1) {

 	goto range;

     }

     tgtPtr->h_addr_list = (copied > 0) ? (char **)p : NULL;

     return 0;

 }

 #endif /* (!defined(HAVE_GETHOSTBYNAME_R) || !defined(HAVE_GETHOSTBYADDR_R)) && \

 	  (!defined(HAVE_MTSAFE_GETHOSTBYNAME) || !defined(HAVE_MTSAFE_GETHOSTBYADDR)) */

 #if !defined(HAVE_GETPWNAM_R) || !defined(HAVE_GETPWUID_R)

 /*

  *---------------------------------------------------------------------------

  *

  * CopyPwd --

  *

  *      Copies string fields of the passwd structure to the

  *      private buffer, honouring the size of the buffer.

  *

  * Results:

  *      0 on success or -1 on error (errno = ERANGE)

  *

  * Side effects:

  *      We are not copying the gecos field as it may not be supported

  *      on all platforms.

  *

  *---------------------------------------------------------------------------

  */

 static int

 CopyPwd(struct passwd *tgtPtr, char *buf, int buflen)

 {

     char *p = buf;

     int copied, len = 0;

     copied = CopyString(tgtPtr->pw_name, p, buflen - len);

     if (copied == -1) {

     range:

 	errno = ERANGE;

 	return -1;

     }

     tgtPtr->pw_name = (copied > 0) ? p : NULL;

     len += copied;

     p = buf + len;

     copied = CopyString(tgtPtr->pw_passwd, p, buflen - len);

     if (copied == -1) {

 	goto range;

     }

     tgtPtr->pw_passwd = (copied > 0) ? p : NULL;

     len += copied;

     p = buf + len;

     copied = CopyString(tgtPtr->pw_dir, p, buflen - len);

     if (copied == -1) {

 	goto range;

     }

     tgtPtr->pw_dir = (copied > 0) ? p : NULL;

     len += copied;

     p = buf + len;

     copied = CopyString(tgtPtr->pw_shell, p, buflen - len);

     if (copied == -1) {

 	goto range;

     }

     tgtPtr->pw_shell = (copied > 0) ? p : NULL;

     return 0;

 }

 #endif /* !defined(HAVE_GETPWNAM_R) || !defined(HAVE_GETPWUID_R) */

 #if !defined(HAVE_GETGRNAM_R) || !defined(HAVE_GETGRGID_R)

 /*

  *---------------------------------------------------------------------------

  *

  * CopyGrp --

  *

  *      Copies string fields of the group structure to the

  *      private buffer, honouring the size of the buffer.

  *

  * Results:

  *      0 on success or -1 on error (errno = ERANGE)

  *

  * Side effects:

  *      None.

  *

  *---------------------------------------------------------------------------

  */

 static int

 CopyGrp(struct group *tgtPtr, char *buf, int buflen)

 {

     register char *p = buf;

     register int copied, len = 0;

     /* Copy username */

     copied = CopyString(tgtPtr->gr_name, p, buflen - len);

     if (copied == -1) {

     range:

 	errno = ERANGE;

 	return -1;

     }

     tgtPtr->gr_name = (copied > 0) ? p : NULL;

     len += copied;

     p = buf + len;

     /* Copy password */

     copied = CopyString(tgtPtr->gr_passwd, p, buflen - len);

     if (copied == -1) {

 	goto range;

     }

     tgtPtr->gr_passwd = (copied > 0) ? p : NULL;

     len += copied;

     p = buf + len;

     /* Copy group members */

     PadBuffer(p, len, sizeof(char *));

     copied = CopyArray((char **)tgtPtr->gr_mem, -1, p, buflen - len);

     if (copied == -1) {

 	goto range;

     }

     tgtPtr->gr_mem = (copied > 0) ? (char **)p : NULL;

     return 0;

 }

 #endif /* !defined(HAVE_GETGRNAM_R) || !defined(HAVE_GETGRGID_R) */

 #endif /* TCL_THREADS */

 /*

  *---------------------------------------------------------------------------

  *

  * TclpGetPwNam --

  *

  *      Thread-safe wrappers for getpwnam().

  *      See "man getpwnam" for more details.

  *

  * Results:

  *      Pointer to struct passwd on success or NULL on error.

  *

  * Side effects:

  *      None.

  *

  *---------------------------------------------------------------------------

  */

 struct passwd *

 TclpGetPwNam(const char *name)

 {

 #if !defined(TCL_THREADS)

     return getpwnam(name);

 #else

     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

 #if defined(HAVE_GETPWNAM_R_5)

     struct passwd *pwPtr = NULL;

     return (getpwnam_r(name, &tsdPtr->pwd, tsdPtr->pbuf, sizeof(tsdPtr->pbuf),

 		       &pwPtr) == 0 && pwPtr != NULL) ? &tsdPtr->pwd : NULL;

 #elif defined(HAVE_GETPWNAM_R_4)

     return getpwnam_r(name, &tsdPtr->pwd, tsdPtr->pbuf, sizeof(tsdPtr->pbuf));

 #else

     struct passwd *pwPtr;

     Tcl_MutexLock(&compatLock);

     pwPtr = getpwnam(name);

     if (pwPtr != NULL) {

 	tsdPtr->pwd = *pwPtr;

 	pwPtr = &tsdPtr->pwd;

 	if (CopyPwd(&tsdPtr->pwd, tsdPtr->pbuf, sizeof(tsdPtr->pbuf)) == -1) {

 	    pwPtr = NULL;

 	}

     }

     Tcl_MutexUnlock(&compatLock);

     return pwPtr;

 #endif

     return NULL; /* Not reached */

 #endif /* TCL_THREADS */

 }

 /*

  *---------------------------------------------------------------------------

  *

  * TclpGetPwUid --

  *

  *      Thread-safe wrappers for getpwuid().

  *      See "man getpwuid" for more details.

  *

  * Results:

  *      Pointer to struct passwd on success or NULL on error.

  *

  * Side effects:

  *      None.

  *

  *---------------------------------------------------------------------------

  */

 struct passwd *

 TclpGetPwUid(uid_t uid)

 {

 #if !defined(TCL_THREADS)

     return getpwuid(uid);

 #else

     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

 #if defined(HAVE_GETPWUID_R_5)

     struct passwd *pwPtr = NULL;

     return (getpwuid_r(uid, &tsdPtr->pwd, tsdPtr->pbuf, sizeof(tsdPtr->pbuf),

 		       &pwPtr) == 0 && pwPtr != NULL) ? &tsdPtr->pwd : NULL;

 #elif defined(HAVE_GETPWUID_R_4)

     return getpwuid_r(uid, &tsdPtr->pwd, tsdPtr->pbuf, sizeof(tsdPtr->pbuf));

 #else

     struct passwd *pwPtr;

     Tcl_MutexLock(&compatLock);

     pwPtr = getpwuid(uid);

     if (pwPtr != NULL) {

 	tsdPtr->pwd = *pwPtr;

 	pwPtr = &tsdPtr->pwd;

 	if (CopyPwd(&tsdPtr->pwd, tsdPtr->pbuf, sizeof(tsdPtr->pbuf)) == -1) {

 	    pwPtr = NULL;

 	}

     }

     Tcl_MutexUnlock(&compatLock);

     return pwPtr;

 #endif

     return NULL; /* Not reached */

 #endif /* TCL_THREADS */

 }

 /*

  *---------------------------------------------------------------------------

  *

  * TclpGetGrNam --

  *

  *      Thread-safe wrappers for getgrnam().

  *      See "man getgrnam" for more details.

  *

  * Results:

  *      Pointer to struct group on success or NULL on error.

  *

  * Side effects:

  *      None.

  *

  *---------------------------------------------------------------------------

  */

 struct group *

 TclpGetGrNam(const char *name)

 {

 #if !defined(TCL_THREADS)

     return getgrnam(name);

 #else

     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

 #if defined(HAVE_GETGRNAM_R_5)

     struct group *grPtr = NULL;

     return (getgrnam_r(name, &tsdPtr->grp, tsdPtr->gbuf, sizeof(tsdPtr->gbuf),

 		       &grPtr) == 0 && grPtr != NULL) ? &tsdPtr->grp : NULL;

 #elif defined(HAVE_GETGRNAM_R_4)

     return getgrnam_r(name, &tsdPtr->grp, tsdPtr->gbuf, sizeof(tsdPtr->gbuf));

 #else

     struct group *grPtr;

     Tcl_MutexLock(&compatLock);

     grPtr = getgrnam(name);

     if (grPtr != NULL) {

 	tsdPtr->grp = *grPtr;

 	grPtr = &tsdPtr->grp;

 	if (CopyGrp(&tsdPtr->grp, tsdPtr->gbuf, sizeof(tsdPtr->gbuf)) == -1) {

 	    grPtr = NULL;

 	}

     }

     Tcl_MutexUnlock(&compatLock);

     return grPtr;

 #endif

     return NULL; /* Not reached */

 #endif /* TCL_THREADS */

 }

 /*

  *---------------------------------------------------------------------------

  *

  * TclpGetGrGid --

  *

  *      Thread-safe wrappers for getgrgid().

  *      See "man getgrgid" for more details.

  *

  * Results:

  *      Pointer to struct group on success or NULL on error.

  *

  * Side effects:

  *      None.

  *

  *---------------------------------------------------------------------------

  */

 struct group *

 TclpGetGrGid(gid_t gid)

 {

 #if !defined(TCL_THREADS)

     return getgrgid(gid);

 #else

     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

 #if defined(HAVE_GETGRGID_R_5)

     struct group *grPtr = NULL;

     return (getgrgid_r(gid, &tsdPtr->grp, tsdPtr->gbuf, sizeof(tsdPtr->gbuf),

 		       &grPtr) == 0 && grPtr != NULL) ? &tsdPtr->grp : NULL;

 #elif defined(HAVE_GETGRGID_R_4)

     return getgrgid_r(gid, &tsdPtr->grp, tsdPtr->gbuf, sizeof(tsdPtr->gbuf));

 #else

     struct group *grPtr;

     Tcl_MutexLock(&compatLock);

     grPtr = getgrgid(gid);

     if (grPtr != NULL) {

 	tsdPtr->grp = *grPtr;

 	grPtr = &tsdPtr->grp;

 	if (CopyGrp(&tsdPtr->grp, tsdPtr->gbuf, sizeof(tsdPtr->gbuf)) == -1) {

 	    grPtr = NULL;

 	}

     }

     Tcl_MutexUnlock(&compatLock);

     return grPtr;

 #endif

     return NULL; /* Not reached */

 #endif /* TCL_THREADS */

 }

 /*

  *---------------------------------------------------------------------------

  *

  * TclpGetHostByName --

  *

  *      Thread-safe wrappers for gethostbyname().

  *      See "man gethostbyname" for more details.

  *

  * Results:

  *      Pointer to struct hostent on success or NULL on error.

  *

  * Side effects:

  *      None.

  *

  *---------------------------------------------------------------------------

  */

 struct hostent *

 TclpGetHostByName(const char *name)

 {

 #if !defined(TCL_THREADS) || defined(HAVE_MTSAFE_GETHOSTBYNAME)

     return gethostbyname(name);

 #else

     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

 #if defined(HAVE_GETHOSTBYNAME_R_5)

     int h_errno;

     return gethostbyname_r(name, &tsdPtr->hent, tsdPtr->hbuf,

 			   sizeof(tsdPtr->hbuf), &h_errno);

 #elif defined(HAVE_GETHOSTBYNAME_R_6)

     struct hostent *hePtr;

     int h_errno;

     return (gethostbyname_r(name, &tsdPtr->hent, tsdPtr->hbuf,

 			    sizeof(tsdPtr->hbuf), &hePtr, &h_errno) == 0) ?

 	&tsdPtr->hent : NULL;

 #elif defined(HAVE_GETHOSTBYNAME_R_3)

     struct hostent_data data;

     return (gethostbyname_r(name, &tsdPtr->hent, &data) == 0) ?

 	&tsdPtr->hent : NULL;

 #else

     struct hostent *hePtr;

     Tcl_MutexLock(&compatLock);

     hePtr = gethostbyname(name);

     if (hePtr != NULL) {

 	tsdPtr->hent = *hePtr;

 	hePtr = &tsdPtr->hent;

 	if (CopyHostent(&tsdPtr->hent, tsdPtr->hbuf,

 			sizeof(tsdPtr->hbuf)) == -1) {

 	    hePtr = NULL;

 	}

     }

     Tcl_MutexUnlock(&compatLock);

     return hePtr;

 #endif

     return NULL; /* Not reached */

 #endif /* TCL_THREADS */

 }

 /*

  *---------------------------------------------------------------------------

  *

  * TclpGetHostByAddr --

  *

  *      Thread-safe wrappers for gethostbyaddr().

  *      See "man gethostbyaddr" for more details.

  *

  * Results:

  *      Pointer to struct hostent on success or NULL on error.

  *

  * Side effects:

  *      None.

  *

  *---------------------------------------------------------------------------

  */

 struct hostent *

 TclpGetHostByAddr(const char *addr, int length, int type)

 {

 #if !defined(TCL_THREADS) || defined(HAVE_MTSAFE_GETHOSTBYADDR)

     return gethostbyaddr(addr, length, type);

 #else

     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

 #if defined(HAVE_GETHOSTBYADDR_R_7)

     int h_errno;

     return gethostbyaddr_r(addr, length, type, &tsdPtr->hent, tsdPtr->hbuf,

 			   sizeof(tsdPtr->hbuf), &h_errno);

 #elif defined(HAVE_GETHOSTBYADDR_R_8)

     struct hostent *hePtr;

     int h_errno;

     return (gethostbyaddr_r(addr, length, type, &tsdPtr->hent, tsdPtr->hbuf,

 			    sizeof(tsdPtr->hbuf), &hePtr, &h_errno) == 0) ?

 	&tsdPtr->hent : NULL;

 #else

     struct hostent *hePtr;

     Tcl_MutexLock(&compatLock);

     hePtr = gethostbyaddr(addr, length, type);

     if (hePtr != NULL) {

 	tsdPtr->hent = *hePtr;

 	hePtr = &tsdPtr->hent;

 	if (CopyHostent(&tsdPtr->hent, tsdPtr->hbuf,

 			sizeof(tsdPtr->hbuf)) == -1) {

 	    hePtr = NULL;

 	}

     }

     Tcl_MutexUnlock(&compatLock);

     return hePtr;

 #endif

     return NULL; /* Not reached */

 #endif /* TCL_THREADS */

 }