1996-05-04 11:50:46 +04:00
/*
Unix SMB / Netbios implementation .
Version 1.9 .
Samba system utilities
1998-01-22 16:27:43 +03:00
Copyright ( C ) Andrew Tridgell 1992 - 1998
1996-05-04 11:50:46 +04:00
This program is free software ; you can redistribute it and / or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation ; either version 2 of the License , or
( at your option ) any later version .
This program is distributed in the hope that it will be useful ,
but WITHOUT ANY WARRANTY ; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
GNU General Public License for more details .
You should have received a copy of the GNU General Public License
along with this program ; if not , write to the Free Software
Foundation , Inc . , 675 Mass Ave , Cambridge , MA 0213 9 , USA .
*/
# include "includes.h"
extern int DEBUGLEVEL ;
/*
The idea is that this file will eventually have wrappers around all
1996-06-19 17:23:46 +04:00
important system calls in samba . The aims are :
1996-05-04 11:50:46 +04:00
- to enable easier porting by putting OS dependent stuff in here
- to allow for hooks into other " pseudo-filesystems "
- to allow easier integration of things like the japanese extensions
1996-06-19 17:23:46 +04:00
- to support the philosophy of Samba to expose the features of
the OS within the SMB model . In general whatever file / printer / variable
expansions / etc make sense to the OS should be acceptable to Samba .
1996-05-04 11:50:46 +04:00
*/
2000-06-11 09:57:58 +04:00
1999-12-13 16:27:58 +03:00
/*******************************************************************
A wrapper for usleep in case we don ' t have one .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int sys_usleep ( long usecs )
{
# ifndef HAVE_USLEEP
struct timeval tval ;
# endif
/*
* We need this braindamage as the glibc usleep
* is not SPEC1170 complient . . . grumble . . . JRA .
*/
if ( usecs < 0 | | usecs > 1000000 ) {
errno = EINVAL ;
return - 1 ;
}
# if HAVE_USLEEP
usleep ( usecs ) ;
return 0 ;
# else /* HAVE_USLEEP */
/*
* Fake it with select . . .
*/
tval . tv_sec = 0 ;
tval . tv_usec = usecs / 1000 ;
select ( 0 , NULL , NULL , NULL , & tval ) ;
return 0 ;
# endif /* HAVE_USLEEP */
}
1998-09-03 22:40:31 +04:00
/*******************************************************************
A stat ( ) wrapper that will deal with 64 bit filesizes .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1998-11-26 00:17:20 +03:00
int sys_stat ( const char * fname , SMB_STRUCT_STAT * sbuf )
1998-09-03 22:40:31 +04:00
{
1999-12-13 16:27:58 +03:00
int ret ;
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_STAT64)
ret = stat64 ( fname , sbuf ) ;
1998-09-03 22:40:31 +04:00
# else
1999-12-13 16:27:58 +03:00
ret = stat ( fname , sbuf ) ;
1998-09-03 22:40:31 +04:00
# endif
1999-12-13 16:27:58 +03:00
/* we always want directories to appear zero size */
if ( ret = = 0 & & S_ISDIR ( sbuf - > st_mode ) ) sbuf - > st_size = 0 ;
return ret ;
1998-09-03 22:40:31 +04:00
}
/*******************************************************************
An fstat ( ) wrapper that will deal with 64 bit filesizes .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int sys_fstat ( int fd , SMB_STRUCT_STAT * sbuf )
{
1999-12-13 16:27:58 +03:00
int ret ;
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FSTAT64)
ret = fstat64 ( fd , sbuf ) ;
1998-09-03 22:40:31 +04:00
# else
1999-12-13 16:27:58 +03:00
ret = fstat ( fd , sbuf ) ;
1998-09-03 22:40:31 +04:00
# endif
1999-12-13 16:27:58 +03:00
/* we always want directories to appear zero size */
if ( ret = = 0 & & S_ISDIR ( sbuf - > st_mode ) ) sbuf - > st_size = 0 ;
return ret ;
1998-09-03 22:40:31 +04:00
}
/*******************************************************************
An lstat ( ) wrapper that will deal with 64 bit filesizes .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1998-11-26 00:17:20 +03:00
int sys_lstat ( const char * fname , SMB_STRUCT_STAT * sbuf )
1998-09-03 22:40:31 +04:00
{
1999-12-13 16:27:58 +03:00
int ret ;
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSTAT64)
ret = lstat64 ( fname , sbuf ) ;
1998-09-03 22:40:31 +04:00
# else
1999-12-13 16:27:58 +03:00
ret = lstat ( fname , sbuf ) ;
1998-09-03 22:40:31 +04:00
# endif
1999-12-13 16:27:58 +03:00
/* we always want directories to appear zero size */
if ( ret = = 0 & & S_ISDIR ( sbuf - > st_mode ) ) sbuf - > st_size = 0 ;
return ret ;
1998-09-03 22:40:31 +04:00
}
/*******************************************************************
An ftruncate ( ) wrapper that will deal with 64 bit filesizes .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int sys_ftruncate ( int fd , SMB_OFF_T offset )
{
1999-12-13 16:27:58 +03:00
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FTRUNCATE64)
1998-09-03 22:40:31 +04:00
return ftruncate64 ( fd , offset ) ;
# else
return ftruncate ( fd , offset ) ;
# endif
}
/*******************************************************************
An lseek ( ) wrapper that will deal with 64 bit filesizes .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1998-09-12 01:42:18 +04:00
SMB_OFF_T sys_lseek ( int fd , SMB_OFF_T offset , int whence )
1998-09-03 22:40:31 +04:00
{
1999-12-13 16:27:58 +03:00
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSEEK64)
1998-09-03 22:40:31 +04:00
return lseek64 ( fd , offset , whence ) ;
# else
return lseek ( fd , offset , whence ) ;
# endif
}
1996-05-04 11:50:46 +04:00
1998-09-17 23:16:12 +04:00
/*******************************************************************
An fseek ( ) wrapper that will deal with 64 bit filesizes .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int sys_fseek ( FILE * fp , SMB_OFF_T offset , int whence )
{
1999-12-13 16:27:58 +03:00
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEK64)
1998-09-17 23:16:12 +04:00
return fseek64 ( fp , offset , whence ) ;
1999-12-13 16:27:58 +03:00
# elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEKO64)
return fseeko64 ( fp , offset , whence ) ;
1998-09-17 23:16:12 +04:00
# else
return fseek ( fp , offset , whence ) ;
# endif
}
/*******************************************************************
An ftell ( ) wrapper that will deal with 64 bit filesizes .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
SMB_OFF_T sys_ftell ( FILE * fp )
{
1999-12-13 16:27:58 +03:00
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELL64)
1998-09-17 23:16:12 +04:00
return ( SMB_OFF_T ) ftell64 ( fp ) ;
1999-12-13 16:27:58 +03:00
# elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELLO64)
return ( SMB_OFF_T ) ftello64 ( fp ) ;
1998-09-17 23:16:12 +04:00
# else
return ( SMB_OFF_T ) ftell ( fp ) ;
# endif
}
1998-11-17 23:50:07 +03:00
/*******************************************************************
A creat ( ) wrapper that will deal with 64 bit filesizes .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int sys_creat ( const char * path , mode_t mode )
{
1999-12-13 16:27:58 +03:00
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CREAT64)
1998-11-17 23:50:07 +03:00
return creat64 ( path , mode ) ;
# else
/*
* If creat64 isn ' t defined then ensure we call a potential open64 .
* JRA .
*/
return sys_open ( path , O_WRONLY | O_CREAT | O_TRUNC , mode ) ;
# endif
}
/*******************************************************************
An open ( ) wrapper that will deal with 64 bit filesizes .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int sys_open ( const char * path , int oflag , mode_t mode )
{
1999-12-13 16:27:58 +03:00
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OPEN64)
1998-11-17 23:50:07 +03:00
return open64 ( path , oflag , mode ) ;
# else
return open ( path , oflag , mode ) ;
# endif
}
/*******************************************************************
An fopen ( ) wrapper that will deal with 64 bit filesizes .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
FILE * sys_fopen ( const char * path , const char * type )
{
1999-12-13 16:27:58 +03:00
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_FOPEN64)
1998-11-17 23:50:07 +03:00
return fopen64 ( path , type ) ;
# else
return fopen ( path , type ) ;
# endif
}
1999-12-13 16:27:58 +03:00
/*******************************************************************
A readdir wrapper that will deal with 64 bit filesizes .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
SMB_STRUCT_DIRENT * sys_readdir ( DIR * dirp )
{
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_READDIR64)
return readdir64 ( dirp ) ;
# else
return readdir ( dirp ) ;
# endif
}
1996-10-05 06:54:37 +04:00
/*******************************************************************
The wait ( ) calls vary between systems
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1998-11-26 00:17:20 +03:00
1996-10-05 06:54:37 +04:00
int sys_waitpid ( pid_t pid , int * status , int options )
{
1998-07-29 07:08:05 +04:00
# ifdef HAVE_WAITPID
1996-10-05 06:54:37 +04:00
return waitpid ( pid , status , options ) ;
1998-07-29 07:08:05 +04:00
# else /* HAVE_WAITPID */
1997-02-23 08:18:09 +03:00
return wait4 ( pid , status , options , NULL ) ;
1998-07-29 07:08:05 +04:00
# endif /* HAVE_WAITPID */
1996-10-05 06:54:37 +04:00
}
1997-08-22 00:03:45 +04:00
/*******************************************************************
1998-10-02 16:35:28 +04:00
system wrapper for getwd
1997-08-22 00:03:45 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1998-10-02 16:35:28 +04:00
char * sys_getwd ( char * s )
1997-08-22 00:03:45 +04:00
{
1999-12-13 16:27:58 +03:00
char * wd ;
1998-07-29 07:08:05 +04:00
# ifdef HAVE_GETCWD
1999-12-13 16:27:58 +03:00
wd = ( char * ) getcwd ( s , sizeof ( pstring ) ) ;
1997-08-22 00:03:45 +04:00
# else
1999-12-13 16:27:58 +03:00
wd = ( char * ) getwd ( s ) ;
1997-08-22 00:03:45 +04:00
# endif
1999-12-13 16:27:58 +03:00
return wd ;
1998-10-02 16:35:28 +04:00
}
1996-05-04 11:50:46 +04:00
/*******************************************************************
chown isn ' t used much but OS / 2 doesn ' t have it
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1999-12-13 16:27:58 +03:00
1998-11-26 00:17:20 +03:00
int sys_chown ( const char * fname , uid_t uid , gid_t gid )
1996-05-04 11:50:46 +04:00
{
1998-07-29 07:08:05 +04:00
# ifndef HAVE_CHOWN
static int done ;
if ( ! done ) {
DEBUG ( 1 , ( " WARNING: no chown! \n " ) ) ;
done = 1 ;
}
1996-05-04 11:50:46 +04:00
# else
1998-07-29 07:08:05 +04:00
return ( chown ( fname , uid , gid ) ) ;
1996-05-04 11:50:46 +04:00
# endif
}
/*******************************************************************
os / 2 also doesn ' t have chroot
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1998-11-26 00:17:20 +03:00
int sys_chroot ( const char * dname )
1996-05-04 11:50:46 +04:00
{
1998-07-29 07:08:05 +04:00
# ifndef HAVE_CHROOT
static int done ;
if ( ! done ) {
DEBUG ( 1 , ( " WARNING: no chroot! \n " ) ) ;
done = 1 ;
}
2000-06-10 17:38:07 +04:00
errno = ENOSYS ;
return - 1 ;
1996-05-04 11:50:46 +04:00
# else
1998-07-29 07:08:05 +04:00
return ( chroot ( dname ) ) ;
1996-05-04 11:50:46 +04:00
# endif
}
1997-02-23 08:18:09 +03:00
/**************************************************************************
A wrapper for gethostbyname ( ) that tries avoids looking up hostnames
in the root domain , which can cause dial - on - demand links to come up for no
apparent reason .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1998-11-26 00:17:20 +03:00
struct hostent * sys_gethostbyname ( const char * name )
1997-02-23 08:18:09 +03:00
{
1997-08-26 02:18:31 +04:00
# ifdef REDUCE_ROOT_DNS_LOOKUPS
1997-02-23 08:18:09 +03:00
char query [ 256 ] , hostname [ 256 ] ;
char * domain ;
/* Does this name have any dots in it? If so, make no change */
if ( strchr ( name , ' . ' ) )
return ( gethostbyname ( name ) ) ;
/* Get my hostname, which should have domain name
attached . If not , just do the gethostname on the
original string .
*/
gethostname ( hostname , sizeof ( hostname ) - 1 ) ;
hostname [ sizeof ( hostname ) - 1 ] = 0 ;
if ( ( domain = strchr ( hostname , ' . ' ) ) = = NULL )
return ( gethostbyname ( name ) ) ;
/* Attach domain name to query and do modified query.
If names too large , just do gethostname on the
original string .
*/
if ( ( strlen ( name ) + strlen ( domain ) ) > = sizeof ( query ) )
return ( gethostbyname ( name ) ) ;
1998-05-11 10:38:36 +04:00
slprintf ( query , sizeof ( query ) - 1 , " %s%s " , name , domain ) ;
1997-02-23 08:18:09 +03:00
return ( gethostbyname ( query ) ) ;
1997-08-26 02:18:31 +04:00
# else /* REDUCE_ROOT_DNS_LOOKUPS */
return ( gethostbyname ( name ) ) ;
# endif /* REDUCE_ROOT_DNS_LOOKUPS */
1997-02-23 08:18:09 +03:00
}
1998-09-26 03:40:49 +04:00
2000-06-09 10:58:06 +04:00
# if defined(HAVE_IRIX_SPECIFIC_CAPABILITIES)
1998-09-26 03:40:49 +04:00
/**************************************************************************
Try and abstract process capabilities ( for systems that have them ) .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2000-06-09 10:58:06 +04:00
static BOOL set_process_capability ( uint32 cap_flag , BOOL enable )
1998-09-26 03:40:49 +04:00
{
if ( cap_flag = = KERNEL_OPLOCK_CAPABILITY )
{
cap_t cap = cap_get_proc ( ) ;
if ( cap = = NULL ) {
DEBUG ( 0 , ( " set_process_capability: cap_get_proc failed. Error was %s \n " ,
strerror ( errno ) ) ) ;
return False ;
}
if ( enable )
cap - > cap_effective | = CAP_NETWORK_MGT ;
else
cap - > cap_effective & = ~ CAP_NETWORK_MGT ;
if ( cap_set_proc ( cap ) = = - 1 ) {
DEBUG ( 0 , ( " set_process_capability: cap_set_proc failed. Error was %s \n " ,
strerror ( errno ) ) ) ;
1999-12-13 16:27:58 +03:00
cap_free ( cap ) ;
1998-09-26 03:40:49 +04:00
return False ;
}
1999-12-13 16:27:58 +03:00
cap_free ( cap ) ;
1998-09-26 03:40:49 +04:00
DEBUG ( 10 , ( " set_process_capability: Set KERNEL_OPLOCK_CAPABILITY. \n " ) ) ;
}
return True ;
}
/**************************************************************************
Try and abstract inherited process capabilities ( for systems that have them ) .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2000-06-09 10:58:06 +04:00
static BOOL set_inherited_process_capability ( uint32 cap_flag , BOOL enable )
1998-09-26 03:40:49 +04:00
{
if ( cap_flag = = KERNEL_OPLOCK_CAPABILITY )
{
cap_t cap = cap_get_proc ( ) ;
if ( cap = = NULL ) {
DEBUG ( 0 , ( " set_inherited_process_capability: cap_get_proc failed. Error was %s \n " ,
strerror ( errno ) ) ) ;
return False ;
}
if ( enable )
cap - > cap_inheritable | = CAP_NETWORK_MGT ;
else
cap - > cap_inheritable & = ~ CAP_NETWORK_MGT ;
if ( cap_set_proc ( cap ) = = - 1 ) {
DEBUG ( 0 , ( " set_inherited_process_capability: cap_set_proc failed. Error was %s \n " ,
strerror ( errno ) ) ) ;
1999-12-13 16:27:58 +03:00
cap_free ( cap ) ;
1998-09-26 03:40:49 +04:00
return False ;
}
1999-12-13 16:27:58 +03:00
cap_free ( cap ) ;
1998-09-26 03:40:49 +04:00
DEBUG ( 10 , ( " set_inherited_process_capability: Set KERNEL_OPLOCK_CAPABILITY. \n " ) ) ;
}
return True ;
}
2000-06-09 10:58:06 +04:00
# endif
/****************************************************************************
gain the oplock capability from the kernel if possible
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void oplock_set_capability ( BOOL this_process , BOOL inherit )
{
# if HAVE_KERNEL_OPLOCKS_IRIX
set_process_capability ( KERNEL_OPLOCK_CAPABILITY , this_process ) ;
set_inherited_process_capability ( KERNEL_OPLOCK_CAPABILITY , inherit ) ;
# endif
}
1998-09-26 03:40:49 +04:00
/**************************************************************************
Wrapper for random ( ) .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
long sys_random ( void )
{
# if defined(HAVE_RANDOM)
return ( long ) random ( ) ;
# elif defined(HAVE_RAND)
return ( long ) rand ( ) ;
# else
DEBUG ( 0 , ( " Error - no random function available ! \n " ) ) ;
exit ( 1 ) ;
# endif
}
/**************************************************************************
Wrapper for srandom ( ) .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void sys_srandom ( unsigned int seed )
{
# if defined(HAVE_SRANDOM)
srandom ( seed ) ;
# elif defined(HAVE_SRAND)
srand ( seed ) ;
# else
DEBUG ( 0 , ( " Error - no srandom function available ! \n " ) ) ;
exit ( 1 ) ;
# endif
}
1998-09-30 00:24:17 +04:00
2000-02-15 22:36:47 +03:00
/**************************************************************************
Returns equivalent to NGROUPS_MAX - using sysconf if needed .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int groups_max ( void )
{
# if defined(SYSCONF_SC_NGROUPS_MAX)
int ret = sysconf ( _SC_NGROUPS_MAX ) ;
return ( ret = = - 1 ) ? NGROUPS_MAX : ret ;
# else
return NGROUPS_MAX ;
# endif
}
1998-09-30 00:24:17 +04:00
/**************************************************************************
Wrapper for getgroups . Deals with broken ( int ) case .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int sys_getgroups ( int setlen , gid_t * gidset )
{
# if !defined(HAVE_BROKEN_GETGROUPS)
return getgroups ( setlen , gidset ) ;
# else
GID_T gid ;
GID_T * group_list ;
int i , ngroups ;
if ( setlen = = 0 ) {
return getgroups ( setlen , & gid ) ;
}
/*
* Broken case . We need to allocate a
* GID_T array of size setlen .
*/
if ( setlen < 0 ) {
errno = EINVAL ;
return - 1 ;
}
1999-12-13 16:27:58 +03:00
if ( setlen = = 0 )
2000-02-15 22:36:47 +03:00
setlen = groups_max ( ) ;
1998-10-05 12:42:41 +04:00
if ( ( group_list = ( GID_T * ) malloc ( setlen * sizeof ( GID_T ) ) ) = = NULL ) {
1998-09-30 00:24:17 +04:00
DEBUG ( 0 , ( " sys_getgroups: Malloc fail. \n " ) ) ;
return - 1 ;
}
if ( ( ngroups = getgroups ( setlen , group_list ) ) < 0 ) {
int saved_errno = errno ;
free ( ( char * ) group_list ) ;
errno = saved_errno ;
return - 1 ;
}
for ( i = 0 ; i < ngroups ; i + + )
gidset [ i ] = ( gid_t ) group_list [ i ] ;
free ( ( char * ) group_list ) ;
return ngroups ;
# endif /* HAVE_BROKEN_GETGROUPS */
}
1999-07-07 01:50:29 +04:00
1999-12-13 16:27:58 +03:00
# ifdef HAVE_SETGROUPS
/**************************************************************************
Wrapper for setgroups . Deals with broken ( int ) case . Automatically used
if we have broken getgroups .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int sys_setgroups ( int setlen , gid_t * gidset )
{
# if !defined(HAVE_BROKEN_GETGROUPS)
return setgroups ( setlen , gidset ) ;
# else
GID_T * group_list ;
int i ;
if ( setlen = = 0 )
return 0 ;
2000-02-15 22:36:47 +03:00
if ( setlen < 0 | | setlen > groups_max ( ) ) {
1999-12-13 16:27:58 +03:00
errno = EINVAL ;
return - 1 ;
}
/*
* Broken case . We need to allocate a
* GID_T array of size setlen .
*/
if ( ( group_list = ( GID_T * ) malloc ( setlen * sizeof ( GID_T ) ) ) = = NULL ) {
DEBUG ( 0 , ( " sys_setgroups: Malloc fail. \n " ) ) ;
return - 1 ;
}
for ( i = 0 ; i < setlen ; i + + )
group_list [ i ] = ( GID_T ) gidset [ i ] ;
if ( setgroups ( setlen , group_list ) ! = 0 ) {
int saved_errno = errno ;
free ( ( char * ) group_list ) ;
errno = saved_errno ;
return - 1 ;
}
free ( ( char * ) group_list ) ;
return 0 ;
# endif /* HAVE_BROKEN_GETGROUPS */
}
# endif /* HAVE_SETGROUPS */
1999-07-07 01:50:29 +04:00
/*
* We only wrap pw_name and pw_passwd for now as these
* are the only potentially modified fields .
*/
/**************************************************************************
Helper function for getpwnam / getpwuid wrappers .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1999-12-13 16:27:58 +03:00
static struct passwd * setup_pwret ( struct passwd * pass )
1999-07-07 01:50:29 +04:00
{
static pstring pw_name ;
static pstring pw_passwd ;
static struct passwd pw_ret ;
if ( pass = = NULL )
{
return NULL ;
}
memcpy ( ( char * ) & pw_ret , pass , sizeof ( struct passwd ) ) ;
if ( pass - > pw_name )
{
pw_ret . pw_name = pw_name ;
pstrcpy ( pw_ret . pw_name , pass - > pw_name ) ;
}
if ( pass - > pw_passwd )
{
pw_ret . pw_passwd = pw_passwd ;
pstrcpy ( pw_ret . pw_passwd , pass - > pw_passwd ) ;
}
return & pw_ret ;
}
/**************************************************************************
Wrapper for getpwnam ( ) . Always returns a static that can be modified .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
struct passwd * sys_getpwnam ( const char * name )
{
1999-12-13 16:27:58 +03:00
return setup_pwret ( getpwnam ( name ) ) ;
1999-07-07 01:50:29 +04:00
}
/**************************************************************************
Wrapper for getpwuid ( ) . Always returns a static that can be modified .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
struct passwd * sys_getpwuid ( uid_t uid )
{
1999-12-13 16:27:58 +03:00
return setup_pwret ( getpwuid ( uid ) ) ;
1999-07-07 01:50:29 +04:00
}
1999-12-22 04:29:22 +03:00
/**************************************************************************
The following are the UNICODE versions of * all * system interface functions
called within Samba . Ok , ok , the exceptions are the gethostbyXX calls ,
which currently are left as ascii as they are not used other than in name
resolution .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**************************************************************************
Wide stat . Just narrow and call sys_xxx .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int wsys_stat ( const smb_ucs2_t * wfname , SMB_STRUCT_STAT * sbuf )
{
pstring fname ;
return sys_stat ( unicode_to_unix ( fname , wfname , sizeof ( fname ) ) , sbuf ) ;
}
/**************************************************************************
Wide lstat . Just narrow and call sys_xxx .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int wsys_lstat ( const smb_ucs2_t * wfname , SMB_STRUCT_STAT * sbuf )
{
pstring fname ;
return sys_lstat ( unicode_to_unix ( fname , wfname , sizeof ( fname ) ) , sbuf ) ;
}
/**************************************************************************
Wide creat . Just narrow and call sys_xxx .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int wsys_creat ( const smb_ucs2_t * wfname , mode_t mode )
{
pstring fname ;
return sys_creat ( unicode_to_unix ( fname , wfname , sizeof ( fname ) ) , mode ) ;
}
/**************************************************************************
Wide open . Just narrow and call sys_xxx .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int wsys_open ( const smb_ucs2_t * wfname , int oflag , mode_t mode )
{
pstring fname ;
return sys_open ( unicode_to_unix ( fname , wfname , sizeof ( fname ) ) , oflag , mode ) ;
}
/**************************************************************************
Wide fopen . Just narrow and call sys_xxx .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
FILE * wsys_fopen ( const smb_ucs2_t * wfname , const char * type )
{
pstring fname ;
return sys_fopen ( unicode_to_unix ( fname , wfname , sizeof ( fname ) ) , type ) ;
}
/**************************************************************************
Wide opendir . Just narrow and call sys_xxx .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
DIR * wsys_opendir ( const smb_ucs2_t * wfname )
{
pstring fname ;
return opendir ( unicode_to_unix ( fname , wfname , sizeof ( fname ) ) ) ;
}
/**************************************************************************
Wide readdir . Return a structure pointer containing a wide filename .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
SMB_STRUCT_WDIRENT * wsys_readdir ( DIR * dirp )
{
static SMB_STRUCT_WDIRENT retval ;
SMB_STRUCT_DIRENT * dirval = sys_readdir ( dirp ) ;
if ( ! dirval )
return NULL ;
1999-12-22 21:46:05 +03:00
/*
* The only POSIX defined member of this struct is d_name .
*/
1999-12-22 04:29:22 +03:00
unix_to_unicode ( retval . d_name , dirval - > d_name , sizeof ( retval . d_name ) ) ;
return & retval ;
}
/**************************************************************************
Wide getwd . Call sys_xxx and widen . Assumes s points to a wpstring .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
smb_ucs2_t * wsys_getwd ( smb_ucs2_t * s )
{
pstring fname ;
char * p = sys_getwd ( fname ) ;
if ( ! p )
return NULL ;
return unix_to_unicode ( s , p , sizeof ( wpstring ) ) ;
}
/**************************************************************************
Wide chown . Just narrow and call sys_xxx .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int wsys_chown ( const smb_ucs2_t * wfname , uid_t uid , gid_t gid )
{
pstring fname ;
return chown ( unicode_to_unix ( fname , wfname , sizeof ( fname ) ) , uid , gid ) ;
}
/**************************************************************************
Wide chroot . Just narrow and call sys_xxx .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int wsys_chroot ( const smb_ucs2_t * wfname )
{
pstring fname ;
return chroot ( unicode_to_unix ( fname , wfname , sizeof ( fname ) ) ) ;
}
/**************************************************************************
Wide getpwnam . Return a structure pointer containing wide names .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
SMB_STRUCT_WPASSWD * wsys_getpwnam ( const smb_ucs2_t * wname )
{
static SMB_STRUCT_WPASSWD retval ;
fstring name ;
struct passwd * pwret = sys_getpwnam ( unicode_to_unix ( name , wname , sizeof ( name ) ) ) ;
if ( ! pwret )
return NULL ;
unix_to_unicode ( retval . pw_name , pwret - > pw_name , sizeof ( retval . pw_name ) ) ;
retval . pw_passwd = pwret - > pw_passwd ;
retval . pw_uid = pwret - > pw_uid ;
retval . pw_gid = pwret - > pw_gid ;
unix_to_unicode ( retval . pw_gecos , pwret - > pw_gecos , sizeof ( retval . pw_gecos ) ) ;
unix_to_unicode ( retval . pw_dir , pwret - > pw_dir , sizeof ( retval . pw_dir ) ) ;
unix_to_unicode ( retval . pw_shell , pwret - > pw_shell , sizeof ( retval . pw_shell ) ) ;
return & retval ;
}
/**************************************************************************
Wide getpwuid . Return a structure pointer containing wide names .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
SMB_STRUCT_WPASSWD * wsys_getpwuid ( uid_t uid )
{
static SMB_STRUCT_WPASSWD retval ;
struct passwd * pwret = sys_getpwuid ( uid ) ;
if ( ! pwret )
return NULL ;
unix_to_unicode ( retval . pw_name , pwret - > pw_name , sizeof ( retval . pw_name ) ) ;
retval . pw_passwd = pwret - > pw_passwd ;
retval . pw_uid = pwret - > pw_uid ;
retval . pw_gid = pwret - > pw_gid ;
unix_to_unicode ( retval . pw_gecos , pwret - > pw_gecos , sizeof ( retval . pw_gecos ) ) ;
unix_to_unicode ( retval . pw_dir , pwret - > pw_dir , sizeof ( retval . pw_dir ) ) ;
unix_to_unicode ( retval . pw_shell , pwret - > pw_shell , sizeof ( retval . pw_shell ) ) ;
return & retval ;
}
2000-02-15 22:36:47 +03:00
/**************************************************************************
Extract a command into an arg list . Uses a static pstring for storage .
Caller frees returned arg list ( which contains pointers into the static pstring ) .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static char * * extract_args ( const char * command )
{
static pstring trunc_cmd ;
char * ptr ;
int argcl ;
char * * argl = NULL ;
int i ;
pstrcpy ( trunc_cmd , command ) ;
if ( ! ( ptr = strtok ( trunc_cmd , " \t " ) ) ) {
errno = EINVAL ;
return NULL ;
}
/*
* Count the args .
*/
for ( argcl = 1 ; ptr ; ptr = strtok ( NULL , " \t " ) )
argcl + + ;
if ( ( argl = ( char * * ) malloc ( ( argcl + 1 ) * sizeof ( char * ) ) ) = = NULL )
return NULL ;
/*
* Now do the extraction .
*/
pstrcpy ( trunc_cmd , command ) ;
ptr = strtok ( trunc_cmd , " \t " ) ;
i = 0 ;
argl [ i + + ] = ptr ;
while ( ( ptr = strtok ( NULL , " \t " ) ) ! = NULL )
argl [ i + + ] = ptr ;
argl [ i + + ] = NULL ;
return argl ;
}
2000-05-02 06:23:41 +04:00
/**************************************************************************
Wrapper for fork . Ensures that mypid is reset . Used so we can write
a sys_getpid ( ) that only does a system call * once * .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static pid_t mypid = ( pid_t ) - 1 ;
pid_t sys_fork ( void )
{
pid_t forkret = fork ( ) ;
if ( forkret = = ( pid_t ) 0 ) /* Child - reset mypid so sys_getpid does a system call. */
mypid = ( pid_t ) - 1 ;
return forkret ;
}
/**************************************************************************
Wrapper for getpid . Ensures we only do a system call * once * .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
pid_t sys_getpid ( void )
{
if ( mypid = = ( pid_t ) - 1 )
mypid = getpid ( ) ;
return mypid ;
}
2000-02-15 22:36:47 +03:00
/**************************************************************************
Wrapper for popen . Safer as it doesn ' t search a path .
Modified from the glibc sources .
2000-04-16 15:00:21 +04:00
modified by tridge to return a file descriptor . We must kick our FILE * habit
2000-02-15 22:36:47 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2000-05-02 06:23:41 +04:00
2000-02-15 22:36:47 +03:00
typedef struct _popen_list
{
2000-04-16 15:00:21 +04:00
int fd ;
2000-02-15 22:36:47 +03:00
pid_t child_pid ;
struct _popen_list * next ;
} popen_list ;
static popen_list * popen_chain ;
2000-04-16 15:00:21 +04:00
int sys_popen ( const char * command )
2000-02-15 22:36:47 +03:00
{
int parent_end , child_end ;
int pipe_fds [ 2 ] ;
2000-04-16 15:00:21 +04:00
popen_list * entry = NULL ;
2000-02-15 22:36:47 +03:00
char * * argl = NULL ;
if ( pipe ( pipe_fds ) < 0 )
2000-04-16 15:00:21 +04:00
return - 1 ;
2000-02-15 22:36:47 +03:00
2000-04-16 15:00:21 +04:00
parent_end = pipe_fds [ 0 ] ;
child_end = pipe_fds [ 1 ] ;
2000-02-15 22:36:47 +03:00
if ( ! * command ) {
errno = EINVAL ;
goto err_exit ;
}
if ( ( entry = ( popen_list * ) malloc ( sizeof ( popen_list ) ) ) = = NULL )
goto err_exit ;
/*
* Extract the command and args into a NULL terminated array .
*/
if ( ! ( argl = extract_args ( command ) ) )
goto err_exit ;
2000-05-02 06:23:41 +04:00
entry - > child_pid = sys_fork ( ) ;
2000-02-15 22:36:47 +03:00
if ( entry - > child_pid = = - 1 ) {
goto err_exit ;
}
if ( entry - > child_pid = = 0 ) {
/*
* Child !
*/
2000-04-16 15:00:21 +04:00
int child_std_end = STDOUT_FILENO ;
2000-02-15 22:36:47 +03:00
popen_list * p ;
close ( parent_end ) ;
if ( child_end ! = child_std_end ) {
dup2 ( child_end , child_std_end ) ;
close ( child_end ) ;
}
/*
* POSIX .2 : " popen() shall ensure that any streams from previous
* popen ( ) calls that remain open in the parent process are closed
* in the new child process . "
*/
for ( p = popen_chain ; p ; p = p - > next )
2000-04-16 15:00:21 +04:00
close ( p - > fd ) ;
2000-02-15 22:36:47 +03:00
execv ( argl [ 0 ] , argl ) ;
_exit ( 127 ) ;
}
/*
* Parent .
*/
close ( child_end ) ;
free ( ( char * ) argl ) ;
/* Link into popen_chain. */
entry - > next = popen_chain ;
popen_chain = entry ;
2000-04-16 15:00:21 +04:00
return entry - > fd ;
2000-02-15 22:36:47 +03:00
err_exit :
if ( entry )
free ( ( char * ) entry ) ;
if ( argl )
free ( ( char * ) argl ) ;
close ( pipe_fds [ 0 ] ) ;
close ( pipe_fds [ 1 ] ) ;
2000-04-16 15:00:21 +04:00
return - 1 ;
2000-02-15 22:36:47 +03:00
}
/**************************************************************************
Wrapper for pclose . Modified from the glibc sources .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2000-04-16 15:00:21 +04:00
int sys_pclose ( int fd )
2000-02-15 22:36:47 +03:00
{
int wstatus ;
popen_list * * ptr = & popen_chain ;
popen_list * entry = NULL ;
pid_t wait_pid ;
int status = - 1 ;
/* Unlink from popen_chain. */
for ( ; * ptr ! = NULL ; ptr = & ( * ptr ) - > next ) {
2000-04-16 15:00:21 +04:00
if ( ( * ptr ) - > fd = = fd ) {
2000-02-15 22:36:47 +03:00
entry = * ptr ;
* ptr = ( * ptr ) - > next ;
status = 0 ;
break ;
}
}
2000-04-16 15:00:21 +04:00
if ( status < 0 | | close ( entry - > fd ) < 0 )
2000-02-15 22:36:47 +03:00
return - 1 ;
/*
* As Samba is catching and eating child process
* exits we don ' t really care about the child exit
* code , a - 1 with errno = ECHILD will do fine for us .
*/
do {
wait_pid = sys_waitpid ( entry - > child_pid , & wstatus , 0 ) ;
} while ( wait_pid = = - 1 & & errno = = EINTR ) ;
free ( ( char * ) entry ) ;
if ( wait_pid = = - 1 )
return - 1 ;
return wstatus ;
}
2000-09-29 08:45:00 +04:00
# if GLIBC_HACK_FCNTL64
# include <asm/unistd.h>
/* this is a gross hack. 64 bit locking is completely screwed up on
i386 Linux in glibc 2.1 .95 ( which ships with RedHat 7.0 ) . This hack
" fixes " the problem with the current 2.4 .0 test kernels
*/
int fcntl64 ( int fd , int cmd , struct flock * lock )
{
return syscall ( __NR_fcntl64 , fd , cmd , lock ) ;
}
# endif /* HACK_FCNTL64 */