s4-dsdb: ensure that new partitions inherit any transaction

[Samba/nascimento.git] / examples / libsmbclient / smbwrapper / wrapper.c

/* 
   Unix SMB/Netbios implementation.
   Version 2.0
   SMB wrapper functions
   Copyright (C) Andrew Tridgell 1998
   Copyright (C) Derrell Lipman 2002-2005
   
   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 3 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, see <http://www.gnu.org/licenses/>.
*/

/*
 * This is a rewrite of the original wrapped.c file, using libdl to obtain
 * pointers into the C library rather than attempting to find undocumented
 * functions in the C library to call for native file access.  The problem
 * with the original implementation's paradigm is that samba manipulates
 * defines such that it gets the sizes of structures that it wants
 * (e.g. mapping 32-bit functions to 64-bit functions with their associated
 * 64-bit structure fields), but programs run under smbsh or using
 * smbwrapper.so were not necessarily compiled with the same flags.  As an
 * example of the problem, a program calling stat() passes a pointer to a
 * "struct stat" but the fields in that structure are different in samba than
 * they are in the calling program if the calling program was not compiled to
 * force stat() to be mapped to stat64().
 *
 * In this version, we provide an interface to each of the native functions,
 * not just the ones that samba is compiled to map to.  We obtain the function
 * pointers from the C library using dlsym(), and for native file operations,
 * directly call the same function that the calling application was
 * requesting.  Since the size of the calling application's structures vary
 * depending on what function was called, we use our own internal structures
 * for passing information to/from the SMB equivalent functions, and map them
 * back to the native structures before returning the result to the caller.
 *
 * This implementation was completed 25 December 2002.
 * Derrell Lipman
 */

/* We do not want auto munging of 32->64 bit names in this file (only) */
#undef _FILE_OFFSET_BITS
#undef _GNU_SOURCE

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <utime.h>
#include <stdio.h>
#include <dirent.h>
#include <signal.h>
#include <stdarg.h>
#include <string.h>
#ifdef __USE_GNU
# define SMBW_USE_GNU
#endif
#define __USE_GNU             /* need this to have RTLD_NEXT defined */
#include <dlfcn.h>
#ifndef SMBW_USE_GNU
# undef __USE_GNU
#endif
#include <errno.h>
#include "libsmbclient.h"
#include "bsd-strlfunc.h"
#include "wrapper.h"

/*
 * Debug bits:
 * 0x0 = none
 * 0x1 = display symbol definitions not found in C library
 * 0x2 = show wrapper functions being called
 * 0x4 = log to file SMBW_DEBUG_FILE instead of stderr
 */
#define SMBW_DEBUG      0x0
#define SMBW_DEBUG_FILE "/tmp/smbw.log"

int      smbw_debug = 0;

#if SMBW_DEBUG & 0x2
static int      debugFd = 2;
#endif

#ifndef ENOTSUP
#define ENOTSUP EOPNOTSUPP
#endif

/*
 * None of the methods of having the initialization function called
 * automatically upon shared library startup are effective in all situations.
 * We provide the "-init" parameter to the linker which is effective most of
 * the time, but fails for applications that provide their own shared
 * libraries with _init() functions (e.g. ps).  We can't use "-z initfirst"
 * because the environment isn't yet set up at that point, so we can't find
 * our shared memory identifier (see shared.c).  We therefore must resort to
 * this tried-and-true method of keeping an "initialized" flag.  We check it
 * prior to calling the initialize() function to save a function call (a slow
 * operation on x86).
 */
#if SMBW_DEBUG & 0x2
#  define check_init(buf)                                               \
        do {                                                            \
                int saved_errno = errno;                                \
                if (! initialized) initialize();                        \
                (* smbw_libc.write)(debugFd, "["buf"]", sizeof(buf)+1); \
                errno = saved_errno;                                    \
        } while (0)
#else
#  define check_init(buf)                               \
        do {                                            \
                if (! initialized) smbw_initialize();   \
        } while (0)
#endif

static void initialize(void);

static int initialized = 0;

SMBW_libc_pointers smbw_libc;

/*
 * A public entry point used by the "-init" option to the linker.
 */
void smbw_initialize(void)
{
        initialize();
}

static void initialize(void)
{
        int saved_errno;
#if SMBW_DEBUG & 0x1
        char *error;
#endif
        
        saved_errno = errno;
        
        if (initialized) {
                return;
        }
        initialized = 1;
        
#if SMBW_DEBUG & 0x1
# define GETSYM(symname, symstring)                                      \
        if ((smbw_libc.symname = dlsym(RTLD_NEXT, symstring)) == NULL) { \
                if (smbw_libc.write != NULL &&                           \
                    (error = dlerror()) != NULL) {                       \
                        (* smbw_libc.write)(1, error, strlen(error));    \
                        (* smbw_libc.write)(1, "\n", 1);                 \
                }                                                        \
        }
#else
# define GETSYM(symname, symstring)                     \
        smbw_libc.symname = dlsym(RTLD_NEXT, symstring);
#endif
        
        /*
         * Get pointers to each of the symbols we'll need, from the C library
         *
         * Some of these symbols may not be found in the C library.  That's
         * fine.  We declare all of them here, and if the C library supports
         * them, they may be called so we have the wrappers for them.  If the
         * C library doesn't support them, then the wrapper function will
         * never be called, and the null pointer will never be dereferenced.
         */
        GETSYM(write, "write"); /* first, to allow debugging */
        GETSYM(open, "open");
        GETSYM(_open, "_open");
        GETSYM(__open, "__open");
        GETSYM(open64, "open64");
        GETSYM(_open64, "_open64");
        GETSYM(__open64, "__open64");
        GETSYM(pread, "pread");
        GETSYM(pread64, "pread64");
        GETSYM(pwrite, "pwrite");
        GETSYM(pwrite64, "pwrite64");
        GETSYM(close, "close");
        GETSYM(__close, "__close");
        GETSYM(_close, "_close");
        GETSYM(fcntl, "fcntl");
        GETSYM(__fcntl, "__fcntl");
        GETSYM(_fcntl, "_fcntl");
        GETSYM(getdents, "getdents");
        GETSYM(__getdents, "__getdents");
        GETSYM(_getdents, "_getdents");
        GETSYM(getdents64, "getdents64");
        GETSYM(lseek, "lseek");
        GETSYM(__lseek, "__lseek");
        GETSYM(_lseek, "_lseek");
        GETSYM(lseek64, "lseek64");
        GETSYM(__lseek64, "__lseek64");
        GETSYM(_lseek64, "_lseek64");
        GETSYM(read, "read");
        GETSYM(__read, "__read");
        GETSYM(_read, "_read");
        GETSYM(__write, "__write");
        GETSYM(_write, "_write");
        GETSYM(access, "access");
        GETSYM(chmod, "chmod");
        GETSYM(fchmod, "fchmod");
        GETSYM(chown, "chown");
        GETSYM(fchown, "fchown");
        GETSYM(__xstat, "__xstat");
        GETSYM(getcwd, "getcwd");
        GETSYM(mkdir, "mkdir");
        GETSYM(__fxstat, "__fxstat");
        GETSYM(__lxstat, "__lxstat");
        GETSYM(stat, "stat");
        GETSYM(lstat, "lstat");
        GETSYM(fstat, "fstat");
        GETSYM(unlink, "unlink");
        GETSYM(utime, "utime");
        GETSYM(utimes, "utimes");
        GETSYM(readlink, "readlink");
        GETSYM(rename, "rename");
        GETSYM(rmdir, "rmdir");
        GETSYM(symlink, "symlink");
        GETSYM(dup, "dup");
        GETSYM(dup2, "dup2");
        GETSYM(opendir, "opendir");
        GETSYM(readdir, "readdir");
        GETSYM(closedir, "closedir");
        GETSYM(telldir, "telldir");
        GETSYM(seekdir, "seekdir");
        GETSYM(creat, "creat");
        GETSYM(creat64, "creat64");
        GETSYM(__xstat64, "__xstat64");
        GETSYM(stat64, "stat64");
        GETSYM(__fxstat64, "__fxstat64");
        GETSYM(fstat64, "fstat64");
        GETSYM(__lxstat64, "__lxstat64");
        GETSYM(lstat64, "lstat64");
        GETSYM(_llseek, "_llseek");
        GETSYM(readdir64, "readdir64");
        GETSYM(readdir_r, "readdir_r");
        GETSYM(readdir64_r, "readdir64_r");
        GETSYM(setxattr, "setxattr");
        GETSYM(lsetxattr, "lsetxattr");
        GETSYM(fsetxattr, "fsetxattr");
        GETSYM(getxattr, "getxattr");
        GETSYM(lgetxattr, "lgetxattr");
        GETSYM(fgetxattr, "fgetxattr");
        GETSYM(removexattr, "removexattr");
        GETSYM(lremovexattr, "lremovexattr");
        GETSYM(fremovexattr, "fremovexattr");
        GETSYM(listxattr, "listxattr");
        GETSYM(llistxattr, "llistxattr");
        GETSYM(flistxattr, "flistxattr");
        GETSYM(chdir, "chdir");
        GETSYM(fchdir, "fchdir");
        GETSYM(fork, "fork");
        GETSYM(select, "select");
        GETSYM(_select, "_select");
        GETSYM(__select, "__select");
        
#if SMBW_DEBUG & 4
        {
                if ((debugFd =
                     open(SMBW_DEBUG_FILE, O_WRONLY | O_CREAT | O_APPEND)) < 0)
                {
#               define SMBW_MESSAGE    "Could not create " SMBW_DEBUG_FILE "\n" 
                        (* smbw_libc.write)(1, SMBW_MESSAGE, sizeof(SMBW_MESSAGE));
#               undef SMBW_MESSAGE
                        exit(1);
                }
        }
#endif
        
        errno = saved_errno;
}

/**
 ** Static Functions
 **/

static void stat_convert(struct SMBW_stat *src, struct stat *dest)
{
        memset(dest, '\0', sizeof(*dest));
        dest->st_size = src->s_size;
        dest->st_mode = src->s_mode;
        dest->st_ino = src->s_ino;
        dest->st_dev = src->s_dev;
        dest->st_rdev = src->s_rdev;
        dest->st_nlink = src->s_nlink;
        dest->st_uid = src->s_uid;
        dest->st_gid = src->s_gid;
        dest->st_atime = src->s_atime;
        dest->st_mtime = src->s_mtime;
        dest->st_ctime = src->s_ctime;
        dest->st_blksize = src->s_blksize;
        dest->st_blocks = src->s_blocks;
}

static void stat64_convert(struct SMBW_stat *src, struct stat64 *dest)
{
        memset(dest, '\0', sizeof(*dest));
        dest->st_size = src->s_size;
        dest->st_mode = src->s_mode;
        dest->st_ino = src->s_ino;
        dest->st_dev = src->s_dev;
        dest->st_rdev = src->s_rdev;
        dest->st_nlink = src->s_nlink;
        dest->st_uid = src->s_uid;
        dest->st_gid = src->s_gid;
        dest->st_atime = src->s_atime;
        dest->st_mtime = src->s_mtime;
        dest->st_ctime = src->s_ctime;
        dest->st_blksize = src->s_blksize;
        dest->st_blocks = src->s_blocks;
}

static void dirent_convert(struct SMBW_dirent *src, struct dirent *dest)
{
        char *p;
        
        memset(dest, '\0', sizeof(*dest));
        dest->d_ino = src->d_ino;
        dest->d_off = src->d_off;
        
        switch(src->d_type)
        {
        case SMBC_WORKGROUP:
        case SMBC_SERVER:
        case SMBC_FILE_SHARE:
        case SMBC_DIR:
                dest->d_type = DT_DIR;
                break;
                
        case SMBC_FILE:
                dest->d_type = DT_REG;
                break;
                
        case SMBC_PRINTER_SHARE:
                dest->d_type = DT_CHR;
                break;
                
        case SMBC_COMMS_SHARE:
                dest->d_type = DT_SOCK;
                break;
                
        case SMBC_IPC_SHARE:
                dest->d_type = DT_FIFO;
                break;
                
        case SMBC_LINK:
                dest->d_type = DT_LNK;
                break;
        }
        
        dest->d_reclen = src->d_reclen;
        smbw_strlcpy(dest->d_name, src->d_name, sizeof(dest->d_name));
        p = dest->d_name + strlen(dest->d_name) + 1;
        smbw_strlcpy(p,
                     src->d_comment,
                     sizeof(dest->d_name) - (p - dest->d_name));
}

static void dirent64_convert(struct SMBW_dirent *src, struct dirent64 *dest)
{
        char *p;
        
        memset(dest, '\0', sizeof(*dest));
        dest->d_ino = src->d_ino;
        dest->d_off = src->d_off;
        
        switch(src->d_type)
        {
        case SMBC_WORKGROUP:
        case SMBC_SERVER:
        case SMBC_FILE_SHARE:
        case SMBC_DIR:
                dest->d_type = DT_DIR;
                break;
                
        case SMBC_FILE:
                dest->d_type = DT_REG;
                break;
                
        case SMBC_PRINTER_SHARE:
                dest->d_type = DT_CHR;
                break;
                
        case SMBC_COMMS_SHARE:
                dest->d_type = DT_SOCK;
                break;
                
        case SMBC_IPC_SHARE:
                dest->d_type = DT_FIFO;
                break;
                
        case SMBC_LINK:
                dest->d_type = DT_LNK;
                break;
        }
        
        dest->d_reclen = src->d_reclen;
        smbw_strlcpy(dest->d_name, src->d_name, sizeof(dest->d_name));
        p = dest->d_name + strlen(dest->d_name) + 1;
        smbw_strlcpy(p,
                     src->d_comment,
                     sizeof(dest->d_name) - (p - dest->d_name));
}

static int openx(char *name, int flags, mode_t mode, int (* f)(char *, int, mode_t))
{
        if (smbw_path(name)) {
                return smbw_open(name, flags, mode);
        }
        
        return (* f)(name, flags, mode);
}

static int closex(int fd, int (* f)(int fd))
{
        if (smbw_fd(fd)) {
                return smbw_close(fd);
        }
        
        return (* f)(fd);
}

static int fcntlx(int fd, int cmd, long arg, int (* f)(int, int, long))
{
        if (smbw_fd(fd)) {
                return smbw_fcntl(fd, cmd, arg);
        }
        
        return (* f)(fd, cmd, arg);
}

static int getdentsx(int fd, struct dirent *external, unsigned int count, int (* f)(int, struct dirent *, unsigned int))
{
        if (smbw_fd(fd)) {
                int i;
                int internal_count;
                struct SMBW_dirent *internal;
                int ret;
                int n;
                
                /*
                 * LIMITATION: If they pass a count which is not a multiple of
                 * the size of struct dirent, they will not get a partial
                 * structure; we ignore the excess count.
                 */
                n = (count / sizeof(struct dirent));
                
                internal_count = sizeof(struct SMBW_dirent) * n;
                internal = malloc(internal_count);
                if (internal == NULL) {
                        errno = ENOMEM;
                        return -1;
                }
                ret = smbw_getdents(fd, internal, internal_count);
                if (ret <= 0)
                        return ret;
                
                ret = sizeof(struct dirent) * n;
                
                for (i = 0; i < n; i++)
                        dirent_convert(&internal[i], &external[i]);
                
                return ret;
        }
        
        return (* f)(fd, external, count);
}

static off_t lseekx(int fd,
                    off_t offset,
                    int whence,
                    off_t (* f)(int, off_t, int))
{
        off_t           ret;
        
        /*
         * We have left the definitions of the smbw_ functions undefined,
         * because types such as off_t can differ in meaning betweent his
         * function and smbw.c et al.  Functions that return other than an
         * integer value, however, MUST have their return value defined.
         */
        off64_t         smbw_lseek();
        
        if (smbw_fd(fd)) {
                return (off_t) smbw_lseek(fd, offset, whence);
        }
        
        ret = (* f)(fd, offset, whence);
        if (smbw_debug)
        {
                printf("lseekx(%d, 0x%llx) returned 0x%llx\n",
                       fd,
                       (unsigned long long) offset,
                       (unsigned long long) ret);
        }
        return ret;
}

static off64_t lseek64x(int fd,
                        off64_t offset,
                        int whence,
                        off64_t (* f)(int, off64_t, int))
{
        off64_t         ret;
        
        /*
         * We have left the definitions of the smbw_ functions undefined,
         * because types such as off_t can differ in meaning betweent his
         * function and smbw.c et al.  Functions that return other than an
         * integer value, however, MUST have their return value defined.
         */
        off64_t         smbw_lseek();
        
        if (smbw_fd(fd))
                ret = smbw_lseek(fd, offset, whence);
        else
                ret = (* f)(fd, offset, whence);
        if (smbw_debug)
        {
                printf("lseek64x(%d, 0x%llx) returned 0x%llx\n",
                       fd,
                       (unsigned long long) offset,
                       (unsigned long long) ret);
        }
        return ret;
}

static ssize_t readx(int fd, void *buf, size_t count, ssize_t (* f)(int, void *, size_t))
{
        if (smbw_fd(fd)) {
                return smbw_read(fd, buf, count);
        }
        
        return (* f)(fd, buf, count);
}

static ssize_t writex(int fd, void *buf, size_t count, ssize_t (* f)(int, void *, size_t))
{
        if (smbw_fd(fd)) {
                return smbw_write(fd, buf, count);
        }
        
        return (* f)(fd, buf, count);
}


/**
 ** Wrapper Functions
 **/

int open(__const char *name, int flags, ...)
{
        va_list ap;
        mode_t mode;
        
        va_start(ap, flags);
        mode = va_arg(ap, mode_t);
        va_end(ap);
        
        check_init("open");
        
        return openx((char *) name, flags, mode, smbw_libc.open);
}

int _open(char *name, int flags, mode_t mode)
{
        check_init("open");
        
        return openx(name, flags, mode, smbw_libc._open);
}

int __open(char *name, int flags, mode_t mode)
{
        check_init("open");
        
        return openx(name, flags, mode, smbw_libc.__open);
}

int open64 (__const char *name, int flags, ...)
{
        va_list ap;
        mode_t mode;
        
        va_start(ap, flags);
        mode = va_arg(ap, mode_t);
        va_end(ap);
        
        check_init("open64");
        return openx((char *) name, flags, mode, smbw_libc.open64);
}

int _open64(char *name, int flags, mode_t mode)
{
        check_init("_open64");
        return openx(name, flags, mode, smbw_libc._open64);
}

int __open64(char *name, int flags, mode_t mode)
{
        check_init("__open64");
        return openx(name, flags, mode, smbw_libc.__open64);
}

ssize_t pread(int fd, void *buf, size_t size, off_t ofs)
{
        check_init("pread");
        
        if (smbw_fd(fd)) {
                return smbw_pread(fd, buf, size, ofs);
        }
        
        return (* smbw_libc.pread)(fd, buf, size, ofs);
}

ssize_t pread64(int fd, void *buf, size_t size, off64_t ofs)
{
        check_init("pread64");
        
        if (smbw_fd(fd)) {
                return smbw_pread(fd, buf, size, (off_t) ofs);
        }
        
        return (* smbw_libc.pread64)(fd, buf, size, ofs);
}

ssize_t pwrite(int fd, const void *buf, size_t size, off_t ofs)
{
        check_init("pwrite");
        
        if (smbw_fd(fd)) {
                return smbw_pwrite(fd, (void *) buf, size, ofs);
        }
        
        return (* smbw_libc.pwrite)(fd, (void *) buf, size, ofs);
}

ssize_t pwrite64(int fd,  const void *buf, size_t size, off64_t ofs)
{
        check_init("pwrite64");
        
        if (smbw_fd(fd)) {
                return smbw_pwrite(fd, (void *) buf, size, (off_t) ofs);
        }
        
        return (* smbw_libc.pwrite64)(fd, (void *) buf, size, ofs);
}

int chdir(const char *name)
{
        check_init("chdir");
        return smbw_chdir((char *) name);;
}

int __chdir(char *name)
{
        check_init("__chdir");
        return smbw_chdir(name);
}

int _chdir(char *name)
{
        check_init("_chdir");
        return smbw_chdir(name);
}

int close(int fd)
{
        check_init("close");
        return closex(fd, smbw_libc.close);
}

int __close(int fd)
{
        check_init("__close");
        return closex(fd, smbw_libc.__close);
}

int _close(int fd)
{
        check_init("_close");
        return closex(fd, smbw_libc._close);
}

int fchdir(int fd)
{
        check_init("fchdir");
        return smbw_fchdir(fd);
}

int __fchdir(int fd)
{
        check_init("__fchdir");
        return fchdir(fd);
}

int _fchdir(int fd)
{
        check_init("_fchdir");
        return fchdir(fd);
}

int fcntl (int fd, int cmd, ...)
{
        va_list ap;
        long arg;
        
        va_start(ap, cmd);
        arg = va_arg(ap, long);
        va_end(ap);
        
        check_init("fcntl");
        return fcntlx(fd, cmd, arg, smbw_libc.fcntl);
}

int __fcntl(int fd, int cmd, ...)
{
        va_list ap;
        long arg;
        
        va_start(ap, cmd);
        arg = va_arg(ap, long);
        va_end(ap);
        
        check_init("__fcntl");
        return fcntlx(fd, cmd, arg, smbw_libc.__fcntl);
}

int _fcntl(int fd, int cmd, ...)
{
        va_list ap;
        long arg;
        
        va_start(ap, cmd);
        arg = va_arg(ap, long);
        va_end(ap);
        
        check_init("_fcntl");
        return fcntlx(fd, cmd, arg, smbw_libc._fcntl);
}

int getdents(int fd, struct dirent *dirp, unsigned int count)
{
        check_init("getdents");
        return getdentsx(fd, dirp, count, smbw_libc.getdents);
}

int __getdents(int fd, struct dirent *dirp, unsigned int count)
{
        check_init("__getdents");
        return getdentsx(fd, dirp, count, smbw_libc.__getdents);
}

int _getdents(int fd, struct dirent *dirp, unsigned int count)
{
        check_init("_getdents");
        return getdentsx(fd, dirp, count, smbw_libc._getdents);
}

int getdents64(int fd, struct dirent64 *external, unsigned int count)
{
        check_init("getdents64");
        if (smbw_fd(fd)) {
                int i;
                struct SMBW_dirent *internal;
                int ret;
                int n;
                
                /*
                 * LIMITATION: If they pass a count which is not a multiple of
                 * the size of struct dirent, they will not get a partial
                 * structure; we ignore the excess count.
                 */
                n = (count / sizeof(struct dirent64));
                
                internal = malloc(sizeof(struct SMBW_dirent) * n);
                if (internal == NULL) {
                        errno = ENOMEM;
                        return -1;
                }
                ret = smbw_getdents(fd, internal, count);
                if (ret <= 0)
                        return ret;
                
                ret = sizeof(struct dirent) * count;
                
                for (i = 0; count; i++, count--)
                        dirent64_convert(&internal[i], &external[i]);
                
                return ret;
        }
        
        return (* smbw_libc.getdents64)(fd, external, count);
}

off_t lseek(int fd, off_t offset, int whence)
{
        off_t           ret;
        check_init("lseek");
        ret = lseekx(fd, offset, whence, smbw_libc.lseek);
        if (smbw_debug)
        {
                printf("lseek(%d, 0x%llx) returned 0x%llx\n",
                       fd,
                       (unsigned long long) offset,
                       (unsigned long long) ret);
        }
        return ret;
}

off_t __lseek(int fd, off_t offset, int whence)
{
        off_t           ret;
        check_init("__lseek");
        ret = lseekx(fd, offset, whence, smbw_libc.__lseek);
        if (smbw_debug)
        {
                printf("__lseek(%d, 0x%llx) returned 0x%llx\n",
                       fd,
                       (unsigned long long) offset,
                       (unsigned long long) ret);
        }
        return ret;
}

off_t _lseek(int fd, off_t offset, int whence)
{
        off_t           ret;
        check_init("_lseek");
        ret = lseekx(fd, offset, whence, smbw_libc._lseek);
        if (smbw_debug)
        {
                printf("_lseek(%d, 0x%llx) returned 0x%llx\n",
                       fd,
                       (unsigned long long) offset,
                       (unsigned long long) ret);
        }
        return ret;
}

off64_t lseek64(int fd, off64_t offset, int whence)
{
        off64_t         ret;
        check_init("lseek64");
        ret = lseek64x(fd, offset, whence, smbw_libc.lseek64);
        if (smbw_debug)
        {
                printf("lseek64(%d, 0x%llx) returned 0x%llx\n",
                       fd,
                       (unsigned long long) offset,
                       (unsigned long long) ret);
        }
        return ret;
}

off64_t __lseek64(int fd, off64_t offset, int whence)
{
        check_init("__lseek64");
        return lseek64x(fd, offset, whence, smbw_libc.__lseek64);
}

off64_t _lseek64(int fd, off64_t offset, int whence)
{
        off64_t         ret;
        check_init("_lseek64");
        ret = lseek64x(fd, offset, whence, smbw_libc._lseek64);
        if (smbw_debug)
        {
                printf("_lseek64(%d, 0x%llx) returned 0x%llx\n",
                       fd,
                       (unsigned long long) offset,
                       (unsigned long long) ret);
        }
        return ret;
}

ssize_t read(int fd, void *buf, size_t count)
{
        check_init("read");
        return readx(fd, buf, count, smbw_libc.read);
}

ssize_t __read(int fd, void *buf, size_t count)
{
        check_init("__read");
        return readx(fd, buf, count, smbw_libc.__read);
}

ssize_t _read(int fd, void *buf, size_t count)
{
        check_init("_read");
        return readx(fd, buf, count, smbw_libc._read);
}

ssize_t write(int fd, const void *buf, size_t count)
{
        check_init("write");
        return writex(fd, (void *) buf, count, smbw_libc.write);
}

ssize_t __write(int fd, const void *buf, size_t count)
{
        check_init("__write");
        return writex(fd, (void *) buf, count, smbw_libc.__write);
}

ssize_t _write(int fd, const void *buf, size_t count)
{
        check_init("_write");
        return writex(fd, (void *) buf, count, smbw_libc._write);
}

int access(const char *name, int mode)
{
        check_init("access");
        
        if (smbw_path((char *) name)) {
                return smbw_access((char *) name, mode);
        }
        
        return (* smbw_libc.access)((char *) name, mode);
}

int chmod(const char *name, mode_t mode)
{
        check_init("chmod");
        
        if (smbw_path((char *) name)) {
                return smbw_chmod((char *) name, mode);
        }
        
        return (* smbw_libc.chmod)((char *) name, mode);
}

int fchmod(int fd, mode_t mode)
{
        check_init("fchmod");
        
        if (smbw_fd(fd)) {
                /* Not yet implemented in libsmbclient */
                return ENOTSUP;
        }
        
        return (* smbw_libc.fchmod)(fd, mode);
}

int chown(const char *name, uid_t owner, gid_t group)
{
        check_init("chown");
        
        if (smbw_path((char *) name)) {
                return smbw_chown((char *) name, owner, group);
        }
        
        return (* smbw_libc.chown)((char *) name, owner, group);
}

int fchown(int fd, uid_t owner, gid_t group)
{
        check_init("fchown");
        
        if (smbw_fd(fd)) {
                /* Not yet implemented in libsmbclient */
                return ENOTSUP;
        }
        
        return (* smbw_libc.fchown)(fd, owner, group);
}

char *getcwd(char *buf, size_t size)
{
        check_init("getcwd");
        return (char *)smbw_getcwd(buf, size);
}

int mkdir(const char *name, mode_t mode)
{
        check_init("mkdir");
        
        if (smbw_path((char *) name)) {
                return smbw_mkdir((char *) name, mode);
        }
        
        return (* smbw_libc.mkdir)((char *) name, mode);
}

int __fxstat(int vers, int fd, struct stat *st)
{
        check_init("__fxstat");
        
        if (smbw_fd(fd)) {
                struct SMBW_stat statbuf;
                int ret = smbw_fstat(fd, &statbuf);
                stat_convert(&statbuf, st);
                return ret;
        }
        
        return (* smbw_libc.__fxstat)(vers, fd, st);
}

int __xstat(int vers, const char *name, struct stat *st)
{
        check_init("__xstat");
        
        if (smbw_path((char *) name)) {
                struct SMBW_stat statbuf;
                int ret = smbw_stat((char *) name, &statbuf);
                stat_convert(&statbuf, st);
                return ret;
        }
        
        return (* smbw_libc.__xstat)(vers, (char *) name, st);
}

int __lxstat(int vers, const char *name, struct stat *st)
{
        check_init("__lxstat");
        
        if (smbw_path((char *) name)) {
                struct SMBW_stat statbuf;
                int ret = smbw_stat((char *) name, &statbuf);
                stat_convert(&statbuf, st);
                return ret;
        }
        
        return (* smbw_libc.__lxstat)(vers, (char *) name, st);
}

int stat(const char *name, struct stat *st)
{
        check_init("stat");
        
        if (smbw_path((char *) name)) {
                struct SMBW_stat statbuf;
                int ret = smbw_stat((char *) name, &statbuf);
                stat_convert(&statbuf, st);
                return ret;
        }
        
        return (* smbw_libc.stat)((char *) name, st);
}

int lstat(const char *name, struct stat *st)
{
        check_init("lstat");
        
        if (smbw_path((char *) name)) {
                struct SMBW_stat statbuf;
                int ret = smbw_stat((char *) name, &statbuf);
                stat_convert(&statbuf, st);
                return ret;
        }
        
        return (* smbw_libc.lstat)((char *) name, st);
}

int fstat(int fd, struct stat *st)
{
        check_init("fstat");
        
        if (smbw_fd(fd)) {
                struct SMBW_stat statbuf;
                int ret = smbw_fstat(fd, &statbuf);
                stat_convert(&statbuf, st);
                return ret;
        }
        
        return (* smbw_libc.fstat)(fd, st);
}

int unlink(const char *name)
{
        check_init("unlink");
        
        if (smbw_path((char *) name)) {
                return smbw_unlink((char *) name);
        }
        
        return (* smbw_libc.unlink)((char *) name);
}

int utime(const char *name, const struct utimbuf *tvp)
{
        check_init("utime");
        
        if (smbw_path(name)) {
                return smbw_utime(name, (struct utimbuf *) tvp);
        }
        
        return (* smbw_libc.utime)((char *) name, (struct utimbuf *) tvp);
}

int utimes(const char *name, const struct timeval *tvp)
{
        check_init("utimes");
        
        if (smbw_path(name)) {
                return smbw_utimes(name, (struct timeval *) tvp);
        }
        
        return (* smbw_libc.utimes)((char *) name, (struct timeval *) tvp);
}

ssize_t readlink(const char *path, char *buf, size_t bufsize)
{
        check_init("readlink");
        
        if (smbw_path((char *) path)) {
                return smbw_readlink(path, (char *) buf, bufsize);
        }
        
        return (* smbw_libc.readlink)((char *) path, buf, bufsize);
}

int rename(const char *oldname, const char *newname)
{
        int p1, p2;
        
        check_init("rename");
        
        p1 = smbw_path((char *) oldname); 
        p2 = smbw_path((char *) newname); 
        if (p1 ^ p2) {
                /* can't cross filesystem boundaries */
                errno = EXDEV;
                return -1;
        }
        if (p1 && p2) {
                return smbw_rename((char *) oldname, (char *) newname);
        }
        
        return (* smbw_libc.rename)((char *) oldname, (char *) newname);
}

int rmdir(const char *name)
{
        check_init("rmdir");
        
        if (smbw_path((char *) name)) {
                return smbw_rmdir((char *) name);
        }
        
        return (* smbw_libc.rmdir)((char *) name);
}

int symlink(const char *topath, const char *frompath)
{
        int p1, p2;
        
        check_init("symlink");
        
        p1 = smbw_path((char *) topath); 
        p2 = smbw_path((char *) frompath); 
        if (p1 || p2) {
                /* can't handle symlinks */
                errno = EPERM;
                return -1;
        }
        
        return (* smbw_libc.symlink)((char *) topath, (char *) frompath);
}

int dup(int fd)
{
        check_init("dup");
        
        if (smbw_fd(fd)) {
                return smbw_dup(fd);
        }
        
        return (* smbw_libc.dup)(fd);
}

int dup2(int oldfd, int newfd)
{
        check_init("dup2");
        
        if (smbw_fd(newfd)) {
                (* smbw_libc.close)(newfd);
        }
        
        if (smbw_fd(oldfd)) {
                return smbw_dup2(oldfd, newfd);
        }
        
        return (* smbw_libc.dup2)(oldfd, newfd);
}


DIR *opendir(const char *name)
{
        check_init("opendir");
        
        if (smbw_path((char *) name)) {
                return (void *)smbw_opendir((char *) name);
        }
        
        return (* smbw_libc.opendir)((char *) name);
}

struct dirent *readdir(DIR *dir)
{
        check_init("readdir");
        
        if (smbw_dirp(dir)) {
                static struct dirent external;
                struct SMBW_dirent * internal = (void *)smbw_readdir(dir);
                if (internal != NULL) {
                        dirent_convert(internal, &external);
                        return &external;
                }
                return NULL;
        }
        return (* smbw_libc.readdir)(dir);
}

int closedir(DIR *dir)
{
        check_init("closedir");
        
        if (smbw_dirp(dir)) {
                return smbw_closedir(dir);
        }
        
        return (* smbw_libc.closedir)(dir);
}

long telldir(DIR *dir)
{
        check_init("telldir");
        
        if (smbw_dirp(dir)) {
                return (long) smbw_telldir(dir);
        }
        
        return (* smbw_libc.telldir)(dir);
}

void seekdir(DIR *dir, long offset)
{
        check_init("seekdir");
        
        if (smbw_dirp(dir)) {
                smbw_seekdir(dir, (long long) offset);
                return;
        }
        
        (* smbw_libc.seekdir)(dir, offset);
}

int creat(const char *path, mode_t mode)
{
        extern int creat_bits;
        
        check_init("creat");
        return openx((char *) path, creat_bits, mode, smbw_libc.open);
}

int creat64(const char *path, mode_t mode)
{
        extern int creat_bits;
        
        check_init("creat64");
        return openx((char *) path, creat_bits, mode, smbw_libc.open64);
}

int __xstat64 (int ver, const char *name, struct stat64 *st64)
{
        check_init("__xstat64");
        
        if (smbw_path((char *) name)) {
                struct SMBW_stat statbuf;
                int ret = smbw_stat((char *) name, &statbuf);
                stat64_convert(&statbuf, st64);
                return ret;
        }
        
        return (* smbw_libc.__xstat64)(ver, (char *) name, st64);
}

int stat64(const char *name, struct stat64 *st64)
{
        check_init("stat64");
        
        if (smbw_path((char *) name)) {
                struct SMBW_stat statbuf;
                int ret = smbw_stat((char *) name, &statbuf);
                stat64_convert(&statbuf, st64);
                return ret;
        }
        
        return (* smbw_libc.stat64)((char *) name, st64);
}

int __fxstat64(int ver, int fd, struct stat64 *st64)
{
        check_init("__fxstat64");
        
        if (smbw_fd(fd)) {
                struct SMBW_stat statbuf;
                int ret = smbw_fstat(fd, &statbuf);
                stat64_convert(&statbuf, st64);
                return ret;
        }
        
        return (* smbw_libc.__fxstat64)(ver, fd, st64);
}

int fstat64(int fd, struct stat64 *st64)
{
        check_init("fstat64");
        
        if (smbw_fd(fd)) {
                struct SMBW_stat statbuf;
                int ret = smbw_fstat(fd, &statbuf);
                stat64_convert(&statbuf, st64);
                return ret;
        }
        
        return (* smbw_libc.fstat64)(fd, st64);
}

int __lxstat64(int ver, const char *name, struct stat64 *st64)
{
        check_init("__lxstat64");
        
        if (smbw_path((char *) name)) {
                struct SMBW_stat statbuf;
                int ret = smbw_stat(name, &statbuf);
                stat64_convert(&statbuf, st64);
                return ret;
        }
        
        return (* smbw_libc.__lxstat64)(ver, (char *) name, st64);
}

int lstat64(const char *name, struct stat64 *st64)
{
        check_init("lstat64");
        
        if (smbw_path((char *) name)) {
                struct SMBW_stat statbuf;
                int ret = smbw_stat((char *) name, &statbuf);
                stat64_convert(&statbuf, st64);
                return ret;
        }
        
        return (* smbw_libc.lstat64)((char *) name, st64);
}

int _llseek(unsigned int fd,  unsigned  long  offset_high, unsigned  long  offset_low,  loff_t  *result, unsigned int whence)
{
        check_init("_llseek");
        
        if (smbw_fd(fd)) {
                *result = lseek(fd, offset_low, whence);
                return (*result < 0 ? -1 : 0);
        }
        
        return (* smbw_libc._llseek)(fd, offset_high, offset_low, result, whence);
}

struct dirent64 *readdir64(DIR *dir)
{
        check_init("readdir64");
        
        if (smbw_dirp(dir)) {
                static struct dirent64 external;
                struct SMBW_dirent * internal = (void *)smbw_readdir(dir);
                if (internal != NULL) {
                        dirent64_convert(internal, &external);
                        return &external;
                }
                return NULL;
        }
        
        return (* smbw_libc.readdir64)(dir);
}

int readdir_r(DIR *dir, struct dirent *external, struct dirent **result)
{
        check_init("readdir_r");
        
        if (smbw_dirp(dir)) {
                struct SMBW_dirent internal;
                int ret = smbw_readdir_r(dir, &internal, NULL);
                if (ret == 0) {
                        dirent_convert(&internal, external);
                        *result = external;
                }
                return ret;
        }
        
        return (* smbw_libc.readdir_r)(dir, external, result);
}

int readdir64_r(DIR *dir, struct dirent64 *external, struct dirent64 **result)
{
        check_init("readdir64_r");
        
        if (smbw_dirp(dir)) {
                struct SMBW_dirent internal;
                int ret = smbw_readdir_r(dir, &internal, NULL);
                if (ret == 0) {
                        dirent64_convert(&internal, external);
                        *result = external;
                }
                return ret;
        }
        
        return (* smbw_libc.readdir64_r)(dir, external, result);
}

int fork(void)
{
        check_init("fork");
        return smbw_fork();
}

int setxattr(const char *fname,
             const char *name,
             const void *value,
             size_t size,
             int flags)
{
        if (smbw_path(fname)) {
                return smbw_setxattr(fname, name, value, size, flags);
        }
        
        return (* smbw_libc.setxattr)(fname, name, value, size, flags);
}

int lsetxattr(const char *fname,
              const char *name,
              const void *value,
              size_t size,
              int flags)
{
        if (smbw_path(fname)) {
                return smbw_lsetxattr(fname, name, value, size, flags);
        }
        
        return (* smbw_libc.lsetxattr)(fname, name, value, size, flags);
}

int fsetxattr(int fd,
              const char *name,
              const void *value,
              size_t size,
              int flags)
{
        if (smbw_fd(fd)) {
                return smbw_fsetxattr(fd, name, value, size, flags);
        }
        
        return (* smbw_libc.fsetxattr)(fd, name, value, size, flags);
}

int getxattr(const char *fname,
             const char *name,
             const void *value,
             size_t size)
{
        if (smbw_path(fname)) {
                return smbw_getxattr(fname, name, value, size);
        }
        
        return (* smbw_libc.getxattr)(fname, name, value, size);
}

int lgetxattr(const char *fname,
              const char *name,
              const void *value,
              size_t size)
{
        if (smbw_path(fname)) {
                return smbw_lgetxattr(fname, name, value, size);
        }
        
        return (* smbw_libc.lgetxattr)(fname, name, value, size);
}

int fgetxattr(int fd,
              const char *name,
              const void *value,
              size_t size)
{
        if (smbw_fd(fd)) {
                return smbw_fgetxattr(fd, name, value, size);
        }
        
        return (* smbw_libc.fgetxattr)(fd, name, value, size);
}

int removexattr(const char *fname,
                const char *name)
{
        if (smbw_path(fname)) {
                return smbw_removexattr(fname, name);
        }
        
        return (* smbw_libc.removexattr)(fname, name);
}

int lremovexattr(const char *fname,
                 const char *name)
{
        if (smbw_path(fname)) {
                return smbw_lremovexattr(fname, name);
        }
        
        return (* smbw_libc.lremovexattr)(fname, name);
}

int fremovexattr(int fd,
                 const char *name)
{
        if (smbw_fd(fd)) {
                return smbw_fremovexattr(fd, name);
        }
        
        return (* smbw_libc.fremovexattr)(fd, name);
}

int listxattr(const char *fname,
              char *list,
              size_t size)
{
        if (smbw_path(fname)) {
                return smbw_listxattr(fname, list, size);
        }
        
        return (* smbw_libc.listxattr)(fname, list, size);
}

int llistxattr(const char *fname,
               char *list,
               size_t size)
{
        if (smbw_path(fname)) {
                return smbw_llistxattr(fname, list, size);
        }
        
        return (* smbw_libc.llistxattr)(fname, list, size);
}

int flistxattr(int fd,
               char *list,
               size_t size)
{
        if (smbw_fd(fd)) {
                return smbw_flistxattr(fd, list, size);
        }
        
        return (* smbw_libc.flistxattr)(fd, list, size);
}


/*
 * We're ending up with a different implementation of malloc() with smbwrapper
 * than without it.  The one with it does not support returning a non-NULL
 * pointer from a call to malloc(0), and many apps depend on getting a valid
 * pointer when requesting zero length (e.g. df, emacs).
 *
 * Unfortunately, initializing the smbw_libc[] array via the dynamic link
 * library (libdl) requires malloc so we can't just do the same type of
 * mapping to the C library as we do with everything else.  We need to
 * implement a different way of allocating memory that ensures that the C
 * library version of malloc() gets used.  This is the only place where we
 * kludge the code to use an undocumented interface to the C library.
 *
 * If anyone can come up with a way to dynamically link to the C library
 * rather than using this undocumented interface, I'd sure love to hear about
 * it.  Better yet, if you can figure out where the alternate malloc()
 * functions are coming from and arrange for them not to be called, that would
 * be even better.  We should try to avoid wrapping functions that don't
 * really require it.
 */

void *malloc(size_t size)
{
        void *__libc_malloc(size_t size);
        return __libc_malloc(size);
}

void *calloc(size_t nmemb, size_t size)
{
        void *__libc_calloc(size_t nmemb, size_t size);
        return __libc_calloc(nmemb, size);
}

void *realloc(void *ptr, size_t size)
{
        void *__libc_realloc(void *ptr, size_t size);
        return __libc_realloc(ptr, size);
}

void free(void *ptr)
{
        static int      in_progress = 0;
        void __libc_free(void *ptr);
        
        if (in_progress) return;
        in_progress = 1;
        __libc_free(ptr);
        in_progress = 0;
}


#if 0                           /* SELECT */

static struct sigaction user_action[_NSIG];

static void
smbw_sigaction_handler(int signum,
                       siginfo_t *info,
                       void *context)
{
        /* Our entire purpose for trapping signals is to call this! */
        sys_select_signal();
        
        /* Call the user's handler */
        if (user_action[signum].sa_handler != SIG_IGN &&
            user_action[signum].sa_handler != SIG_DFL &&
            user_action[signum].sa_handler != SIG_ERR) {
                (* user_action[signum].sa_sigaction)(signum, info, context);
        }
}


/*
 * Every Samba signal handler must call sys_select_signal() to avoid a race
 * condition, so we'll take whatever signal handler is currently assigned,
 * call call sys_select_signal() in addition to their call.
 */
static int
do_select(int n,
          fd_set *readfds,
          fd_set *writefds,
          fd_set *exceptfds,
          struct timeval *timeout,
          int (* select_fn)(int n,
                            fd_set *readfds,
                            fd_set *writefds,
                            fd_set *exceptfds,
                            struct timeval *timeout))
{
        int i;
        int ret;
        int saved_errno;
        sigset_t sigset;
        struct sigaction new_action;
        
        saved_errno = errno;
        for (i=1; i<_NSIG; i++) {
                sigemptyset(&sigset);
                new_action.sa_mask = sigset;
                new_action.sa_flags = SA_SIGINFO;
                new_action.sa_sigaction = smbw_sigaction_handler;
                
                if (sigaction(i, &new_action, &user_action[i]) < 0) {
                        if (errno != EINVAL) {
                                return -1;
                        }
                }
        }
        errno = saved_errno;
        
        ret = (* select_fn)(n, readfds, writefds, exceptfds, timeout);
        saved_errno = errno;
        
        for (i=0; i<_NSIG; i++) {
                (void) sigaction(i, &user_action[i], NULL);
        }
        
        errno = saved_errno;
        return ret;
}

int
select(int n,
       fd_set *readfds,
       fd_set *writefds,
       fd_set *exceptfds,
       struct timeval *timeout)
{
        check_init("select");
        
        return do_select(n, readfds, writefds, exceptfds,
                         timeout, smbw_libc.select);
}

int
_select(int n,
        fd_set *readfds,
        fd_set *writefds,
        fd_set *exceptfds,
        struct timeval *timeout)
{
        check_init("_select");
        
        return do_select(n, readfds, writefds, exceptfds,
                         timeout, smbw_libc._select);
}

int
__select(int n,
         fd_set *readfds,
         fd_set *writefds,
         fd_set *exceptfds,
         struct timeval *timeout)
{
        check_init("__select");
        
        return do_select(n, readfds, writefds, exceptfds,
                         timeout, smbw_libc.__select);
}

#endif