1025 lines
23 KiB
C
1025 lines
23 KiB
C
/*
|
||
* 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.
|
||
*/
|
||
|
||
#include "tclInt.h"
|
||
#include <pwd.h>
|
||
#include <grp.h>
|
||
#include <errno.h>
|
||
#include <string.h>
|
||
|
||
/*
|
||
* See also: SC_BLOCKING_STYLE in unix/tcl.m4
|
||
*/
|
||
|
||
#ifdef USE_FIONBIO
|
||
# ifdef HAVE_SYS_FILIO_H
|
||
# include <sys/filio.h> /* For FIONBIO. */
|
||
# endif
|
||
# ifdef HAVE_SYS_IOCTL_H
|
||
# include <sys/ioctl.h>
|
||
# endif
|
||
#endif /* USE_FIONBIO */
|
||
|
||
/*
|
||
* 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 {
|
||
struct passwd pwd;
|
||
#if defined(HAVE_GETPWNAM_R_5) || defined(HAVE_GETPWUID_R_5)
|
||
#define NEED_PW_CLEANER 1
|
||
char *pbuf;
|
||
int pbuflen;
|
||
#else
|
||
char pbuf[2048];
|
||
#endif
|
||
|
||
struct group grp;
|
||
#if defined(HAVE_GETGRNAM_R_5) || defined(HAVE_GETGRGID_R_5)
|
||
#define NEED_GR_CLEANER 1
|
||
char *gbuf;
|
||
int gbuflen;
|
||
#else
|
||
char gbuf[2048];
|
||
#endif
|
||
|
||
#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;
|
||
|
||
/*
|
||
* Helper function declarations. Note that these are only used if needed and
|
||
* only defined if used (via the NEED_* macros).
|
||
*/
|
||
|
||
#undef NEED_COPYARRAY
|
||
#undef NEED_COPYGRP
|
||
#undef NEED_COPYHOSTENT
|
||
#undef NEED_COPYPWD
|
||
#undef NEED_COPYSTRING
|
||
|
||
#if !defined(HAVE_GETGRNAM_R_5) && !defined(HAVE_GETGRNAM_R_4)
|
||
#define NEED_COPYGRP 1
|
||
static int CopyGrp(struct group *tgtPtr, char *buf, int buflen);
|
||
#endif
|
||
|
||
#if !defined(HAVE_GETPWNAM_R_5) && !defined(HAVE_GETPWNAM_R_4)
|
||
#define NEED_COPYPWD 1
|
||
static int CopyPwd(struct passwd *tgtPtr, char *buf, int buflen);
|
||
#endif
|
||
|
||
static int CopyArray(char **src, int elsize, char *buf,
|
||
int buflen);
|
||
static int CopyHostent(struct hostent *tgtPtr, char *buf,
|
||
int buflen);
|
||
static int CopyString(const char *src, char *buf, int buflen);
|
||
|
||
#endif
|
||
|
||
#ifdef NEED_PW_CLEANER
|
||
static void FreePwBuf(ClientData dummy);
|
||
#endif
|
||
#ifdef NEED_GR_CLEANER
|
||
static void FreeGrBuf(ClientData dummy);
|
||
#endif
|
||
#endif /* TCL_THREADS */
|
||
|
||
/*
|
||
*---------------------------------------------------------------------------
|
||
*
|
||
* TclUnixSetBlockingMode --
|
||
*
|
||
* Set the blocking mode of a file descriptor.
|
||
*
|
||
* Results:
|
||
*
|
||
* 0 on success, -1 (with errno set) on error.
|
||
*
|
||
*---------------------------------------------------------------------------
|
||
*/
|
||
|
||
int
|
||
TclUnixSetBlockingMode(
|
||
int fd, /* File descriptor */
|
||
int mode) /* Either TCL_MODE_BLOCKING or
|
||
* TCL_MODE_NONBLOCKING. */
|
||
{
|
||
#ifndef USE_FIONBIO
|
||
int flags = fcntl(fd, F_GETFL);
|
||
|
||
if (mode == TCL_MODE_BLOCKING) {
|
||
flags &= ~O_NONBLOCK;
|
||
} else {
|
||
flags |= O_NONBLOCK;
|
||
}
|
||
return fcntl(fd, F_SETFL, flags);
|
||
#else /* USE_FIONBIO */
|
||
int state = (mode == TCL_MODE_NONBLOCKING);
|
||
|
||
return ioctl(fd, FIONBIO, &state);
|
||
#endif /* !USE_FIONBIO */
|
||
}
|
||
|
||
/*
|
||
*---------------------------------------------------------------------------
|
||
*
|
||
* 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;
|
||
|
||
/*
|
||
* How to allocate a buffer of the right initial size. If you want the
|
||
* gory detail, see http://www.opengroup.org/austin/docs/austin_328.txt
|
||
* and weep.
|
||
*/
|
||
|
||
if (tsdPtr->pbuf == NULL) {
|
||
tsdPtr->pbuflen = (int) sysconf(_SC_GETPW_R_SIZE_MAX);
|
||
if (tsdPtr->pbuflen < 1) {
|
||
tsdPtr->pbuflen = 1024;
|
||
}
|
||
tsdPtr->pbuf = (char *)ckalloc(tsdPtr->pbuflen);
|
||
Tcl_CreateThreadExitHandler(FreePwBuf, NULL);
|
||
}
|
||
while (1) {
|
||
int e = getpwnam_r(name, &tsdPtr->pwd, tsdPtr->pbuf, tsdPtr->pbuflen,
|
||
&pwPtr);
|
||
|
||
if (e == 0) {
|
||
break;
|
||
} else if (e != ERANGE) {
|
||
return NULL;
|
||
}
|
||
tsdPtr->pbuflen *= 2;
|
||
tsdPtr->pbuf = (char *)ckrealloc(tsdPtr->pbuf, tsdPtr->pbuflen);
|
||
}
|
||
return (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;
|
||
|
||
/*
|
||
* How to allocate a buffer of the right initial size. If you want the
|
||
* gory detail, see http://www.opengroup.org/austin/docs/austin_328.txt
|
||
* and weep.
|
||
*/
|
||
|
||
if (tsdPtr->pbuf == NULL) {
|
||
tsdPtr->pbuflen = (int) sysconf(_SC_GETPW_R_SIZE_MAX);
|
||
if (tsdPtr->pbuflen < 1) {
|
||
tsdPtr->pbuflen = 1024;
|
||
}
|
||
tsdPtr->pbuf = (char *)ckalloc(tsdPtr->pbuflen);
|
||
Tcl_CreateThreadExitHandler(FreePwBuf, NULL);
|
||
}
|
||
while (1) {
|
||
int e = getpwuid_r(uid, &tsdPtr->pwd, tsdPtr->pbuf, tsdPtr->pbuflen,
|
||
&pwPtr);
|
||
|
||
if (e == 0) {
|
||
break;
|
||
} else if (e != ERANGE) {
|
||
return NULL;
|
||
}
|
||
tsdPtr->pbuflen *= 2;
|
||
tsdPtr->pbuf = (char *)ckrealloc(tsdPtr->pbuf, tsdPtr->pbuflen);
|
||
}
|
||
return (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 */
|
||
}
|
||
|
||
/*
|
||
*---------------------------------------------------------------------------
|
||
*
|
||
* FreePwBuf --
|
||
*
|
||
* Helper that is used to dispose of space allocated and referenced from
|
||
* the ThreadSpecificData for user entries. (Darn that baroque POSIX
|
||
* reentrant interface.)
|
||
*
|
||
*---------------------------------------------------------------------------
|
||
*/
|
||
|
||
#ifdef NEED_PW_CLEANER
|
||
static void
|
||
FreePwBuf(
|
||
ClientData dummy)
|
||
{
|
||
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
|
||
(void)dummy;
|
||
|
||
ckfree(tsdPtr->pbuf);
|
||
}
|
||
#endif /* NEED_PW_CLEANER */
|
||
|
||
/*
|
||
*---------------------------------------------------------------------------
|
||
*
|
||
* 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;
|
||
|
||
/*
|
||
* How to allocate a buffer of the right initial size. If you want the
|
||
* gory detail, see http://www.opengroup.org/austin/docs/austin_328.txt
|
||
* and weep.
|
||
*/
|
||
|
||
if (tsdPtr->gbuf == NULL) {
|
||
tsdPtr->gbuflen = (int) sysconf(_SC_GETGR_R_SIZE_MAX);
|
||
if (tsdPtr->gbuflen < 1) {
|
||
tsdPtr->gbuflen = 1024;
|
||
}
|
||
tsdPtr->gbuf = (char *)ckalloc(tsdPtr->gbuflen);
|
||
Tcl_CreateThreadExitHandler(FreeGrBuf, NULL);
|
||
}
|
||
while (1) {
|
||
int e = getgrnam_r(name, &tsdPtr->grp, tsdPtr->gbuf, tsdPtr->gbuflen,
|
||
&grPtr);
|
||
|
||
if (e == 0) {
|
||
break;
|
||
} else if (e != ERANGE) {
|
||
return NULL;
|
||
}
|
||
tsdPtr->gbuflen *= 2;
|
||
tsdPtr->gbuf = (char *)ckrealloc(tsdPtr->gbuf, tsdPtr->gbuflen);
|
||
}
|
||
return (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;
|
||
|
||
/*
|
||
* How to allocate a buffer of the right initial size. If you want the
|
||
* gory detail, see http://www.opengroup.org/austin/docs/austin_328.txt
|
||
* and weep.
|
||
*/
|
||
|
||
if (tsdPtr->gbuf == NULL) {
|
||
tsdPtr->gbuflen = (int) sysconf(_SC_GETGR_R_SIZE_MAX);
|
||
if (tsdPtr->gbuflen < 1) {
|
||
tsdPtr->gbuflen = 1024;
|
||
}
|
||
tsdPtr->gbuf = (char *)ckalloc(tsdPtr->gbuflen);
|
||
Tcl_CreateThreadExitHandler(FreeGrBuf, NULL);
|
||
}
|
||
while (1) {
|
||
int e = getgrgid_r(gid, &tsdPtr->grp, tsdPtr->gbuf, tsdPtr->gbuflen,
|
||
&grPtr);
|
||
|
||
if (e == 0) {
|
||
break;
|
||
} else if (e != ERANGE) {
|
||
return NULL;
|
||
}
|
||
tsdPtr->gbuflen *= 2;
|
||
tsdPtr->gbuf = (char *)ckrealloc(tsdPtr->gbuf, tsdPtr->gbuflen);
|
||
}
|
||
return (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 */
|
||
}
|
||
|
||
/*
|
||
*---------------------------------------------------------------------------
|
||
*
|
||
* FreeGrBuf --
|
||
*
|
||
* Helper that is used to dispose of space allocated and referenced from
|
||
* the ThreadSpecificData for group entries. (Darn that baroque POSIX
|
||
* reentrant interface.)
|
||
*
|
||
*---------------------------------------------------------------------------
|
||
*/
|
||
|
||
#ifdef NEED_GR_CLEANER
|
||
static void
|
||
FreeGrBuf(
|
||
ClientData dummy)
|
||
{
|
||
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
|
||
(void)dummy;
|
||
|
||
ckfree(tsdPtr->gbuf);
|
||
}
|
||
#endif /* NEED_GR_CLEANER */
|
||
|
||
/*
|
||
*---------------------------------------------------------------------------
|
||
*
|
||
* 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 local_errno;
|
||
|
||
return gethostbyname_r(name, &tsdPtr->hent, tsdPtr->hbuf,
|
||
sizeof(tsdPtr->hbuf), &local_errno);
|
||
|
||
#elif defined(HAVE_GETHOSTBYNAME_R_6)
|
||
struct hostent *hePtr = NULL;
|
||
int local_errno, result;
|
||
|
||
result = gethostbyname_r(name, &tsdPtr->hent, tsdPtr->hbuf,
|
||
sizeof(tsdPtr->hbuf), &hePtr, &local_errno);
|
||
return (result == 0) ? hePtr : NULL;
|
||
|
||
#elif defined(HAVE_GETHOSTBYNAME_R_3)
|
||
struct hostent_data data;
|
||
|
||
return (gethostbyname_r(name, &tsdPtr->hent, &data) == 0)
|
||
? &tsdPtr->hent : NULL;
|
||
|
||
#else
|
||
#define NEED_COPYHOSTENT 1
|
||
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 local_errno;
|
||
|
||
return gethostbyaddr_r(addr, length, type, &tsdPtr->hent, tsdPtr->hbuf,
|
||
sizeof(tsdPtr->hbuf), &local_errno);
|
||
|
||
#elif defined(HAVE_GETHOSTBYADDR_R_8)
|
||
struct hostent *hePtr;
|
||
int local_errno;
|
||
|
||
return (gethostbyaddr_r(addr, length, type, &tsdPtr->hent, tsdPtr->hbuf,
|
||
sizeof(tsdPtr->hbuf), &hePtr, &local_errno) == 0)
|
||
? &tsdPtr->hent : NULL;
|
||
#else
|
||
#define NEED_COPYHOSTENT 1
|
||
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 */
|
||
}
|
||
|
||
/*
|
||
*---------------------------------------------------------------------------
|
||
*
|
||
* 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.
|
||
*
|
||
*---------------------------------------------------------------------------
|
||
*/
|
||
|
||
#ifdef NEED_COPYGRP
|
||
#define NEED_COPYARRAY 1
|
||
#define NEED_COPYSTRING 1
|
||
|
||
static int
|
||
CopyGrp(
|
||
struct group *tgtPtr,
|
||
char *buf,
|
||
int buflen)
|
||
{
|
||
char *p = buf;
|
||
int copied, len = 0;
|
||
|
||
/*
|
||
* Copy username.
|
||
*/
|
||
|
||
copied = CopyString(tgtPtr->gr_name, p, buflen - len);
|
||
if (copied == -1) {
|
||
goto range;
|
||
}
|
||
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;
|
||
|
||
range:
|
||
errno = ERANGE;
|
||
return -1;
|
||
}
|
||
#endif /* NEED_COPYGRP */
|
||
|
||
/*
|
||
*---------------------------------------------------------------------------
|
||
*
|
||
* CopyHostent --
|
||
*
|
||
* 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
|
||
*
|
||
*---------------------------------------------------------------------------
|
||
*/
|
||
|
||
#ifdef NEED_COPYHOSTENT
|
||
#define NEED_COPYSTRING 1
|
||
#define NEED_COPYARRAY 1
|
||
|
||
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) {
|
||
goto range;
|
||
}
|
||
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;
|
||
|
||
range:
|
||
errno = ERANGE;
|
||
return -1;
|
||
}
|
||
#endif /* NEED_COPYHOSTENT */
|
||
|
||
/*
|
||
*---------------------------------------------------------------------------
|
||
*
|
||
* 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.
|
||
*
|
||
*---------------------------------------------------------------------------
|
||
*/
|
||
|
||
#ifdef NEED_COPYPWD
|
||
#define NEED_COPYSTRING 1
|
||
|
||
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 /* NEED_COPYPWD */
|
||
|
||
/*
|
||
*---------------------------------------------------------------------------
|
||
*
|
||
* 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.
|
||
*
|
||
*---------------------------------------------------------------------------
|
||
*/
|
||
|
||
#ifdef NEED_COPYARRAY
|
||
static int
|
||
CopyArray(
|
||
char **src, /* Array of elements to copy. */
|
||
int elsize, /* Size of each element, or -1 to indicate
|
||
* that they are C strings of dynamic
|
||
* length. */
|
||
char *buf, /* Buffer to copy into. */
|
||
int buflen) /* Size of buffer. */
|
||
{
|
||
int i, j, len = 0;
|
||
char *p, **newBuffer;
|
||
|
||
if (src == NULL) {
|
||
return 0;
|
||
}
|
||
|
||
for (i = 0; src[i] != NULL; i++) {
|
||
/*
|
||
* Empty loop to count how many.
|
||
*/
|
||
}
|
||
len = sizeof(char *) * (i + 1); /* Leave place for the array. */
|
||
if (len > buflen) {
|
||
return -1;
|
||
}
|
||
|
||
newBuffer = (char **)buf;
|
||
p = buf + len;
|
||
|
||
for (j = 0; j < i; j++) {
|
||
int sz = (elsize<0 ? (int) strlen(src[j]) + 1 : elsize);
|
||
|
||
len += sz;
|
||
if (len > buflen) {
|
||
return -1;
|
||
}
|
||
memcpy(p, src[j], sz);
|
||
newBuffer[j] = p;
|
||
p = buf + len;
|
||
}
|
||
newBuffer[j] = NULL;
|
||
|
||
return len;
|
||
}
|
||
#endif /* NEED_COPYARRAY */
|
||
|
||
/*
|
||
*---------------------------------------------------------------------------
|
||
*
|
||
* 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
|
||
*
|
||
*---------------------------------------------------------------------------
|
||
*/
|
||
|
||
#ifdef NEED_COPYSTRING
|
||
static int
|
||
CopyString(
|
||
const char *src, /* String to copy. */
|
||
char *buf, /* Buffer to copy into. */
|
||
int buflen) /* Size of buffer. */
|
||
{
|
||
int len = 0;
|
||
|
||
if (src != NULL) {
|
||
len = strlen(src) + 1;
|
||
if (len > buflen) {
|
||
return -1;
|
||
}
|
||
memcpy(buf, src, len);
|
||
}
|
||
|
||
return len;
|
||
}
|
||
#endif /* NEED_COPYSTRING */
|
||
|
||
/*
|
||
* Local Variables:
|
||
* mode: c
|
||
* c-basic-offset: 4
|
||
* fill-column: 78
|
||
* End:
|
||
*/
|
||
|
||
/*
|
||
*------------------------------------------------------------------------
|
||
*
|
||
* TclWinCPUID --
|
||
*
|
||
* Get CPU ID information on an Intel box under UNIX (either Linux or Cygwin)
|
||
*
|
||
* Results:
|
||
* Returns TCL_OK if successful, TCL_ERROR if CPUID is not supported.
|
||
*
|
||
* Side effects:
|
||
* If successful, stores EAX, EBX, ECX and EDX registers after the CPUID
|
||
* instruction in the four integers designated by 'regsPtr'
|
||
*
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
int
|
||
TclWinCPUID(
|
||
unsigned int index, /* Which CPUID value to retrieve. */
|
||
unsigned int *regsPtr) /* Registers after the CPUID. */
|
||
{
|
||
int status = TCL_ERROR;
|
||
|
||
/* See: <http://en.wikipedia.org/wiki/CPUID> */
|
||
#if defined(HAVE_CPUID)
|
||
#if defined(__x86_64__) || defined(_M_AMD64) || defined (_M_X64)
|
||
__asm__ __volatile__("movq %%rbx, %%rsi \n\t" /* save %rbx */
|
||
"cpuid \n\t"
|
||
"xchgq %%rsi, %%rbx \n\t" /* restore the old %rbx */
|
||
: "=a"(regsPtr[0]), "=S"(regsPtr[1]), "=c"(regsPtr[2]), "=d"(regsPtr[3])
|
||
: "a"(index));
|
||
#else
|
||
__asm__ __volatile__("mov %%ebx, %%esi \n\t" /* save %ebx */
|
||
"cpuid \n\t"
|
||
"xchg %%esi, %%ebx \n\t" /* restore the old %ebx */
|
||
: "=a"(regsPtr[0]), "=S"(regsPtr[1]), "=c"(regsPtr[2]), "=d"(regsPtr[3])
|
||
: "a"(index));
|
||
#endif
|
||
status = TCL_OK;
|
||
#endif
|
||
return status;
|
||
}
|
||
|
||
/*
|
||
* Local Variables:
|
||
* mode: c
|
||
* c-basic-offset: 4
|
||
* fill-column: 78
|
||
* End:
|
||
*/
|