wrapper.c

samba-3.0.22.tar.gz 编译smb服务器的源码

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