[PATCH & new files]: smbwrapper/smbsh for Linux
Derrell.Lipman at UnwiredUniverse.com
Derrell.Lipman at UnwiredUniverse.com
Fri Jan 10 00:19:08 GMT 2003
Here is a patch file and new files wrapper.c and wrapper.h (which replace
wrapped.c, realcalls.c, realcalls.h, and init.c). These new files go into the
smbwrapper directory.
Everything that I have tested seems to be working under this version of smbsh.
I have only one "kludge" here, which is that _something_ linked with smbsh
provides a malloc() other than the standard C library one. The alternative
malloc() routine returns NULL on a call to malloc(0), whereas the malloc()
function in the C library returns a valid pointer. A number of applications
routinely call malloc(0) and expect a non-NULL (i.e. valid) pointer to be
returned, so I had to implement a work-around for this. The work-around can
not use the same mechanism as all of the other wrapper functions. See the end
of wrapper.c for more explanation and what I consider to be a "kludge"
work-around. Otherwise, this seems to work well. Please let me know if you
find any problems.
Sorry about the long patch file. It's mostly due to the fact that I had to
regenerate proto.h.
The attached patch is against samba-2.2.3a from Debian/Woody prior to applying
any of the Debian patches. (This breaks the Debian patch for one of the
smbwrapper files: modifying BINDIR. That will have to be fixed in the Debian
patch file.)
** wrapper.c *****************************************************************
/*
Unix SMB/Netbios implementation.
Version 2.0
SMB wrapper functions
Copyright (C) Andrew Tridgell 1998
Copyright (C) Derrell Lipman 2002
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 02139, USA.
*/
/*
* 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
*/
/* Makefile defines these "for our benefit" but we don't want them defined */
#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 <stdarg.h>
#include <dlfcn.h>
#include <errno.h>
#include "wrapper.h"
/*
* Debug bits:
* 0x0 = none
* 0x1 = display symbol definitions not found in C library
* 0x2 = show wrapper functions being called
*/
#define SMBW_DEBUG 0x0
/*
* 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 { \
if (! initialized) smbw_initialize(); \
(* smbw_libc.write)(1, "["buf"]", sizeof(buf)+1); \
} while (0);
#else
# define check_init(buf) \
do { \
if (! initialized) 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)
{
void *lib = NULL;
char *error;
if (initialized)
return;
initialized = 1;
if ((lib = dlopen("/lib/libc.so.6", RTLD_NOW | RTLD_GLOBAL)) == NULL) {
exit(1);
}
#if SMBW_DEBUG & 0x1
# define GETSYM(symname, symstring) \
if ((smbw_libc.symname = dlsym(lib, 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(lib, 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.
*/
do {
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(read, "read");
GETSYM(__read, "__read");
GETSYM(_read, "_read");
GETSYM(__write, "__write");
GETSYM(_write, "_write");
GETSYM(access, "access");
GETSYM(chmod, "chmod");
GETSYM(chown, "chown");
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(chdir, "chdir");
GETSYM(fchdir, "fchdir");
GETSYM(fork, "fork");
} while (0);
dlclose(lib);
}
/**
** Static Functions
**/
static void stat_convert(struct SMBW_stat *src, struct stat *dest)
{
memset(dest, '\0', sizeof(*dest));
dest->st_size = src->st_size;
dest->st_mode = src->st_mode;
dest->st_ino = src->st_ino;
dest->st_dev = src->st_dev;
dest->st_rdev = src->st_rdev;
dest->st_nlink = src->st_nlink;
dest->st_uid = src->st_uid;
dest->st_gid = src->st_gid;
dest->st_atime = src->st_atime;
dest->st_mtime = src->st_mtime;
dest->st_ctime = src->st_ctime;
dest->st_blksize = src->st_blksize;
dest->st_blocks = src->st_blocks;
}
static void stat64_convert(struct SMBW_stat *src, struct stat64 *dest)
{
memset(dest, '\0', sizeof(*dest));
dest->st_size = src->st_size;
dest->st_mode = src->st_mode;
dest->st_ino = src->st_ino;
dest->st_dev = src->st_dev;
dest->st_rdev = src->st_rdev;
dest->st_nlink = src->st_nlink;
dest->st_uid = src->st_uid;
dest->st_gid = src->st_gid;
dest->st_atime = src->st_atime;
dest->st_mtime = src->st_mtime;
dest->st_ctime = src->st_ctime;
dest->st_blksize = src->st_blksize;
dest->st_blocks = src->st_blocks;
}
static void dirent_convert(struct SMBW_dirent *src, struct dirent *dest)
{
memset(dest, '\0', sizeof(*dest));
dest->d_ino = src->d_ino;
dest->d_off = src->d_off;
dest->d_type = src->d_type;
dest->d_reclen = src->d_reclen;
strncpy(dest->d_name, src->d_name, sizeof(dest->d_name));
}
static void dirent64_convert(struct SMBW_dirent *src, struct dirent64 *dest)
{
memset(dest, '\0', sizeof(*dest));
dest->d_ino = src->d_ino;
dest->d_off = src->d_off;
dest->d_type = src->d_type;
dest->d_reclen = src->d_reclen;
strncpy(dest->d_name, src->d_name, sizeof(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);
}
if (smbw_local_fd(fd)) {
errno = EBADF;
return -1;
}
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;
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 = 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--)
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))
{
if (smbw_fd(fd)) {
return smbw_lseek(fd, offset, whence);
}
return (* f)(fd, offset, whence);
}
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, 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, 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)
{
check_init("lseek");
return lseekx(fd, offset, whence, smbw_libc.lseek);
}
off_t __lseek(int fd, off_t offset, int whence)
{
check_init("__lseek");
return lseekx(fd, offset, whence, smbw_libc.__lseek);
}
off_t _lseek(int fd, off_t offset, int whence)
{
check_init("_lseek");
return lseekx(fd, offset, whence, smbw_libc._lseek);
}
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 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);
}
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, 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, tvp);
}
return (* smbw_libc.utimes)((char *) name, (struct timeval *) tvp);
}
int 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)) {
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 (off_t) 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();
}
/*
* 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 libarary 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, buat 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)
{
void __libc_free(void *ptr);
__libc_free(ptr);
}
** wrapper.h *****************************************************************
/*
Unix SMB/Netbios implementation.
Version 2.0
SMB wrapper functions
Copyright (C) Andrew Tridgell 1998
Copyright (C) Derrell Lipman 2002
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 02139, USA.
*/
/*
* 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
*/
#ifndef __WRAPPER_H__
#define __WRAPPER_H__
#define NO_ACL_WRAPPER
#define NO_FACL_WRAPPER
typedef struct SMBW_stat {
unsigned long st_dev; /* device */
unsigned long st_ino; /* inode */
unsigned long st_mode; /* protection */
unsigned long st_nlink; /* number of hard links */
unsigned long st_uid; /* user ID of owner */
unsigned long st_gid; /* group ID of owner */
unsigned long st_rdev; /* device type (if inode device) */
unsigned long long st_size; /* total size, in bytes */
unsigned long st_blksize; /* blocksize for filesystem I/O */
unsigned long st_blocks; /* number of blocks allocated */
unsigned long st_atime; /* time of last access */
unsigned long st_mtime; /* time of last modification */
unsigned long st_ctime; /* time of last change */
} SMBW_stat;
typedef struct SMBW_dirent {
unsigned long d_ino; /* inode number */
unsigned long long d_off; /* offset to the next dirent */
unsigned long d_reclen; /* length of this record */
unsigned long d_type; /* type of file */
char d_name[256]; /* filename */
} SMBW_dirent;
typedef struct SMBW_libc
{
/* write() is first, to allow debugging */
ssize_t (* write)(int fd, void *buf, size_t count);
int (* open)(char *name, int flags, mode_t mode);
int (* _open)(char *name, int flags, mode_t mode) ;
int (* __open)(char *name, int flags, mode_t mode) ;
int (* open64)(char *name, int flags, mode_t mode);
int (* _open64)(char *name, int flags, mode_t mode) ;
int (* __open64)(char *name, int flags, mode_t mode) ;
ssize_t (* pread)(int fd, void *buf, size_t size, off_t ofs);
ssize_t (* pread64)(int fd, void *buf, size_t size, off64_t ofs);
ssize_t (* pwrite)(int fd, void *buf, size_t size, off_t ofs);
ssize_t (* pwrite64)(int fd, void *buf, size_t size, off64_t ofs);
int (* close)(int fd);
int (* __close)(int fd);
int (* _close)(int fd);
int (* fcntl)(int fd, int cmd, long arg);
int (* __fcntl)(int fd, int cmd, long arg);
int (* _fcntl)(int fd, int cmd, long arg);
int (* getdents)(int fd, struct dirent *dirp, unsigned int count);
int (* __getdents)(int fd, struct dirent *dirp, unsigned int count);
int (* _getdents)(int fd, struct dirent *dirp, unsigned int count);
int (* getdents64)(int fd, struct dirent64 *dirp, unsigned int count);
off_t (* lseek)(int fd, off_t offset, int whence);
off_t (* __lseek)(int fd, off_t offset, int whence);
off_t (* _lseek)(int fd, off_t offset, int whence);
ssize_t (* read)(int fd, void *buf, size_t count);
ssize_t (* __read)(int fd, void *buf, size_t count);
ssize_t (* _read)(int fd, void *buf, size_t count);
ssize_t (* __write)(int fd, void *buf, size_t count);
ssize_t (* _write)(int fd, void *buf, size_t count);
int (* access)(char *name, int mode);
int (* chmod)(char *name, mode_t mode);
int (* chown)(char *name, uid_t owner, gid_t group);
int (* __xstat)(int vers, char *name, struct stat *st);
char * ( *getcwd)(char *buf, size_t size);
int (* mkdir)(char *name, mode_t mode);
int (* __fxstat)(int vers, int fd, struct stat *st);
int (* __lxstat)(int vers, char *name, struct stat *st);
int (* stat)(char *name, struct stat *st);
int (* lstat)(char *name, struct stat *st);
int (* fstat)(int fd, struct stat *st);
int (* unlink)(char *name);
int (* utime)(char *name, struct utimbuf *tvp);
int (* utimes)(char *name, struct timeval *tvp);
int (* readlink)(char *path, char *buf, size_t bufsize);
int (* rename)(char *oldname, char *newname);
int (* rmdir)(char *name);
int (* symlink)(char *topath, char *frompath);
int (* dup)(int fd);
int (* dup2)(int oldfd, int newfd);
DIR * (* opendir)(char *name);
struct dirent * (* readdir)(DIR *dir);
int (* closedir)(DIR *dir);
long (* telldir)(DIR *dir);
void (* seekdir)(DIR *dir, long offset);
int (* creat)(char *path, mode_t mode);
int (* creat64)(char *path, mode_t mode);
int (* __xstat64)(int ver, char *name, struct stat64 *st64);
int (* stat64)(char *name, struct stat64 *st64);
int (* __fxstat64)(int ver, int fd, struct stat64 *st64);
int (* fstat64)(int fd, struct stat64 *st64);
int (* __lxstat64)(int ver, char *name, struct stat64 *st64);
int (* lstat64)(char *name, struct stat64 *st64);
int (* _llseek)(unsigned int fd, unsigned long offset_high, unsigned long offset_low, loff_t *result, unsigned int whence);
struct dirent64 * (* readdir64)(DIR *dir);
int (* readdir_r)(DIR *dir, struct dirent *entry, struct dirent **result);
int (* readdir64_r)(DIR *dir, struct dirent64 *entry, struct dirent64 **result);
int (* chdir)(const char *path);
int (* fchdir)(int fd);
pid_t (* fork)(void);
} SMBW_libc_pointers;
extern SMBW_libc_pointers smbw_libc;
#endif /* __WRAPPER_H__ */
******************************************************************************
diff -r -u samba-2.2.3a.debian/source/Makefile.in samba-2.2.3a/source/Makefile.in
--- samba-2.2.3a.debian/source/Makefile.in Sat Feb 2 19:46:05 2002
+++ samba-2.2.3a/source/Makefile.in Wed Dec 25 15:45:44 2002
@@ -275,11 +275,11 @@
SMBW_OBJ = smbwrapper/smbw.o \
smbwrapper/smbw_dir.o smbwrapper/smbw_stat.o \
- smbwrapper/realcalls.o smbwrapper/shared.o \
+ smbwrapper/shared.o \
$(LIBSMB_OBJ) $(PARAM_OBJ) \
$(UBIQX_OBJ) $(LIB_OBJ)
-SMBWRAPPER_OBJ = $(SMBW_OBJ) smbwrapper/wrapped.o
+SMBWRAPPER_OBJ = $(SMBW_OBJ) smbwrapper/wrapper.o
LIBSMBCLIENT_OBJ = libsmb/libsmbclient.o $(LIB_OBJ) $(LIBSMB_OBJ) $(PARAM_OBJ) $(UBIQX_OBJ)
diff -r -u samba-2.2.3a.debian/source/include/proto.h samba-2.2.3a/source/include/proto.h
--- samba-2.2.3a.debian/source/include/proto.h Sat Feb 2 19:46:40 2002
+++ samba-2.2.3a/source/include/proto.h Wed Dec 25 16:18:25 2002
@@ -166,29 +166,595 @@
void CatchChild(void);
void CatchChildLeaveStatus(void);
-/*The following definitions come from libsmb/cliconnect.c */
+/*The following definitions come from lib/smbrun.c */
+
+int smbrun(char *cmd, int *outfd);
+
+/*The following definitions come from lib/snprintf.c */
+
+
+/*The following definitions come from lib/substitute.c */
+
+void standard_sub_basic(char *str);
+void standard_sub_advanced(int snum, char *user, char *connectpath, gid_t gid, char *str);
+void standard_sub_conn(connection_struct *conn, char *str);
+void standard_sub_home(int snum, char *user, char *str);
+void standard_sub_snum(int snum, char *str);
+void standard_sub_vuser(char *str, user_struct *vuser);
+void standard_sub_vsnum(char *str, user_struct *vuser, int snum);
+
+/*The following definitions come from lib/sysacls.c */
+
+int sys_acl_get_entry( SMB_ACL_T the_acl, int entry_id, SMB_ACL_ENTRY_T *entry_p);
+int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p);
+int sys_acl_get_permset( SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p);
+void *sys_acl_get_qualifier( SMB_ACL_ENTRY_T entry_d);
+SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type);
+SMB_ACL_T sys_acl_get_fd(int fd);
+int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset);
+int sys_acl_add_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
+int sys_acl_get_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
+char *sys_acl_to_text( SMB_ACL_T the_acl, ssize_t *plen);
+SMB_ACL_T sys_acl_init( int count);
+int sys_acl_create_entry( SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry);
+int sys_acl_set_tag_type( SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype);
+int sys_acl_set_qualifier( SMB_ACL_ENTRY_T entry, void *qual);
+int sys_acl_set_permset( SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset);
+int sys_acl_valid( SMB_ACL_T theacl );
+int sys_acl_set_file( const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl);
+int sys_acl_set_fd( int fd, SMB_ACL_T theacl);
+int sys_acl_delete_def_file(const char *name);
+int sys_acl_free_text(char *text);
+int sys_acl_free_acl(SMB_ACL_T the_acl) ;
+int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype);
+int sys_acl_get_entry( SMB_ACL_T the_acl, int entry_id, SMB_ACL_ENTRY_T *entry_p);
+int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p);
+int sys_acl_get_permset( SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p);
+void *sys_acl_get_qualifier( SMB_ACL_ENTRY_T entry_d);
+SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type);
+SMB_ACL_T sys_acl_get_fd(int fd);
+int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset);
+int sys_acl_add_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
+int sys_acl_get_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
+char *sys_acl_to_text( SMB_ACL_T the_acl, ssize_t *plen);
+SMB_ACL_T sys_acl_init( int count);
+int sys_acl_create_entry( SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry);
+int sys_acl_set_tag_type( SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype);
+int sys_acl_set_qualifier( SMB_ACL_ENTRY_T entry, void *qual);
+int sys_acl_set_permset( SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset);
+int sys_acl_valid( SMB_ACL_T theacl );
+int sys_acl_set_file( const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl);
+int sys_acl_set_fd( int fd, SMB_ACL_T theacl);
+int sys_acl_delete_def_file(const char *name);
+int sys_acl_free_text(char *text);
+int sys_acl_free_acl(SMB_ACL_T the_acl) ;
+int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype);
+int sys_acl_get_entry(SMB_ACL_T acl_d, int entry_id, SMB_ACL_ENTRY_T *entry_p);
+int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *type_p);
+int sys_acl_get_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p);
+void *sys_acl_get_qualifier(SMB_ACL_ENTRY_T entry_d);
+SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL_TYPE_T type);
+SMB_ACL_T sys_acl_get_fd(int fd);
+int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset_d);
+int sys_acl_add_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm);
+int sys_acl_get_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm);
+char *sys_acl_to_text(SMB_ACL_T acl_d, ssize_t *len_p);
+SMB_ACL_T sys_acl_init(int count);
+int sys_acl_create_entry(SMB_ACL_T *acl_p, SMB_ACL_ENTRY_T *entry_p);
+int sys_acl_set_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T tag_type);
+int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry_d, void *qual_p);
+int sys_acl_set_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T permset_d);
+int sys_acl_valid(SMB_ACL_T acl_d);
+int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d);
+int sys_acl_set_fd(int fd, SMB_ACL_T acl_d);
+int sys_acl_delete_def_file(const char *path);
+int sys_acl_free_text(char *text);
+int sys_acl_free_acl(SMB_ACL_T acl_d) ;
+int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype);
+int sys_acl_get_entry(SMB_ACL_T acl_d, int entry_id, SMB_ACL_ENTRY_T *entry_p);
+int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *type_p);
+int sys_acl_get_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p);
+void *sys_acl_get_qualifier(SMB_ACL_ENTRY_T entry_d);
+SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL_TYPE_T type);
+SMB_ACL_T sys_acl_get_fd(int fd);
+int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset_d);
+int sys_acl_add_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm);
+int sys_acl_get_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm);
+char *sys_acl_to_text(SMB_ACL_T acl_d, ssize_t *len_p);
+SMB_ACL_T sys_acl_init(int count);
+int sys_acl_create_entry(SMB_ACL_T *acl_p, SMB_ACL_ENTRY_T *entry_p);
+int sys_acl_set_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T tag_type);
+int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry_d, void *qual_p);
+int sys_acl_set_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T permset_d);
+int sys_acl_valid(SMB_ACL_T acl_d);
+int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d);
+int sys_acl_set_fd(int fd, SMB_ACL_T acl_d);
+int sys_acl_delete_def_file(const char *path);
+int sys_acl_free_text(char *text);
+int sys_acl_free_acl(SMB_ACL_T acl_d) ;
+int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype);
+int sys_acl_get_entry(SMB_ACL_T acl_d, int entry_id, SMB_ACL_ENTRY_T *entry_p);
+int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *type_p);
+int sys_acl_get_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p);
+void *sys_acl_get_qualifier(SMB_ACL_ENTRY_T entry_d);
+SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL_TYPE_T type);
+SMB_ACL_T sys_acl_get_fd(int fd);
+int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset_d);
+int sys_acl_add_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm);
+int sys_acl_get_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm);
+char *sys_acl_to_text(SMB_ACL_T acl_d, ssize_t *len_p);
+SMB_ACL_T sys_acl_init(int count);
+int sys_acl_create_entry(SMB_ACL_T *acl_p, SMB_ACL_ENTRY_T *entry_p);
+int sys_acl_set_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T tag_type);
+int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry_d, void *qual_p);
+int sys_acl_set_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T permset_d);
+int sys_acl_valid(SMB_ACL_T acl_d);
+int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d);
+int sys_acl_set_fd(int fd, SMB_ACL_T acl_d);
+int sys_acl_delete_def_file(const char *name);
+int sys_acl_free_text(char *text);
+int sys_acl_free_acl(SMB_ACL_T acl_d) ;
+int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype);
+int sys_acl_get_entry( SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p);
+int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p);
+int sys_acl_get_permset( SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p);
+void *sys_acl_get_qualifier( SMB_ACL_ENTRY_T entry_d);
+SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type);
+SMB_ACL_T sys_acl_get_fd(int fd);
+int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset);
+int sys_acl_add_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
+char *sys_acl_to_text( SMB_ACL_T theacl, ssize_t *plen);
+SMB_ACL_T sys_acl_init( int count);
+int sys_acl_create_entry( SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry);
+int sys_acl_set_tag_type( SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype);
+int sys_acl_set_qualifier( SMB_ACL_ENTRY_T entry, void *qual);
+int sys_acl_set_permset( SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset);
+int sys_acl_valid( SMB_ACL_T theacl );
+int sys_acl_set_file( const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl);
+int sys_acl_set_fd( int fd, SMB_ACL_T theacl);
+int sys_acl_delete_def_file(const char *name);
+int sys_acl_get_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
+int sys_acl_free_text(char *text);
+int sys_acl_free_acl(SMB_ACL_T posix_acl);
+int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype);
+int sys_acl_get_entry( SMB_ACL_T the_acl, int entry_id, SMB_ACL_ENTRY_T *entry_p);
+int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p);
+int sys_acl_get_permset( SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p);
+void *sys_acl_get_qualifier( SMB_ACL_ENTRY_T entry_d);
+SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type);
+SMB_ACL_T sys_acl_get_fd(int fd);
+int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset);
+int sys_acl_add_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
+int sys_acl_get_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
+char *sys_acl_to_text( SMB_ACL_T the_acl, ssize_t *plen);
+int sys_acl_free_text(char *text);
+SMB_ACL_T sys_acl_init( int count);
+int sys_acl_create_entry( SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry);
+int sys_acl_set_tag_type( SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype);
+int sys_acl_set_qualifier( SMB_ACL_ENTRY_T entry, void *qual);
+int sys_acl_set_permset( SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset);
+int sys_acl_valid( SMB_ACL_T theacl );
+int sys_acl_set_file( const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl);
+int sys_acl_set_fd( int fd, SMB_ACL_T theacl);
+int sys_acl_delete_def_file(const char *name);
+int sys_acl_free_acl(SMB_ACL_T the_acl) ;
+int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype);
+
+/*The following definitions come from lib/system.c */
+
+int sys_usleep(long usecs);
+int sys_stat(const char *fname,SMB_STRUCT_STAT *sbuf);
+int sys_fstat(int fd,SMB_STRUCT_STAT *sbuf);
+int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf);
+int sys_ftruncate(int fd, SMB_OFF_T offset);
+SMB_OFF_T sys_lseek(int fd, SMB_OFF_T offset, int whence);
+int sys_fseek(FILE *fp, SMB_OFF_T offset, int whence);
+SMB_OFF_T sys_ftell(FILE *fp);
+int sys_creat(const char *path, mode_t mode);
+int sys_open(const char *path, int oflag, mode_t mode);
+FILE *sys_fopen(const char *path, const char *type);
+SMB_STRUCT_DIRENT *sys_readdir(DIR *dirp);
+int sys_mknod(const char *path, mode_t mode, SMB_DEV_T dev);
+char *sys_realpath(const char *path, char *resolved_path);
+int sys_waitpid(pid_t pid,int *status,int options);
+char *sys_getwd(char *s);
+int sys_symlink(const char *oldpath, const char *newpath);
+int sys_readlink(const char *path, char *buf, size_t bufsiz);
+int sys_link(const char *oldpath, const char *newpath);
+int sys_chown(const char *fname,uid_t uid,gid_t gid);
+int sys_chroot(const char *dname);
+struct hostent *sys_gethostbyname(const char *name);
+void oplock_set_capability(BOOL this_process, BOOL inherit);
+long sys_random(void);
+void sys_srandom(unsigned int seed);
+int groups_max(void);
+int sys_getgroups(int setlen, gid_t *gidset);
+int sys_setgroups(int setlen, gid_t *gidset);
+void sys_setpwent(void);
+struct passwd *sys_getpwent(void);
+void sys_endpwent(void);
+struct passwd *sys_getpwnam(const char *name);
+struct passwd *sys_getpwuid(uid_t uid);
+int wsys_stat(const smb_ucs2_t *wfname,SMB_STRUCT_STAT *sbuf);
+int wsys_lstat(const smb_ucs2_t *wfname,SMB_STRUCT_STAT *sbuf);
+int wsys_creat(const smb_ucs2_t *wfname, mode_t mode);
+int wsys_open(const smb_ucs2_t *wfname, int oflag, mode_t mode);
+FILE *wsys_fopen(const smb_ucs2_t *wfname, const char *type);
+DIR *wsys_opendir(const smb_ucs2_t *wfname);
+smb_ucs2_t *wsys_getwd(smb_ucs2_t *s);
+int wsys_chown(const smb_ucs2_t *wfname, uid_t uid, gid_t gid);
+int wsys_chroot(const smb_ucs2_t *wfname);
+pid_t sys_fork(void);
+pid_t sys_getpid(void);
+int sys_popen(const char *command);
+int sys_pclose(int fd);
+void *sys_dlopen(const char *name, int flags);
+void *sys_dlsym(void *handle, char *symbol);
+int sys_dlclose (void *handle);
+const char *sys_dlerror(void);
+
+/*The following definitions come from lib/talloc.c */
+
+TALLOC_CTX *talloc_init(void);
+void *talloc(TALLOC_CTX *t, size_t size);
+void *talloc_realloc(TALLOC_CTX *t, void *ptr, size_t size);
+void talloc_destroy_pool(TALLOC_CTX *t);
+void talloc_destroy(TALLOC_CTX *t);
+size_t talloc_pool_size(TALLOC_CTX *t);
+void *talloc_zero(TALLOC_CTX *t, size_t size);
+void *talloc_memdup(TALLOC_CTX *t, void *p, size_t size);
+char *talloc_strdup(TALLOC_CTX *t, char *p);
+
+/*The following definitions come from lib/time.c */
+
+time_t get_time_t_min(void);
+time_t get_time_t_max(void);
+void GetTimeOfDay(struct timeval *tval);
+void TimeInit(void);
+void get_process_uptime(struct timeval *ret_time);
+int TimeDiff(time_t t);
+struct tm *LocalTime(time_t *t);
+time_t nt_time_to_unix(NTTIME *nt);
+time_t nt_time_to_unix_abs(NTTIME *nt);
+time_t interpret_long_date(char *p);
+void unix_to_nt_time(NTTIME *nt, time_t t);
+void unix_to_nt_time_abs(NTTIME *nt, time_t t);
+void put_long_date(char *p,time_t t);
+BOOL null_mtime(time_t mtime);
+void put_dos_date(char *buf,int offset,time_t unixdate);
+void put_dos_date2(char *buf,int offset,time_t unixdate);
+void put_dos_date3(char *buf,int offset,time_t unixdate);
+time_t make_unix_date(void *date_ptr);
+time_t make_unix_date2(void *date_ptr);
+time_t make_unix_date3(void *date_ptr);
+char *http_timestring(time_t t);
+char *timestring(BOOL hires);
+time_t get_create_time(SMB_STRUCT_STAT *st,BOOL fake_dirs);
+void init_nt_time(NTTIME *nt);
+
+/*The following definitions come from lib/ufc.c */
+
+char *ufc_crypt(const char *key,const char *salt);
+
+/*The following definitions come from lib/username.c */
+
+BOOL name_is_local(const char *name);
+char *get_user_home_dir(char *user);
+char *get_user_service_home_dir(char *user);
+BOOL map_username(char *user);
+struct passwd *Get_Pwnam(char *user,BOOL allow_change);
+BOOL user_in_group_list(char *user,char *gname);
+BOOL user_in_list(char *user,char *list);
+struct passwd *smb_getpwnam(char *user, BOOL allow_change);
+
+/*The following definitions come from lib/util.c */
+
+char *tmpdir(void);
+BOOL in_group(gid_t group, gid_t current_gid, int ngroups, gid_t *groups);
+char *Atoic(char *p, int *n, char *c);
+char *get_numlist(char *p, uint32 **num, int *count);
+BOOL file_exist(char *fname,SMB_STRUCT_STAT *sbuf);
+time_t file_modtime(char *fname);
+BOOL directory_exist(char *dname,SMB_STRUCT_STAT *st);
+SMB_OFF_T get_file_size(char *file_name);
+char *attrib_string(uint16 mode);
+void show_msg(char *buf);
+void smb_setlen(char *buf,int len);
+int set_message(char *buf,int num_words,int num_bytes,BOOL zero);
+int set_message_bcc(char *buf,int num_bytes);
+int set_message_end(void *outbuf,void *end_ptr);
+void dos_clean_name(char *s);
+void unix_clean_name(char *s);
+void make_dir_struct(char *buf,char *mask,char *fname,SMB_OFF_T size,int mode,time_t date);
+void close_low_fds(void);
+int set_blocking(int fd, BOOL set);
+ssize_t transfer_file_internal(int infd, int outfd, size_t n, ssize_t (*read_fn)(int, void *, size_t),
+ ssize_t (*write_fn)(int, const void *, size_t));
+SMB_OFF_T transfer_file(int infd,int outfd,SMB_OFF_T n);
+void msleep(int t);
+void become_daemon(void);
+BOOL yesno(char *p);
+void *Realloc(void *p,size_t size);
+void safe_free(void *p);
+BOOL get_myname(char *my_name);
+int interpret_protocol(char *str,int def);
+BOOL is_ipaddress(const char *str);
+uint32 interpret_addr(const char *str);
+struct in_addr *interpret_addr2(const char *str);
+BOOL zero_ip(struct in_addr ip);
+char *automount_lookup(char *user_name);
+char *automount_lookup(char *user_name);
+BOOL same_net(struct in_addr ip1,struct in_addr ip2,struct in_addr mask);
+BOOL process_exists(pid_t pid);
+char *uidtoname(uid_t uid);
+char *gidtoname(gid_t gid);
+uid_t nametouid(char *name);
+gid_t nametogid(char *name);
+void smb_panic(char *why);
+char *readdirname(DIR *p);
+BOOL is_in_path(char *name, name_compare_entry *namelist);
+void set_namearray(name_compare_entry **ppname_array, char *namelist);
+void free_namearray(name_compare_entry *name_array);
+BOOL fcntl_lock(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type);
+BOOL is_myname(char *s);
+BOOL is_myname_or_ipaddr(char *s);
+void set_remote_arch(enum remote_arch_types type);
+enum remote_arch_types get_remote_arch(void);
+void out_ascii(FILE *f, unsigned char *buf,int len);
+void out_data(FILE *f,char *buf1,int len, int per_line);
+void print_asc(int level, unsigned char *buf,int len);
+void dump_data(int level,char *buf1,int len);
+char *tab_depth(int depth);
+int str_checksum(const char *s);
+void zero_free(void *p, size_t size);
+int set_maxfiles(int requested_max);
+BOOL reg_split_key(char *full_keyname, uint32 *reg_type, char *key_name);
+int smb_mkstemp(char *template);
+void *smb_xmalloc(size_t size);
+void *xmemdup(const void *p, size_t size);
+char *xstrdup(const char *s);
+void *memdup(void *p, size_t size);
+char *myhostname(void);
+char *lock_path(char *name);
+char *parent_dirname(const char *path);
+BOOL ms_has_wild(char *s);
+BOOL mask_match(char *string, char *pattern, BOOL is_case_sensitive);
+BOOL unix_wild_match(char *pattern, char *string);
+int _Insure_trap_error(int a1, int a2, int a3, int a4, int a5, int a6);
+
+/*The following definitions come from lib/util_file.c */
+
+BOOL do_file_lock(int fd, int waitsecs, int type);
+BOOL file_lock(int fd, int type, int secs, int *plock_depth);
+BOOL file_unlock(int fd, int *plock_depth);
+void *startfilepwent(char *pfile, char *s_readbuf, int bufsize,
+ int *file_lock_depth, BOOL update);
+void endfilepwent(void *vp, int *file_lock_depth);
+SMB_BIG_UINT getfilepwpos(void *vp);
+BOOL setfilepwpos(void *vp, SMB_BIG_UINT tok);
+int getfileline(void *vp, char *linebuf, int linebuf_size);
+char *fgets_slash(char *s2,int maxlen,FILE *f);
+char *file_pload(char *syscmd, size_t *size);
+char *fd_load(int fd, size_t *size);
+char *file_load(char *fname, size_t *size);
+char **file_lines_load(char *fname, int *numlines, BOOL convert);
+char **fd_lines_load(int fd, int *numlines, BOOL convert);
+char **file_lines_pload(char *syscmd, int *numlines, BOOL convert);
+void file_lines_free(char **lines);
+void file_lines_slashcont(char **lines);
+
+/*The following definitions come from lib/util_getent.c */
+
+struct sys_grent * getgrent_list(void);
+void grent_free (struct sys_grent *glist);
+struct sys_pwent * getpwent_list(void);
+void pwent_free (struct sys_pwent *plist);
+struct sys_userlist *get_users_in_group(const char *gname);
+void free_userlist(struct sys_userlist *list_head);
+
+/*The following definitions come from lib/util_seaccess.c */
+
+void se_map_generic(uint32 *access_mask, struct generic_mapping *mapping);
+BOOL se_access_check(SEC_DESC *sd, NT_USER_TOKEN *token,
+ uint32 acc_desired, uint32 *acc_granted,
+ NTSTATUS *status);
+SEC_DESC_BUF *se_create_child_secdesc(TALLOC_CTX *ctx, SEC_DESC *parent_ctr,
+ BOOL child_container);
+
+/*The following definitions come from lib/util_sec.c */
+
+void sec_init(void);
+uid_t sec_initial_uid(void);
+gid_t sec_initial_gid(void);
+BOOL non_root_mode(void);
+void gain_root_privilege(void);
+void gain_root_group_privilege(void);
+void set_effective_uid(uid_t uid);
+void set_effective_gid(gid_t gid);
+void save_re_uid(void);
+void restore_re_uid(void);
+int set_re_uid(void);
+void become_user_permanently(uid_t uid, gid_t gid);
+BOOL is_setuid_root(void) ;
+
+/*The following definitions come from lib/util_sid.c */
+
+void generate_wellknown_sids(void);
+BOOL map_domain_sid_to_name(DOM_SID *sid, char *nt_domain);
+BOOL lookup_known_rid(DOM_SID *sid, uint32 rid, char *name, enum SID_NAME_USE *psid_name_use);
+BOOL map_domain_name_to_sid(DOM_SID *sid, char *nt_domain);
+void split_domain_name(const char *fullname, char *domain, char *name);
+char *sid_to_string(fstring sidstr_out, DOM_SID *sid);
+BOOL string_to_sid(DOM_SID *sidout, const char *sidstr);
+BOOL sid_append_rid(DOM_SID *sid, uint32 rid);
+BOOL sid_split_rid(DOM_SID *sid, uint32 *rid);
+BOOL sid_peek_rid(DOM_SID *sid, uint32 *rid);
+void sid_copy(DOM_SID *dst, const DOM_SID *src);
+DOM_SID *sid_dup(DOM_SID *src);
+BOOL sid_linearize(char *outbuf, size_t len, DOM_SID *sid);
+int sid_compare(const DOM_SID *sid1, const DOM_SID *sid2);
+BOOL sid_equal(const DOM_SID *sid1, const DOM_SID *sid2);
+size_t sid_size(DOM_SID *sid);
+BOOL non_mappable_sid(DOM_SID *sid);
+
+/*The following definitions come from lib/util_sock.c */
+
+BOOL is_a_socket(int fd);
+void set_socket_options(int fd, char *options);
+ssize_t read_udp_socket(int fd,char *buf,size_t len);
+ssize_t read_with_timeout(int fd,char *buf,size_t mincnt,size_t maxcnt,unsigned int time_out);
+BOOL send_keepalive(int client);
+ssize_t read_data(int fd,char *buffer,size_t N);
+ssize_t write_data(int fd,char *buffer,size_t N);
+ssize_t write_socket_data(int fd,char *buffer,size_t N);
+ssize_t write_socket(int fd,char *buf,size_t len);
+ssize_t read_smb_length(int fd,char *inbuf,unsigned int timeout);
+BOOL receive_smb(int fd,char *buffer, unsigned int timeout);
+BOOL client_receive_smb(int fd,char *buffer, unsigned int timeout);
+BOOL send_smb(int fd,char *buffer);
+BOOL send_one_packet(char *buf,int len,struct in_addr ip,int port,int type);
+int open_socket_in( int type, int port, int dlevel, uint32 socket_addr, BOOL rebind );
+int open_socket_out(int type, struct in_addr *addr, int port ,int timeout);
+void client_setfd(int fd);
+char *client_name(void);
+char *client_addr(void);
+char *get_socket_name(int fd);
+char *get_socket_addr(int fd);
+int open_pipe_sock(char *path);
+int sock_exec(const char *prog);
-BOOL cli_session_setup(struct cli_state *cli,
- char *user,
- char *pass, int passlen,
- char *ntpass, int ntpasslen,
- char *workgroup);
-BOOL cli_ulogoff(struct cli_state *cli);
-BOOL cli_send_tconX(struct cli_state *cli,
- const char *share, const char *dev, const char *pass, int passlen);
-BOOL cli_tdis(struct cli_state *cli);
-void cli_negprot_send(struct cli_state *cli);
-BOOL cli_negprot(struct cli_state *cli);
-BOOL cli_session_request(struct cli_state *cli,
- struct nmb_name *calling, struct nmb_name *called);
-BOOL cli_connect(struct cli_state *cli, const char *host, struct in_addr *ip);
-BOOL cli_establish_connection(struct cli_state *cli,
- char *dest_host, struct in_addr *dest_ip,
- struct nmb_name *calling, struct nmb_name *called,
- char *service, char *service_type,
- BOOL do_shutdown, BOOL do_tcon);
-BOOL attempt_netbios_session_request(struct cli_state *cli, char *srchost, char *desthost,
- struct in_addr *pdest_ip);
+/*The following definitions come from lib/util_str.c */
+
+void set_first_token(char *ptr);
+BOOL next_token(char **ptr,char *buff,char *sep, size_t bufsize);
+char **toktocliplist(int *ctok, char *sep);
+int StrCaseCmp(const char *s, const char *t);
+int StrnCaseCmp(const char *s, const char *t, size_t n);
+BOOL strequal(const char *s1, const char *s2);
+BOOL strnequal(const char *s1,const char *s2,size_t n);
+BOOL strcsequal(const char *s1,const char *s2);
+int strwicmp(char *psz1, char *psz2);
+void strlower(char *s);
+void strupper(char *s);
+void strnorm(char *s);
+BOOL strisnormal(char *s);
+void string_replace(char *s,char oldc,char newc);
+char *skip_string(char *buf,size_t n);
+size_t str_charnum(const char *s);
+BOOL trim_string(char *s,const char *front,const char *back);
+BOOL strhasupper(const char *s);
+BOOL strhaslower(const char *s);
+size_t count_chars(const char *s,char c);
+BOOL str_is_all(const char *s,char c);
+char *safe_strcpy(char *dest,const char *src, size_t maxlength);
+char *safe_strcat(char *dest, const char *src, size_t maxlength);
+char *alpha_strcpy(char *dest, const char *src, const char *other_safe_chars, size_t maxlength);
+char *StrnCpy(char *dest,const char *src,size_t n);
+char *strncpyn(char *dest, const char *src,size_t n, char c);
+size_t strhex_to_str(char *p, size_t len, const char *strhex);
+BOOL in_list(char *s,char *list,BOOL casesensitive);
+void string_free(char **s);
+BOOL string_set(char **dest,const char *src);
+void string_sub(char *s,const char *pattern,const char *insert, size_t len);
+void fstring_sub(char *s,const char *pattern,const char *insert);
+void pstring_sub(char *s,const char *pattern,const char *insert);
+void all_string_sub(char *s,const char *pattern,const char *insert, size_t len);
+void split_at_last_component(char *path, char *front, char sep, char *back);
+char *octal_string(int i);
+char *string_truncate(char *s, int length);
+
+/*The following definitions come from lib/util_unistr.c */
+
+size_t unix_PutUniCode(char *dst,const char *src, ssize_t len, BOOL null_terminate);
+size_t dos_PutUniCode(char *dst,const char *src, ssize_t len, BOOL null_terminate);
+void unistr_to_dos(char *dest, const char *src, size_t len);
+char *skip_unibuf(char *src, size_t len);
+char *dos_unistrn2(uint16 *src, int len);
+char *dos_unistr2(uint16 *src);
+char *dos_unistr2_to_str(UNISTR2 *str);
+void ascii_to_unistr(uint16 *dest, const char *src, int maxlen);
+void unistr_to_ascii(char *dest, const uint16 *src, int len);
+void unistr2_to_ascii(char *dest, const UNISTR2 *str, size_t maxlen);
+uint32 buffer2_to_uint32(BUFFER2 *str);
+char *dos_buffer2_to_str(BUFFER2 *str);
+char *dos_buffer2_to_multistr(BUFFER2 *str);
+size_t dos_struni2(char *dst, const char *src, size_t max_len);
+char *dos_unistr(char *buf);
+int unistrcpy(char *dst, char *src);
+void default_unicode_map(smb_ucs2_t **pp_cp_to_ucs2, uint16 **pp_ucs2_to_cp);
+BOOL load_unicode_map(const char *codepage, smb_ucs2_t **pp_cp_to_ucs2, uint16 **pp_ucs2_to_cp);
+BOOL load_dos_unicode_map(int codepage);
+BOOL load_unix_unicode_map(const char *unix_char_set, BOOL override);
+smb_ucs2_t *multibyte_to_unicode(smb_ucs2_t *dst, const char *src,
+ size_t dst_len, smb_ucs2_t *cp_to_ucs2);
+char *unicode_to_unix(char *dst, const smb_ucs2_t *src, size_t dst_len);
+smb_ucs2_t *unix_to_unicode(smb_ucs2_t *dst, const char *src, size_t dst_len);
+size_t unicode_to_unix_char(char *dst, const smb_ucs2_t src);
+char *unicode_to_dos(char *dst, const smb_ucs2_t *src, size_t dst_len);
+size_t unicode_to_dos_char(char *dst, const smb_ucs2_t src);
+smb_ucs2_t *dos_to_unicode(smb_ucs2_t *dst, const char *src, size_t dst_len);
+size_t strlen_w(const smb_ucs2_t *src);
+smb_ucs2_t *safe_strcpy_w(smb_ucs2_t *dest,const smb_ucs2_t *src, size_t maxlength);
+smb_ucs2_t *safe_strcat_w(smb_ucs2_t *dest, const smb_ucs2_t *src, size_t maxlength);
+int strcmp_w(const smb_ucs2_t *s1, const smb_ucs2_t *s2);
+int strncmp_w(const smb_ucs2_t *s1, const smb_ucs2_t *s2, size_t len);
+smb_ucs2_t *strstr_w(const smb_ucs2_t *s1, const smb_ucs2_t *s2);
+smb_ucs2_t *strchr_w(const smb_ucs2_t *s, smb_ucs2_t c);
+smb_ucs2_t *strrchr_w(const smb_ucs2_t *s, smb_ucs2_t c);
+smb_ucs2_t *strtok_w(smb_ucs2_t *s1, const smb_ucs2_t *s2);
+smb_ucs2_t *strdup_w(const smb_ucs2_t *s);
+int isupper_w( smb_ucs2_t val);
+int islower_w( smb_ucs2_t val);
+int isdigit_w( smb_ucs2_t val);
+int isxdigit_w( smb_ucs2_t val);
+int isspace_w( smb_ucs2_t val);
+smb_ucs2_t toupper_w( smb_ucs2_t val );
+smb_ucs2_t tolower_w( smb_ucs2_t val );
+void set_first_token_w(smb_ucs2_t *ptr);
+BOOL next_token_w(smb_ucs2_t **ptr, smb_ucs2_t *buff, smb_ucs2_t *sep, size_t bufsize);
+smb_ucs2_t **toktocliplist_w(int *ctok, smb_ucs2_t *sep);
+int StrCaseCmp_w(const smb_ucs2_t *s, const smb_ucs2_t *t);
+int StrnCaseCmp_w(const smb_ucs2_t *s, const smb_ucs2_t *t, size_t n);
+BOOL strequal_w(const smb_ucs2_t *s1, const smb_ucs2_t *s2);
+BOOL strnequal_w(const smb_ucs2_t *s1,const smb_ucs2_t *s2,size_t n);
+BOOL strcsequal_w(const smb_ucs2_t *s1,const smb_ucs2_t *s2);
+void strlower_w(smb_ucs2_t *s);
+void strupper_w(smb_ucs2_t *s);
+void strnorm_w(smb_ucs2_t *s);
+BOOL strisnormal_w(smb_ucs2_t *s);
+void string_replace_w(smb_ucs2_t *s, smb_ucs2_t oldc, smb_ucs2_t newc);
+smb_ucs2_t *skip_string_w(smb_ucs2_t *buf,size_t n);
+size_t str_charnum_w(const smb_ucs2_t *s);
+BOOL trim_string_w(smb_ucs2_t *s,const smb_ucs2_t *front,const smb_ucs2_t *back);
+BOOL strhasupper_w(const smb_ucs2_t *s);
+BOOL strhaslower_w(const smb_ucs2_t *s);
+size_t count_chars_w(const smb_ucs2_t *s,smb_ucs2_t c);
+BOOL str_is_all_w(const smb_ucs2_t *s,smb_ucs2_t c);
+smb_ucs2_t *alpha_strcpy_w(smb_ucs2_t *dest, const smb_ucs2_t *src, const smb_ucs2_t *other_safe_chars, size_t maxlength);
+smb_ucs2_t *StrnCpy_w(smb_ucs2_t *dest,const smb_ucs2_t *src,size_t n);
+smb_ucs2_t *strncpyn_w(smb_ucs2_t *dest, const smb_ucs2_t *src,size_t n, smb_ucs2_t c);
+size_t strhex_to_str_w(char *p, size_t len, const smb_ucs2_t *strhex);
+BOOL in_list_w(smb_ucs2_t *s,smb_ucs2_t *list,BOOL casesensitive);
+BOOL string_init_w(smb_ucs2_t **dest,const smb_ucs2_t *src);
+void string_free_w(smb_ucs2_t **s);
+BOOL string_set_w(smb_ucs2_t **dest,const smb_ucs2_t *src);
+void string_sub_w(smb_ucs2_t *s,const smb_ucs2_t *pattern,const smb_ucs2_t *insert, size_t len);
+void fstring_sub_w(smb_ucs2_t *s,const smb_ucs2_t *pattern,const smb_ucs2_t *insert);
+void pstring_sub_w(smb_ucs2_t *s,const smb_ucs2_t *pattern,smb_ucs2_t *insert);
+void all_string_sub_w(smb_ucs2_t *s,const smb_ucs2_t *pattern,const smb_ucs2_t *insert, size_t len);
+void split_at_last_component_w(smb_ucs2_t *path, smb_ucs2_t *front, smb_ucs2_t sep, smb_ucs2_t *back);
+smb_ucs2_t *octal_string_w(int i);
+smb_ucs2_t *string_truncate_w(smb_ucs2_t *s, size_t length);
+smb_ucs2_t doscp2ucs2(int w);
+int ucs2doscp(smb_ucs2_t w);
+int rpcstr_pull(char* dest, void *src, int dest_len, int src_len, int flags);
+
+/*The following definitions come from lib/wins_srv.c */
+
+BOOL wins_srv_load_list( char *src );
+struct in_addr wins_srv_ip( void );
+void wins_srv_died( struct in_addr boothill_ip );
+unsigned long wins_srv_count( void );
/*The following definitions come from libsmb/cli_dfs.c */
@@ -207,86 +773,6 @@
NTSTATUS cli_dfs_enum(struct cli_state *cli, TALLOC_CTX *mem_ctx,
uint32 info_level, DFS_INFO_CTR *ctr);
-/*The following definitions come from libsmb/clidgram.c */
-
-int cli_send_mailslot(int dgram_sock, BOOL unique, char *mailslot,
- char *buf, int len,
- const char *srcname, int src_type,
- const char *dstname, int dest_type,
- struct in_addr dest_ip, struct in_addr src_ip,
- int dest_port, int src_port);
-int cli_get_response(int dgram_sock, BOOL unique, char *mailslot, char *buf, int bufsiz);
-int cli_get_backup_list(const char *myname, const char *send_to_name);
-int cli_get_backup_server(char *my_name, char *target, char *servername, int namesize);
-
-/*The following definitions come from libsmb/clientgen.c */
-
-int cli_set_port(struct cli_state *cli, int port);
-BOOL cli_receive_smb(struct cli_state *cli);
-BOOL cli_send_smb(struct cli_state *cli);
-void cli_setup_packet(struct cli_state *cli);
-void cli_setup_bcc(struct cli_state *cli, void *p);
-void cli_init_creds(struct cli_state *cli, const struct ntuser_creds *usr);
-struct cli_state *cli_initialise(struct cli_state *cli);
-void cli_shutdown(struct cli_state *cli);
-void cli_sockopt(struct cli_state *cli, char *options);
-uint16 cli_setpid(struct cli_state *cli, uint16 pid);
-
-/*The following definitions come from libsmb/clierror.c */
-
-char *cli_errstr(struct cli_state *cli);
-NTSTATUS cli_nt_error(struct cli_state *cli);
-void cli_dos_error(struct cli_state *cli, uint8 *eclass, uint32 *ecode);
-int cli_errno_from_dos(uint8 eclass, uint32 num);
-int cli_errno_from_nt(NTSTATUS status);
-int cli_errno(struct cli_state *cli);
-BOOL cli_is_error(struct cli_state *cli);
-BOOL cli_is_nt_error(struct cli_state *cli);
-BOOL cli_is_dos_error(struct cli_state *cli);
-
-/*The following definitions come from libsmb/clifile.c */
-
-uint32 unix_perms_to_wire(mode_t perms);
-BOOL cli_unix_symlink(struct cli_state *cli, const char *fname_src, const char *fname_dst);
-BOOL cli_unix_hardlink(struct cli_state *cli, const char *fname_src, const char *fname_dst);
-BOOL cli_unix_chmod(struct cli_state *cli, const char *fname, mode_t mode);
-BOOL cli_unix_chown(struct cli_state *cli, const char *fname, uid_t uid, gid_t gid);
-BOOL cli_rename(struct cli_state *cli, const char *fname_src, const char *fname_dst);
-BOOL cli_unlink(struct cli_state *cli, const char *fname);
-BOOL cli_mkdir(struct cli_state *cli, const char *dname);
-BOOL cli_rmdir(struct cli_state *cli, const char *dname);
-int cli_nt_delete_on_close(struct cli_state *cli, int fnum, BOOL flag);
-int cli_nt_create_full(struct cli_state *cli, const char *fname, uint32 DesiredAccess,
- uint32 FileAttributes, uint32 ShareAccess,
- uint32 CreateDisposition, uint32 CreateOptions);
-int cli_nt_create(struct cli_state *cli, const char *fname, uint32 DesiredAccess);
-int cli_open(struct cli_state *cli, const char *fname, int flags, int share_mode);
-BOOL cli_close(struct cli_state *cli, int fnum);
-BOOL cli_lock(struct cli_state *cli, int fnum,
- uint32 offset, uint32 len, int timeout, enum brl_type lock_type);
-BOOL cli_unlock(struct cli_state *cli, int fnum, uint32 offset, uint32 len);
-BOOL cli_lock64(struct cli_state *cli, int fnum,
- SMB_BIG_UINT offset, SMB_BIG_UINT len, int timeout, enum brl_type lock_type);
-BOOL cli_unlock64(struct cli_state *cli, int fnum, SMB_BIG_UINT offset, SMB_BIG_UINT len);
-BOOL cli_getattrE(struct cli_state *cli, int fd,
- uint16 *attr, size_t *size,
- time_t *c_time, time_t *a_time, time_t *m_time);
-BOOL cli_getatr(struct cli_state *cli, const char *fname,
- uint16 *attr, size_t *size, time_t *t);
-BOOL cli_setatr(struct cli_state *cli, const char *fname, uint16 attr, time_t t);
-BOOL cli_chkpath(struct cli_state *cli, const char *path);
-BOOL cli_dskattr(struct cli_state *cli, int *bsize, int *total, int *avail);
-int cli_ctemp(struct cli_state *cli, const char *path, char **tmp_path);
-
-/*The following definitions come from libsmb/clilist.c */
-
-int cli_list_new(struct cli_state *cli,const char *Mask,uint16 attribute,
- void (*fn)(file_info *, const char *, void *), void *state);
-int cli_list_old(struct cli_state *cli,const char *Mask,uint16 attribute,
- void (*fn)(file_info *, const char *, void *), void *state);
-int cli_list(struct cli_state *cli,const char *Mask,uint16 attribute,
- void (*fn)(file_info *, const char *, void *), void *state);
-
/*The following definitions come from libsmb/cli_lsarpc.c */
struct cli_state *cli_lsa_initialise(struct cli_state *cli, char *system_name,
@@ -319,14 +805,7 @@
NTSTATUS cli_lsa_enum_sids(struct cli_state *cli, TALLOC_CTX *mem_ctx,
POLICY_HND *pol, uint32 *enum_ctx, uint32 pref_max_length,
uint32 *num_sids, DOM_SID **sids);
-BOOL fetch_domain_sid( char *domain, char *remote_machine, DOM_SID *psid);
-
-/*The following definitions come from libsmb/climessage.c */
-
-BOOL cli_message_start(struct cli_state *cli, char *host, char *username,
- int *grp);
-BOOL cli_message_text(struct cli_state *cli, char *msg, int len, int grp);
-BOOL cli_message_end(struct cli_state *cli, int grp);
+BOOL fetch_domain_sid( char *domain, char *remote_machine, DOM_SID *psid);
/*The following definitions come from libsmb/cli_netlogon.c */
@@ -354,12 +833,6 @@
char *username, char *password,
int logon_type);
-/*The following definitions come from libsmb/clioplock.c */
-
-BOOL cli_oplock_ack(struct cli_state *cli, int fnum, unsigned char level);
-void cli_oplock_handler(struct cli_state *cli,
- BOOL (*handler)(struct cli_state *, int, unsigned char));
-
/*The following definitions come from libsmb/cli_pipe_util.c */
struct cli_state *cli_pipe_initialise(struct cli_state *cli, char *system_name,
@@ -367,56 +840,6 @@
struct ntuser_creds *creds);
void cli_pipe_shutdown(struct cli_state *cli);
-/*The following definitions come from libsmb/cliprint.c */
-
-int cli_print_queue(struct cli_state *cli,
- void (*fn)(struct print_job_info *));
-int cli_printjob_del(struct cli_state *cli, int job);
-
-/*The following definitions come from libsmb/clirap.c */
-
-BOOL cli_api_pipe(struct cli_state *cli, char *pipe_name,
- uint16 *setup, uint32 setup_count, uint32 max_setup_count,
- char *params, uint32 param_count, uint32 max_param_count,
- char *data, uint32 data_count, uint32 max_data_count,
- char **rparam, uint32 *rparam_count,
- char **rdata, uint32 *rdata_count);
-BOOL cli_api(struct cli_state *cli,
- char *param, int prcnt, int mprcnt,
- char *data, int drcnt, int mdrcnt,
- char **rparam, int *rprcnt,
- char **rdata, int *rdrcnt);
-BOOL cli_NetWkstaUserLogon(struct cli_state *cli,char *user, char *workstation);
-int cli_RNetShareEnum(struct cli_state *cli, void (*fn)(const char *, uint32, const char *, void *), void *state);
-BOOL cli_NetServerEnum(struct cli_state *cli, char *workgroup, uint32 stype,
- void (*fn)(const char *, uint32, const char *, void *),
- void *state);
-BOOL cli_oem_change_password(struct cli_state *cli, const char *user, const char *new_password,
- const char *old_password);
-BOOL cli_qpathinfo(struct cli_state *cli, const char *fname,
- time_t *c_time, time_t *a_time, time_t *m_time,
- size_t *size, uint16 *mode);
-BOOL cli_qpathinfo2(struct cli_state *cli, const char *fname,
- time_t *c_time, time_t *a_time, time_t *m_time,
- time_t *w_time, size_t *size, uint16 *mode,
- SMB_INO_T *ino);
-BOOL cli_qfileinfo(struct cli_state *cli, int fnum,
- uint16 *mode, size_t *size,
- time_t *c_time, time_t *a_time, time_t *m_time,
- time_t *w_time, SMB_INO_T *ino);
-BOOL cli_qfileinfo_test(struct cli_state *cli, int fnum, int level, char *outdata);
-NTSTATUS cli_qpathinfo_alt_name(struct cli_state *cli, const char *fname, fstring alt_name);
-
-/*The following definitions come from libsmb/clireadwrite.c */
-
-ssize_t cli_read(struct cli_state *cli, int fnum, char *buf, off_t offset, size_t size);
-ssize_t cli_readraw(struct cli_state *cli, int fnum, char *buf, off_t offset, size_t size);
-ssize_t cli_write(struct cli_state *cli,
- int fnum, uint16 write_mode,
- char *buf, off_t offset, size_t size);
-ssize_t cli_smbwrite(struct cli_state *cli,
- int fnum, char *buf, off_t offset, size_t size1);
-
/*The following definitions come from libsmb/cli_reg.c */
struct cli_state *cli_winreg_initialise(struct cli_state *cli,
@@ -495,12 +918,6 @@
NTSTATUS cli_samr_delete_dom_user(struct cli_state *cli, TALLOC_CTX *mem_ctx,
POLICY_HND *user_pol);
-/*The following definitions come from libsmb/clisecdesc.c */
-
-SEC_DESC *cli_query_secdesc(struct cli_state *cli, int fnum,
- TALLOC_CTX *mem_ctx);
-BOOL cli_set_secdesc(struct cli_state *cli, int fnum, SEC_DESC *sd);
-
/*The following definitions come from libsmb/cli_spoolss.c */
struct cli_state *cli_spoolss_initialise(struct cli_state *cli,
@@ -558,801 +975,384 @@
uint32 level,
char* env,
DRIVER_DIRECTORY_CTR *ctr
-);
-NTSTATUS cli_spoolss_addprinterdriver (
- struct cli_state *cli,
- TALLOC_CTX *mem_ctx,
- uint32 level,
- PRINTER_DRIVER_CTR *ctr
-);
-NTSTATUS cli_spoolss_addprinterex (
- struct cli_state *cli,
- TALLOC_CTX *mem_ctx,
- uint32 level,
- PRINTER_INFO_CTR *ctr
-);
-NTSTATUS cli_spoolss_deleteprinterdriver (
- struct cli_state *cli,
- TALLOC_CTX *mem_ctx,
- char *arch,
- char *driver
-);
-NTSTATUS cli_spoolss_getprintprocessordirectory(struct cli_state *cli,
- TALLOC_CTX *mem_ctx,
- char *name,
- char *environment,
- fstring procdir);
-NTSTATUS cli_spoolss_setprinterdata (struct cli_state *cli, TALLOC_CTX *mem_ctx,
- POLICY_HND *pol, char* valname, char* value);
-
-/*The following definitions come from libsmb/cli_srvsvc.c */
-
-struct cli_state *cli_svrsvc_initialise(struct cli_state *cli,
- char *system_name,
- struct ntuser_creds *creds);
-NTSTATUS cli_srvsvc_net_srv_get_info(struct cli_state *cli,
- TALLOC_CTX *mem_ctx,
- uint32 switch_value, SRV_INFO_CTR *ctr);
-
-/*The following definitions come from libsmb/clistr.c */
-
-int clistr_push(struct cli_state *cli, void *dest, const char *src, int dest_len, int flags);
-int clistr_pull(struct cli_state *cli, char *dest, const void *src, int dest_len, int src_len, int flags);
-int clistr_align_out(struct cli_state *cli, const void *p, int flags);
-int clistr_align_in(struct cli_state *cli, const void *p, int flags);
-
-/*The following definitions come from libsmb/clitrans.c */
-
-BOOL cli_send_trans(struct cli_state *cli, int trans,
- const char *pipe_name,
- int fid, int flags,
- uint16 *setup, int lsetup, int msetup,
- char *param, int lparam, int mparam,
- char *data, int ldata, int mdata);
-BOOL cli_receive_trans(struct cli_state *cli,int trans,
- char **param, int *param_len,
- char **data, int *data_len);
-BOOL cli_send_nt_trans(struct cli_state *cli,
- int function,
- int flags,
- uint16 *setup, int lsetup, int msetup,
- char *param, int lparam, int mparam,
- char *data, int ldata, int mdata);
-BOOL cli_receive_nt_trans(struct cli_state *cli,
- char **param, int *param_len,
- char **data, int *data_len);
-
-/*The following definitions come from libsmb/credentials.c */
-
-char *credstr(uchar *cred);
-void cred_session_key(DOM_CHAL *clnt_chal, DOM_CHAL *srv_chal, char *pass,
- uchar session_key[8]);
-void cred_create(uchar session_key[8], DOM_CHAL *stor_cred, UTIME timestamp,
- DOM_CHAL *cred);
-int cred_assert(DOM_CHAL *cred, uchar session_key[8], DOM_CHAL *stored_cred,
- UTIME timestamp);
-BOOL clnt_deal_with_creds(uchar sess_key[8],
- DOM_CRED *sto_clnt_cred, DOM_CRED *rcv_srv_cred);
-BOOL deal_with_creds(uchar sess_key[8],
- DOM_CRED *sto_clnt_cred,
- DOM_CRED *rcv_clnt_cred, DOM_CRED *rtn_srv_cred);
-
-/*The following definitions come from libsmb/errormap.c */
-
-NTSTATUS dos_to_ntstatus(int eclass, int ecode);
-void ntstatus_to_dos(NTSTATUS ntstatus, uint8 *eclass, uint32 *ecode);
-NTSTATUS werror_to_ntstatus(WERROR error);
-WERROR ntstatus_to_werror(NTSTATUS error);
-
-/*The following definitions come from libsmb/namequery.c */
-
-struct node_status *node_status_query(int fd,struct nmb_name *name,
- struct in_addr to_ip, int *num_names);
-BOOL name_status_find(const char *q_name, int q_type, int type, struct in_addr to_ip, char *name);
-BOOL name_register(int fd, const char *name, int name_type,
- struct in_addr name_ip, int opcode,
- BOOL bcast,
- struct in_addr to_ip, int *count);
-struct in_addr *name_query(int fd,const char *name,int name_type,
- BOOL bcast,BOOL recurse,
- struct in_addr to_ip, int *count);
-FILE *startlmhosts(char *fname);
-BOOL getlmhostsent( FILE *fp, pstring name, int *name_type, struct in_addr *ipaddr);
-void endlmhosts(FILE *fp);
-BOOL name_register_wins(const char *name, int name_type);
-BOOL name_resolve_bcast(const char *name, int name_type,
- struct in_addr **return_ip_list, int *return_count);
-BOOL resolve_name(const char *name, struct in_addr *return_ip, int name_type);
-BOOL resolve_srv_name(const char* srv_name, fstring dest_host,
- struct in_addr *ip);
-BOOL find_master_ip(char *group, struct in_addr *master_ip);
-BOOL lookup_dc_name(const char *srcname, const char *domain,
- struct in_addr *dc_ip, char *ret_name);
-BOOL get_dc_list(BOOL pdc_only, char *group, struct in_addr **ip_list, int *count);
-BOOL get_lmb_list(struct in_addr **ip_list, int *count);
-
-/*The following definitions come from libsmb/nmblib.c */
-
-void debug_nmb_packet(struct packet_struct *p);
-char *nmb_namestr(struct nmb_name *n);
-struct packet_struct *copy_packet(struct packet_struct *packet);
-void free_packet(struct packet_struct *packet);
-struct packet_struct *parse_packet(char *buf,int length,
- enum packet_type packet_type);
-struct packet_struct *read_packet(int fd,enum packet_type packet_type);
-void make_nmb_name( struct nmb_name *n, const char *name, int type);
-BOOL nmb_name_equal(struct nmb_name *n1, struct nmb_name *n2);
-int build_packet(char *buf, struct packet_struct *p);
-BOOL send_packet(struct packet_struct *p);
-struct packet_struct *receive_packet(int fd,enum packet_type type,int t);
-struct packet_struct *receive_nmb_packet(int fd, int t, int trn_id);
-struct packet_struct *receive_dgram_packet(int fd, int t, char *mailslot_name);
-BOOL match_mailslot_name(struct packet_struct *p, char *mailslot_name);
-void sort_query_replies(char *data, int n, struct in_addr ip);
-char *dns_to_netbios_name(char *dns_name);
-int name_mangle( char *In, char *Out, char name_type );
-int name_extract(char *buf,int ofs,char *name);
-int name_len(char *s1);
-
-/*The following definitions come from libsmb/nterr.c */
-
-char *get_nt_error_msg(NTSTATUS nt_code);
-char *get_nt_error_c_code(NTSTATUS nt_code);
-
-/*The following definitions come from libsmb/passchange.c */
-
-BOOL remote_password_change(const char *remote_machine, const char *user_name,
- const char *old_passwd, const char *new_passwd,
- char *err_str, size_t err_str_len);
-
-/*The following definitions come from libsmb/pwd_cache.c */
-
-void pwd_init(struct pwd_info *pwd);
-BOOL pwd_is_nullpwd(const struct pwd_info *pwd);
-BOOL pwd_compare(struct pwd_info *pwd1, struct pwd_info *pwd2);
-void pwd_read(struct pwd_info *pwd, char *passwd_report, BOOL do_encrypt);
-void pwd_set_nullpwd(struct pwd_info *pwd);
-void pwd_set_cleartext(struct pwd_info *pwd, char *clr);
-void pwd_get_cleartext(struct pwd_info *pwd, char *clr);
-void pwd_set_lm_nt_16(struct pwd_info *pwd, uchar lm_pwd[16], uchar nt_pwd[16]);
-void pwd_get_lm_nt_16(struct pwd_info *pwd, uchar lm_pwd[16], uchar nt_pwd[16]);
-void pwd_make_lm_nt_16(struct pwd_info *pwd, char *clr);
-void pwd_make_lm_nt_owf(struct pwd_info *pwd, uchar cryptkey[8]);
-void pwd_get_lm_nt_owf(struct pwd_info *pwd, uchar lm_owf[24], uchar nt_owf[24]);
-
-/*The following definitions come from lib/smbrun.c */
-
-int smbrun(char *cmd, int *outfd);
-
-/*The following definitions come from libsmb/smbdes.c */
-
-void E_P16(const unsigned char *p14,unsigned char *p16);
-void E_P24(const unsigned char *p21, const unsigned char *c8, unsigned char *p24);
-void D_P16(const unsigned char *p14, const unsigned char *in, unsigned char *out);
-void E_old_pw_hash( unsigned char *p14, const unsigned char *in, unsigned char *out);
-void cred_hash1(unsigned char *out, const unsigned char *in,unsigned char *key);
-void cred_hash2(unsigned char *out, const unsigned char *in,unsigned char *key);
-void cred_hash3(unsigned char *out,unsigned char *in,unsigned char *key, int forw);
-void SamOEMhash( unsigned char *data, const unsigned char *key, int val);
-void sam_pwd_hash(unsigned int rid, const uchar *in, uchar *out, int forw);
-
-/*The following definitions come from libsmb/smbencrypt.c */
-
-void SMBencrypt(uchar *passwd, uchar *c8, uchar *p24);
-void E_md4hash(uchar *passwd, uchar *p16);
-void nt_lm_owf_gen(char *pwd, uchar nt_p16[16], uchar p16[16]);
-void SMBOWFencrypt(uchar passwd[16], uchar *c8, uchar p24[24]);
-void NTLMSSPOWFencrypt(uchar passwd[8], uchar *ntlmchalresp, uchar p24[24]);
-void SMBNTencrypt(uchar *passwd, uchar *c8, uchar *p24);
-BOOL make_oem_passwd_hash(char data[516], const char *passwd, uchar old_pw_hash[16], BOOL unicode);
-BOOL encode_pw_buffer(char buffer[516], const char *new_pass,
- int new_pw_len, BOOL nt_pass_set);
-BOOL decode_pw_buffer(char in_buffer[516], char *new_pwrd,
- int new_pwrd_size, uint32 *new_pw_len,
- uchar nt_p16[16], uchar p16[16]);
-void nt_owf_genW(const UNISTR2 *pwd, uchar nt_p16[16]);
+);
+NTSTATUS cli_spoolss_addprinterdriver (
+ struct cli_state *cli,
+ TALLOC_CTX *mem_ctx,
+ uint32 level,
+ PRINTER_DRIVER_CTR *ctr
+);
+NTSTATUS cli_spoolss_addprinterex (
+ struct cli_state *cli,
+ TALLOC_CTX *mem_ctx,
+ uint32 level,
+ PRINTER_INFO_CTR *ctr
+);
+NTSTATUS cli_spoolss_deleteprinterdriver (
+ struct cli_state *cli,
+ TALLOC_CTX *mem_ctx,
+ char *arch,
+ char *driver
+);
+NTSTATUS cli_spoolss_getprintprocessordirectory(struct cli_state *cli,
+ TALLOC_CTX *mem_ctx,
+ char *name,
+ char *environment,
+ fstring procdir);
+NTSTATUS cli_spoolss_setprinterdata (struct cli_state *cli, TALLOC_CTX *mem_ctx,
+ POLICY_HND *pol, char* valname, char* value);
-/*The following definitions come from libsmb/smberr.c */
+/*The following definitions come from libsmb/cli_srvsvc.c */
-char *smb_dos_err_name(uint8 class, uint16 num);
-char *get_dos_error_msg(WERROR result);
-char *smb_dos_err_class(uint8 class);
-char *smb_dos_errstr(char *inbuf);
-char *werror_str(WERROR status);
-WERROR map_werror_from_unix(int error);
+struct cli_state *cli_svrsvc_initialise(struct cli_state *cli,
+ char *system_name,
+ struct ntuser_creds *creds);
+NTSTATUS cli_srvsvc_net_srv_get_info(struct cli_state *cli,
+ TALLOC_CTX *mem_ctx,
+ uint32 switch_value, SRV_INFO_CTR *ctr);
-/*The following definitions come from libsmb/unexpected.c */
+/*The following definitions come from libsmb/cliconnect.c */
-void unexpected_packet(struct packet_struct *p);
-void clear_unexpected(time_t t);
-struct packet_struct *receive_unexpected(enum packet_type packet_type, int id,
- char *mailslot_name);
+BOOL cli_session_setup(struct cli_state *cli,
+ char *user,
+ char *pass, int passlen,
+ char *ntpass, int ntpasslen,
+ char *workgroup);
+BOOL cli_ulogoff(struct cli_state *cli);
+BOOL cli_send_tconX(struct cli_state *cli,
+ const char *share, const char *dev, const char *pass, int passlen);
+BOOL cli_tdis(struct cli_state *cli);
+void cli_negprot_send(struct cli_state *cli);
+BOOL cli_negprot(struct cli_state *cli);
+BOOL cli_session_request(struct cli_state *cli,
+ struct nmb_name *calling, struct nmb_name *called);
+BOOL cli_connect(struct cli_state *cli, const char *host, struct in_addr *ip);
+BOOL cli_establish_connection(struct cli_state *cli,
+ char *dest_host, struct in_addr *dest_ip,
+ struct nmb_name *calling, struct nmb_name *called,
+ char *service, char *service_type,
+ BOOL do_shutdown, BOOL do_tcon);
+BOOL attempt_netbios_session_request(struct cli_state *cli, char *srchost, char *desthost,
+ struct in_addr *pdest_ip);
-/*The following definitions come from lib/snprintf.c */
+/*The following definitions come from libsmb/clidgram.c */
+int cli_send_mailslot(int dgram_sock, BOOL unique, char *mailslot,
+ char *buf, int len,
+ const char *srcname, int src_type,
+ const char *dstname, int dest_type,
+ struct in_addr dest_ip, struct in_addr src_ip,
+ int dest_port, int src_port);
+int cli_get_response(int dgram_sock, BOOL unique, char *mailslot, char *buf, int bufsiz);
+int cli_get_backup_list(const char *myname, const char *send_to_name);
+int cli_get_backup_server(char *my_name, char *target, char *servername, int namesize);
-/*The following definitions come from lib/substitute.c */
+/*The following definitions come from libsmb/clientgen.c */
-void standard_sub_basic(char *str);
-void standard_sub_advanced(int snum, char *user, char *connectpath, gid_t gid, char *str);
-void standard_sub_conn(connection_struct *conn, char *str);
-void standard_sub_home(int snum, char *user, char *str);
-void standard_sub_snum(int snum, char *str);
-void standard_sub_vuser(char *str, user_struct *vuser);
-void standard_sub_vsnum(char *str, user_struct *vuser, int snum);
+int cli_set_port(struct cli_state *cli, int port);
+BOOL cli_receive_smb(struct cli_state *cli);
+BOOL cli_send_smb(struct cli_state *cli);
+void cli_setup_packet(struct cli_state *cli);
+void cli_setup_bcc(struct cli_state *cli, void *p);
+void cli_init_creds(struct cli_state *cli, const struct ntuser_creds *usr);
+struct cli_state *cli_initialise(struct cli_state *cli);
+void cli_shutdown(struct cli_state *cli);
+void cli_sockopt(struct cli_state *cli, char *options);
+uint16 cli_setpid(struct cli_state *cli, uint16 pid);
-/*The following definitions come from lib/sysacls.c */
+/*The following definitions come from libsmb/clierror.c */
-int sys_acl_get_entry( SMB_ACL_T the_acl, int entry_id, SMB_ACL_ENTRY_T *entry_p);
-int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p);
-int sys_acl_get_permset( SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p);
-void *sys_acl_get_qualifier( SMB_ACL_ENTRY_T entry_d);
-SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type);
-SMB_ACL_T sys_acl_get_fd(int fd);
-int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset);
-int sys_acl_add_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
-int sys_acl_get_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
-char *sys_acl_to_text( SMB_ACL_T the_acl, ssize_t *plen);
-SMB_ACL_T sys_acl_init( int count);
-int sys_acl_create_entry( SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry);
-int sys_acl_set_tag_type( SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype);
-int sys_acl_set_qualifier( SMB_ACL_ENTRY_T entry, void *qual);
-int sys_acl_set_permset( SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset);
-int sys_acl_valid( SMB_ACL_T theacl );
-int sys_acl_set_file( const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl);
-int sys_acl_set_fd( int fd, SMB_ACL_T theacl);
-int sys_acl_delete_def_file(const char *name);
-int sys_acl_free_text(char *text);
-int sys_acl_free_acl(SMB_ACL_T the_acl) ;
-int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype);
-int sys_acl_get_entry( SMB_ACL_T the_acl, int entry_id, SMB_ACL_ENTRY_T *entry_p);
-int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p);
-int sys_acl_get_permset( SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p);
-void *sys_acl_get_qualifier( SMB_ACL_ENTRY_T entry_d);
-SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type);
-SMB_ACL_T sys_acl_get_fd(int fd);
-int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset);
-int sys_acl_add_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
-int sys_acl_get_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
-char *sys_acl_to_text( SMB_ACL_T the_acl, ssize_t *plen);
-SMB_ACL_T sys_acl_init( int count);
-int sys_acl_create_entry( SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry);
-int sys_acl_set_tag_type( SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype);
-int sys_acl_set_qualifier( SMB_ACL_ENTRY_T entry, void *qual);
-int sys_acl_set_permset( SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset);
-int sys_acl_valid( SMB_ACL_T theacl );
-int sys_acl_set_file( const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl);
-int sys_acl_set_fd( int fd, SMB_ACL_T theacl);
-int sys_acl_delete_def_file(const char *name);
-int sys_acl_free_text(char *text);
-int sys_acl_free_acl(SMB_ACL_T the_acl) ;
-int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype);
-int sys_acl_get_entry(SMB_ACL_T acl_d, int entry_id, SMB_ACL_ENTRY_T *entry_p);
-int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *type_p);
-int sys_acl_get_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p);
-void *sys_acl_get_qualifier(SMB_ACL_ENTRY_T entry_d);
-SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL_TYPE_T type);
-SMB_ACL_T sys_acl_get_fd(int fd);
-int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset_d);
-int sys_acl_add_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm);
-int sys_acl_get_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm);
-char *sys_acl_to_text(SMB_ACL_T acl_d, ssize_t *len_p);
-SMB_ACL_T sys_acl_init(int count);
-int sys_acl_create_entry(SMB_ACL_T *acl_p, SMB_ACL_ENTRY_T *entry_p);
-int sys_acl_set_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T tag_type);
-int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry_d, void *qual_p);
-int sys_acl_set_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T permset_d);
-int sys_acl_valid(SMB_ACL_T acl_d);
-int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d);
-int sys_acl_set_fd(int fd, SMB_ACL_T acl_d);
-int sys_acl_delete_def_file(const char *path);
-int sys_acl_free_text(char *text);
-int sys_acl_free_acl(SMB_ACL_T acl_d) ;
-int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype);
-int sys_acl_get_entry(SMB_ACL_T acl_d, int entry_id, SMB_ACL_ENTRY_T *entry_p);
-int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *type_p);
-int sys_acl_get_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p);
-void *sys_acl_get_qualifier(SMB_ACL_ENTRY_T entry_d);
-SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL_TYPE_T type);
-SMB_ACL_T sys_acl_get_fd(int fd);
-int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset_d);
-int sys_acl_add_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm);
-int sys_acl_get_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm);
-char *sys_acl_to_text(SMB_ACL_T acl_d, ssize_t *len_p);
-SMB_ACL_T sys_acl_init(int count);
-int sys_acl_create_entry(SMB_ACL_T *acl_p, SMB_ACL_ENTRY_T *entry_p);
-int sys_acl_set_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T tag_type);
-int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry_d, void *qual_p);
-int sys_acl_set_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T permset_d);
-int sys_acl_valid(SMB_ACL_T acl_d);
-int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d);
-int sys_acl_set_fd(int fd, SMB_ACL_T acl_d);
-int sys_acl_delete_def_file(const char *path);
-int sys_acl_free_text(char *text);
-int sys_acl_free_acl(SMB_ACL_T acl_d) ;
-int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype);
-int sys_acl_get_entry(SMB_ACL_T acl_d, int entry_id, SMB_ACL_ENTRY_T *entry_p);
-int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *type_p);
-int sys_acl_get_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p);
-void *sys_acl_get_qualifier(SMB_ACL_ENTRY_T entry_d);
-SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL_TYPE_T type);
-SMB_ACL_T sys_acl_get_fd(int fd);
-int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset_d);
-int sys_acl_add_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm);
-int sys_acl_get_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm);
-char *sys_acl_to_text(SMB_ACL_T acl_d, ssize_t *len_p);
-SMB_ACL_T sys_acl_init(int count);
-int sys_acl_create_entry(SMB_ACL_T *acl_p, SMB_ACL_ENTRY_T *entry_p);
-int sys_acl_set_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T tag_type);
-int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry_d, void *qual_p);
-int sys_acl_set_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T permset_d);
-int sys_acl_valid(SMB_ACL_T acl_d);
-int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d);
-int sys_acl_set_fd(int fd, SMB_ACL_T acl_d);
-int sys_acl_delete_def_file(const char *name);
-int sys_acl_free_text(char *text);
-int sys_acl_free_acl(SMB_ACL_T acl_d) ;
-int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype);
-int sys_acl_get_entry( SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p);
-int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p);
-int sys_acl_get_permset( SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p);
-void *sys_acl_get_qualifier( SMB_ACL_ENTRY_T entry_d);
-SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type);
-SMB_ACL_T sys_acl_get_fd(int fd);
-int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset);
-int sys_acl_add_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
-char *sys_acl_to_text( SMB_ACL_T theacl, ssize_t *plen);
-SMB_ACL_T sys_acl_init( int count);
-int sys_acl_create_entry( SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry);
-int sys_acl_set_tag_type( SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype);
-int sys_acl_set_qualifier( SMB_ACL_ENTRY_T entry, void *qual);
-int sys_acl_set_permset( SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset);
-int sys_acl_valid( SMB_ACL_T theacl );
-int sys_acl_set_file( const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl);
-int sys_acl_set_fd( int fd, SMB_ACL_T theacl);
-int sys_acl_delete_def_file(const char *name);
-int sys_acl_get_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
-int sys_acl_free_text(char *text);
-int sys_acl_free_acl(SMB_ACL_T posix_acl);
-int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype);
-int sys_acl_get_entry( SMB_ACL_T the_acl, int entry_id, SMB_ACL_ENTRY_T *entry_p);
-int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p);
-int sys_acl_get_permset( SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p);
-void *sys_acl_get_qualifier( SMB_ACL_ENTRY_T entry_d);
-SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type);
-SMB_ACL_T sys_acl_get_fd(int fd);
-int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset);
-int sys_acl_add_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
-int sys_acl_get_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
-char *sys_acl_to_text( SMB_ACL_T the_acl, ssize_t *plen);
-int sys_acl_free_text(char *text);
-SMB_ACL_T sys_acl_init( int count);
-int sys_acl_create_entry( SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry);
-int sys_acl_set_tag_type( SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype);
-int sys_acl_set_qualifier( SMB_ACL_ENTRY_T entry, void *qual);
-int sys_acl_set_permset( SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset);
-int sys_acl_valid( SMB_ACL_T theacl );
-int sys_acl_set_file( const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl);
-int sys_acl_set_fd( int fd, SMB_ACL_T theacl);
-int sys_acl_delete_def_file(const char *name);
-int sys_acl_free_acl(SMB_ACL_T the_acl) ;
-int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype);
+char *cli_errstr(struct cli_state *cli);
+NTSTATUS cli_nt_error(struct cli_state *cli);
+void cli_dos_error(struct cli_state *cli, uint8 *eclass, uint32 *ecode);
+int cli_errno_from_dos(uint8 eclass, uint32 num);
+int cli_errno_from_nt(NTSTATUS status);
+int cli_errno(struct cli_state *cli);
+BOOL cli_is_error(struct cli_state *cli);
+BOOL cli_is_nt_error(struct cli_state *cli);
+BOOL cli_is_dos_error(struct cli_state *cli);
-/*The following definitions come from lib/system.c */
+/*The following definitions come from libsmb/clifile.c */
-int sys_usleep(long usecs);
-int sys_stat(const char *fname,SMB_STRUCT_STAT *sbuf);
-int sys_fstat(int fd,SMB_STRUCT_STAT *sbuf);
-int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf);
-int sys_ftruncate(int fd, SMB_OFF_T offset);
-SMB_OFF_T sys_lseek(int fd, SMB_OFF_T offset, int whence);
-int sys_fseek(FILE *fp, SMB_OFF_T offset, int whence);
-SMB_OFF_T sys_ftell(FILE *fp);
-int sys_creat(const char *path, mode_t mode);
-int sys_open(const char *path, int oflag, mode_t mode);
-FILE *sys_fopen(const char *path, const char *type);
-SMB_STRUCT_DIRENT *sys_readdir(DIR *dirp);
-int sys_mknod(const char *path, mode_t mode, SMB_DEV_T dev);
-char *sys_realpath(const char *path, char *resolved_path);
-int sys_waitpid(pid_t pid,int *status,int options);
-char *sys_getwd(char *s);
-int sys_symlink(const char *oldpath, const char *newpath);
-int sys_readlink(const char *path, char *buf, size_t bufsiz);
-int sys_link(const char *oldpath, const char *newpath);
-int sys_chown(const char *fname,uid_t uid,gid_t gid);
-int sys_chroot(const char *dname);
-struct hostent *sys_gethostbyname(const char *name);
-void oplock_set_capability(BOOL this_process, BOOL inherit);
-long sys_random(void);
-void sys_srandom(unsigned int seed);
-int groups_max(void);
-int sys_getgroups(int setlen, gid_t *gidset);
-int sys_setgroups(int setlen, gid_t *gidset);
-void sys_setpwent(void);
-struct passwd *sys_getpwent(void);
-void sys_endpwent(void);
-struct passwd *sys_getpwnam(const char *name);
-struct passwd *sys_getpwuid(uid_t uid);
-int wsys_stat(const smb_ucs2_t *wfname,SMB_STRUCT_STAT *sbuf);
-int wsys_lstat(const smb_ucs2_t *wfname,SMB_STRUCT_STAT *sbuf);
-int wsys_creat(const smb_ucs2_t *wfname, mode_t mode);
-int wsys_open(const smb_ucs2_t *wfname, int oflag, mode_t mode);
-FILE *wsys_fopen(const smb_ucs2_t *wfname, const char *type);
-DIR *wsys_opendir(const smb_ucs2_t *wfname);
-smb_ucs2_t *wsys_getwd(smb_ucs2_t *s);
-int wsys_chown(const smb_ucs2_t *wfname, uid_t uid, gid_t gid);
-int wsys_chroot(const smb_ucs2_t *wfname);
-pid_t sys_fork(void);
-pid_t sys_getpid(void);
-int sys_popen(const char *command);
-int sys_pclose(int fd);
-void *sys_dlopen(const char *name, int flags);
-void *sys_dlsym(void *handle, char *symbol);
-int sys_dlclose (void *handle);
-const char *sys_dlerror(void);
+uint32 unix_perms_to_wire(mode_t perms);
+BOOL cli_unix_symlink(struct cli_state *cli, const char *fname_src, const char *fname_dst);
+BOOL cli_unix_hardlink(struct cli_state *cli, const char *fname_src, const char *fname_dst);
+BOOL cli_unix_chmod(struct cli_state *cli, const char *fname, mode_t mode);
+BOOL cli_unix_chown(struct cli_state *cli, const char *fname, uid_t uid, gid_t gid);
+BOOL cli_rename(struct cli_state *cli, const char *fname_src, const char *fname_dst);
+BOOL cli_unlink(struct cli_state *cli, const char *fname);
+BOOL cli_mkdir(struct cli_state *cli, const char *dname);
+BOOL cli_rmdir(struct cli_state *cli, const char *dname);
+int cli_nt_delete_on_close(struct cli_state *cli, int fnum, BOOL flag);
+int cli_nt_create_full(struct cli_state *cli, const char *fname, uint32 DesiredAccess,
+ uint32 FileAttributes, uint32 ShareAccess,
+ uint32 CreateDisposition, uint32 CreateOptions);
+int cli_nt_create(struct cli_state *cli, const char *fname, uint32 DesiredAccess);
+int cli_open(struct cli_state *cli, const char *fname, int flags, int share_mode);
+BOOL cli_close(struct cli_state *cli, int fnum);
+BOOL cli_lock(struct cli_state *cli, int fnum,
+ uint32 offset, uint32 len, int timeout, enum brl_type lock_type);
+BOOL cli_unlock(struct cli_state *cli, int fnum, uint32 offset, uint32 len);
+BOOL cli_lock64(struct cli_state *cli, int fnum,
+ SMB_BIG_UINT offset, SMB_BIG_UINT len, int timeout, enum brl_type lock_type);
+BOOL cli_unlock64(struct cli_state *cli, int fnum, SMB_BIG_UINT offset, SMB_BIG_UINT len);
+BOOL cli_getattrE(struct cli_state *cli, int fd,
+ uint16 *attr, size_t *size,
+ time_t *c_time, time_t *a_time, time_t *m_time);
+BOOL cli_getatr(struct cli_state *cli, const char *fname,
+ uint16 *attr, size_t *size, time_t *t);
+BOOL cli_setatr(struct cli_state *cli, const char *fname, uint16 attr, time_t t);
+BOOL cli_chkpath(struct cli_state *cli, const char *path);
+BOOL cli_dskattr(struct cli_state *cli, int *bsize, int *total, int *avail);
+int cli_ctemp(struct cli_state *cli, const char *path, char **tmp_path);
-/*The following definitions come from lib/talloc.c */
+/*The following definitions come from libsmb/clilist.c */
-TALLOC_CTX *talloc_init(void);
-void *talloc(TALLOC_CTX *t, size_t size);
-void *talloc_realloc(TALLOC_CTX *t, void *ptr, size_t size);
-void talloc_destroy_pool(TALLOC_CTX *t);
-void talloc_destroy(TALLOC_CTX *t);
-size_t talloc_pool_size(TALLOC_CTX *t);
-void *talloc_zero(TALLOC_CTX *t, size_t size);
-void *talloc_memdup(TALLOC_CTX *t, void *p, size_t size);
-char *talloc_strdup(TALLOC_CTX *t, char *p);
+int cli_list_new(struct cli_state *cli,const char *Mask,uint16 attribute,
+ void (*fn)(file_info *, const char *, void *), void *state);
+int cli_list_old(struct cli_state *cli,const char *Mask,uint16 attribute,
+ void (*fn)(file_info *, const char *, void *), void *state);
+int cli_list(struct cli_state *cli,const char *Mask,uint16 attribute,
+ void (*fn)(file_info *, const char *, void *), void *state);
-/*The following definitions come from lib/time.c */
+/*The following definitions come from libsmb/climessage.c */
-time_t get_time_t_min(void);
-time_t get_time_t_max(void);
-void GetTimeOfDay(struct timeval *tval);
-void TimeInit(void);
-void get_process_uptime(struct timeval *ret_time);
-int TimeDiff(time_t t);
-struct tm *LocalTime(time_t *t);
-time_t nt_time_to_unix(NTTIME *nt);
-time_t nt_time_to_unix_abs(NTTIME *nt);
-time_t interpret_long_date(char *p);
-void unix_to_nt_time(NTTIME *nt, time_t t);
-void unix_to_nt_time_abs(NTTIME *nt, time_t t);
-void put_long_date(char *p,time_t t);
-BOOL null_mtime(time_t mtime);
-void put_dos_date(char *buf,int offset,time_t unixdate);
-void put_dos_date2(char *buf,int offset,time_t unixdate);
-void put_dos_date3(char *buf,int offset,time_t unixdate);
-time_t make_unix_date(void *date_ptr);
-time_t make_unix_date2(void *date_ptr);
-time_t make_unix_date3(void *date_ptr);
-char *http_timestring(time_t t);
-char *timestring(BOOL hires);
-time_t get_create_time(SMB_STRUCT_STAT *st,BOOL fake_dirs);
-void init_nt_time(NTTIME *nt);
+BOOL cli_message_start(struct cli_state *cli, char *host, char *username,
+ int *grp);
+BOOL cli_message_text(struct cli_state *cli, char *msg, int len, int grp);
+BOOL cli_message_end(struct cli_state *cli, int grp);
-/*The following definitions come from lib/ufc.c */
+/*The following definitions come from libsmb/clioplock.c */
-char *ufc_crypt(const char *key,const char *salt);
+BOOL cli_oplock_ack(struct cli_state *cli, int fnum, unsigned char level);
+void cli_oplock_handler(struct cli_state *cli,
+ BOOL (*handler)(struct cli_state *, int, unsigned char));
-/*The following definitions come from lib/username.c */
+/*The following definitions come from libsmb/cliprint.c */
-BOOL name_is_local(const char *name);
-char *get_user_home_dir(char *user);
-char *get_user_service_home_dir(char *user);
-BOOL map_username(char *user);
-struct passwd *Get_Pwnam(char *user,BOOL allow_change);
-BOOL user_in_group_list(char *user,char *gname);
-BOOL user_in_list(char *user,char *list);
-struct passwd *smb_getpwnam(char *user, BOOL allow_change);
+int cli_print_queue(struct cli_state *cli,
+ void (*fn)(struct print_job_info *));
+int cli_printjob_del(struct cli_state *cli, int job);
-/*The following definitions come from lib/util.c */
+/*The following definitions come from libsmb/clirap.c */
-char *tmpdir(void);
-BOOL in_group(gid_t group, gid_t current_gid, int ngroups, gid_t *groups);
-char *Atoic(char *p, int *n, char *c);
-char *get_numlist(char *p, uint32 **num, int *count);
-BOOL file_exist(char *fname,SMB_STRUCT_STAT *sbuf);
-time_t file_modtime(char *fname);
-BOOL directory_exist(char *dname,SMB_STRUCT_STAT *st);
-SMB_OFF_T get_file_size(char *file_name);
-char *attrib_string(uint16 mode);
-void show_msg(char *buf);
-void smb_setlen(char *buf,int len);
-int set_message(char *buf,int num_words,int num_bytes,BOOL zero);
-int set_message_bcc(char *buf,int num_bytes);
-int set_message_end(void *outbuf,void *end_ptr);
-void dos_clean_name(char *s);
-void unix_clean_name(char *s);
-void make_dir_struct(char *buf,char *mask,char *fname,SMB_OFF_T size,int mode,time_t date);
-void close_low_fds(void);
-int set_blocking(int fd, BOOL set);
-ssize_t transfer_file_internal(int infd, int outfd, size_t n, ssize_t (*read_fn)(int, void *, size_t),
- ssize_t (*write_fn)(int, const void *, size_t));
-SMB_OFF_T transfer_file(int infd,int outfd,SMB_OFF_T n);
-void msleep(int t);
-void become_daemon(void);
-BOOL yesno(char *p);
-void *Realloc(void *p,size_t size);
-void safe_free(void *p);
-BOOL get_myname(char *my_name);
-int interpret_protocol(char *str,int def);
-BOOL is_ipaddress(const char *str);
-uint32 interpret_addr(const char *str);
-struct in_addr *interpret_addr2(const char *str);
-BOOL zero_ip(struct in_addr ip);
-char *automount_lookup(char *user_name);
-char *automount_lookup(char *user_name);
-BOOL same_net(struct in_addr ip1,struct in_addr ip2,struct in_addr mask);
-BOOL process_exists(pid_t pid);
-char *uidtoname(uid_t uid);
-char *gidtoname(gid_t gid);
-uid_t nametouid(char *name);
-gid_t nametogid(char *name);
-void smb_panic(char *why);
-char *readdirname(DIR *p);
-BOOL is_in_path(char *name, name_compare_entry *namelist);
-void set_namearray(name_compare_entry **ppname_array, char *namelist);
-void free_namearray(name_compare_entry *name_array);
-BOOL fcntl_lock(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type);
-BOOL is_myname(char *s);
-BOOL is_myname_or_ipaddr(char *s);
-void set_remote_arch(enum remote_arch_types type);
-enum remote_arch_types get_remote_arch(void);
-void out_ascii(FILE *f, unsigned char *buf,int len);
-void out_data(FILE *f,char *buf1,int len, int per_line);
-void print_asc(int level, unsigned char *buf,int len);
-void dump_data(int level,char *buf1,int len);
-char *tab_depth(int depth);
-int str_checksum(const char *s);
-void zero_free(void *p, size_t size);
-int set_maxfiles(int requested_max);
-BOOL reg_split_key(char *full_keyname, uint32 *reg_type, char *key_name);
-int smb_mkstemp(char *template);
-void *smb_xmalloc(size_t size);
-void *xmemdup(const void *p, size_t size);
-char *xstrdup(const char *s);
-void *memdup(void *p, size_t size);
-char *myhostname(void);
-char *lock_path(char *name);
-char *parent_dirname(const char *path);
-BOOL ms_has_wild(char *s);
-BOOL mask_match(char *string, char *pattern, BOOL is_case_sensitive);
-BOOL unix_wild_match(char *pattern, char *string);
-int _Insure_trap_error(int a1, int a2, int a3, int a4, int a5, int a6);
+BOOL cli_api_pipe(struct cli_state *cli, char *pipe_name,
+ uint16 *setup, uint32 setup_count, uint32 max_setup_count,
+ char *params, uint32 param_count, uint32 max_param_count,
+ char *data, uint32 data_count, uint32 max_data_count,
+ char **rparam, uint32 *rparam_count,
+ char **rdata, uint32 *rdata_count);
+BOOL cli_api(struct cli_state *cli,
+ char *param, int prcnt, int mprcnt,
+ char *data, int drcnt, int mdrcnt,
+ char **rparam, int *rprcnt,
+ char **rdata, int *rdrcnt);
+BOOL cli_NetWkstaUserLogon(struct cli_state *cli,char *user, char *workstation);
+int cli_RNetShareEnum(struct cli_state *cli, void (*fn)(const char *, uint32, const char *, void *), void *state);
+BOOL cli_NetServerEnum(struct cli_state *cli, char *workgroup, uint32 stype,
+ void (*fn)(const char *, uint32, const char *, void *),
+ void *state);
+BOOL cli_oem_change_password(struct cli_state *cli, const char *user, const char *new_password,
+ const char *old_password);
+BOOL cli_qpathinfo(struct cli_state *cli, const char *fname,
+ time_t *c_time, time_t *a_time, time_t *m_time,
+ size_t *size, uint16 *mode);
+BOOL cli_qpathinfo2(struct cli_state *cli, const char *fname,
+ time_t *c_time, time_t *a_time, time_t *m_time,
+ time_t *w_time, size_t *size, uint16 *mode,
+ SMB_INO_T *ino);
+BOOL cli_qfileinfo(struct cli_state *cli, int fnum,
+ uint16 *mode, size_t *size,
+ time_t *c_time, time_t *a_time, time_t *m_time,
+ time_t *w_time, SMB_INO_T *ino);
+BOOL cli_qfileinfo_test(struct cli_state *cli, int fnum, int level, char *outdata);
+NTSTATUS cli_qpathinfo_alt_name(struct cli_state *cli, const char *fname, fstring alt_name);
-/*The following definitions come from lib/util_file.c */
+/*The following definitions come from libsmb/clireadwrite.c */
-BOOL do_file_lock(int fd, int waitsecs, int type);
-BOOL file_lock(int fd, int type, int secs, int *plock_depth);
-BOOL file_unlock(int fd, int *plock_depth);
-void *startfilepwent(char *pfile, char *s_readbuf, int bufsize,
- int *file_lock_depth, BOOL update);
-void endfilepwent(void *vp, int *file_lock_depth);
-SMB_BIG_UINT getfilepwpos(void *vp);
-BOOL setfilepwpos(void *vp, SMB_BIG_UINT tok);
-int getfileline(void *vp, char *linebuf, int linebuf_size);
-char *fgets_slash(char *s2,int maxlen,FILE *f);
-char *file_pload(char *syscmd, size_t *size);
-char *fd_load(int fd, size_t *size);
-char *file_load(char *fname, size_t *size);
-char **file_lines_load(char *fname, int *numlines, BOOL convert);
-char **fd_lines_load(int fd, int *numlines, BOOL convert);
-char **file_lines_pload(char *syscmd, int *numlines, BOOL convert);
-void file_lines_free(char **lines);
-void file_lines_slashcont(char **lines);
+ssize_t cli_read(struct cli_state *cli, int fnum, char *buf, off_t offset, size_t size);
+ssize_t cli_readraw(struct cli_state *cli, int fnum, char *buf, off_t offset, size_t size);
+ssize_t cli_write(struct cli_state *cli,
+ int fnum, uint16 write_mode,
+ char *buf, off_t offset, size_t size);
+ssize_t cli_smbwrite(struct cli_state *cli,
+ int fnum, char *buf, off_t offset, size_t size1);
-/*The following definitions come from lib/util_getent.c */
+/*The following definitions come from libsmb/clisecdesc.c */
-struct sys_grent * getgrent_list(void);
-void grent_free (struct sys_grent *glist);
-struct sys_pwent * getpwent_list(void);
-void pwent_free (struct sys_pwent *plist);
-struct sys_userlist *get_users_in_group(const char *gname);
-void free_userlist(struct sys_userlist *list_head);
+SEC_DESC *cli_query_secdesc(struct cli_state *cli, int fnum,
+ TALLOC_CTX *mem_ctx);
+BOOL cli_set_secdesc(struct cli_state *cli, int fnum, SEC_DESC *sd);
-/*The following definitions come from lib/util_seaccess.c */
+/*The following definitions come from libsmb/clistr.c */
-void se_map_generic(uint32 *access_mask, struct generic_mapping *mapping);
-BOOL se_access_check(SEC_DESC *sd, NT_USER_TOKEN *token,
- uint32 acc_desired, uint32 *acc_granted,
- NTSTATUS *status);
-SEC_DESC_BUF *se_create_child_secdesc(TALLOC_CTX *ctx, SEC_DESC *parent_ctr,
- BOOL child_container);
+int clistr_push(struct cli_state *cli, void *dest, const char *src, int dest_len, int flags);
+int clistr_pull(struct cli_state *cli, char *dest, const void *src, int dest_len, int src_len, int flags);
+int clistr_align_out(struct cli_state *cli, const void *p, int flags);
+int clistr_align_in(struct cli_state *cli, const void *p, int flags);
-/*The following definitions come from lib/util_sec.c */
+/*The following definitions come from libsmb/clitrans.c */
-void sec_init(void);
-uid_t sec_initial_uid(void);
-gid_t sec_initial_gid(void);
-BOOL non_root_mode(void);
-void gain_root_privilege(void);
-void gain_root_group_privilege(void);
-void set_effective_uid(uid_t uid);
-void set_effective_gid(gid_t gid);
-void save_re_uid(void);
-void restore_re_uid(void);
-int set_re_uid(void);
-void become_user_permanently(uid_t uid, gid_t gid);
-BOOL is_setuid_root(void) ;
+BOOL cli_send_trans(struct cli_state *cli, int trans,
+ const char *pipe_name,
+ int fid, int flags,
+ uint16 *setup, int lsetup, int msetup,
+ char *param, int lparam, int mparam,
+ char *data, int ldata, int mdata);
+BOOL cli_receive_trans(struct cli_state *cli,int trans,
+ char **param, int *param_len,
+ char **data, int *data_len);
+BOOL cli_send_nt_trans(struct cli_state *cli,
+ int function,
+ int flags,
+ uint16 *setup, int lsetup, int msetup,
+ char *param, int lparam, int mparam,
+ char *data, int ldata, int mdata);
+BOOL cli_receive_nt_trans(struct cli_state *cli,
+ char **param, int *param_len,
+ char **data, int *data_len);
-/*The following definitions come from lib/util_sid.c */
+/*The following definitions come from libsmb/credentials.c */
-void generate_wellknown_sids(void);
-BOOL map_domain_sid_to_name(DOM_SID *sid, char *nt_domain);
-BOOL lookup_known_rid(DOM_SID *sid, uint32 rid, char *name, enum SID_NAME_USE *psid_name_use);
-BOOL map_domain_name_to_sid(DOM_SID *sid, char *nt_domain);
-void split_domain_name(const char *fullname, char *domain, char *name);
-char *sid_to_string(fstring sidstr_out, DOM_SID *sid);
-BOOL string_to_sid(DOM_SID *sidout, const char *sidstr);
-BOOL sid_append_rid(DOM_SID *sid, uint32 rid);
-BOOL sid_split_rid(DOM_SID *sid, uint32 *rid);
-BOOL sid_peek_rid(DOM_SID *sid, uint32 *rid);
-void sid_copy(DOM_SID *dst, const DOM_SID *src);
-DOM_SID *sid_dup(DOM_SID *src);
-BOOL sid_linearize(char *outbuf, size_t len, DOM_SID *sid);
-int sid_compare(const DOM_SID *sid1, const DOM_SID *sid2);
-BOOL sid_equal(const DOM_SID *sid1, const DOM_SID *sid2);
-size_t sid_size(DOM_SID *sid);
-BOOL non_mappable_sid(DOM_SID *sid);
+char *credstr(uchar *cred);
+void cred_session_key(DOM_CHAL *clnt_chal, DOM_CHAL *srv_chal, char *pass,
+ uchar session_key[8]);
+void cred_create(uchar session_key[8], DOM_CHAL *stor_cred, UTIME timestamp,
+ DOM_CHAL *cred);
+int cred_assert(DOM_CHAL *cred, uchar session_key[8], DOM_CHAL *stored_cred,
+ UTIME timestamp);
+BOOL clnt_deal_with_creds(uchar sess_key[8],
+ DOM_CRED *sto_clnt_cred, DOM_CRED *rcv_srv_cred);
+BOOL deal_with_creds(uchar sess_key[8],
+ DOM_CRED *sto_clnt_cred,
+ DOM_CRED *rcv_clnt_cred, DOM_CRED *rtn_srv_cred);
-/*The following definitions come from lib/util_sock.c */
+/*The following definitions come from libsmb/errormap.c */
-BOOL is_a_socket(int fd);
-void set_socket_options(int fd, char *options);
-ssize_t read_udp_socket(int fd,char *buf,size_t len);
-ssize_t read_with_timeout(int fd,char *buf,size_t mincnt,size_t maxcnt,unsigned int time_out);
-BOOL send_keepalive(int client);
-ssize_t read_data(int fd,char *buffer,size_t N);
-ssize_t write_data(int fd,char *buffer,size_t N);
-ssize_t write_socket_data(int fd,char *buffer,size_t N);
-ssize_t write_socket(int fd,char *buf,size_t len);
-ssize_t read_smb_length(int fd,char *inbuf,unsigned int timeout);
-BOOL receive_smb(int fd,char *buffer, unsigned int timeout);
-BOOL client_receive_smb(int fd,char *buffer, unsigned int timeout);
-BOOL send_smb(int fd,char *buffer);
-BOOL send_one_packet(char *buf,int len,struct in_addr ip,int port,int type);
-int open_socket_in( int type, int port, int dlevel, uint32 socket_addr, BOOL rebind );
-int open_socket_out(int type, struct in_addr *addr, int port ,int timeout);
-void client_setfd(int fd);
-char *client_name(void);
-char *client_addr(void);
-char *get_socket_name(int fd);
-char *get_socket_addr(int fd);
-int open_pipe_sock(char *path);
-int sock_exec(const char *prog);
+NTSTATUS dos_to_ntstatus(int eclass, int ecode);
+void ntstatus_to_dos(NTSTATUS ntstatus, uint8 *eclass, uint32 *ecode);
+NTSTATUS werror_to_ntstatus(WERROR error);
+WERROR ntstatus_to_werror(NTSTATUS error);
-/*The following definitions come from lib/util_str.c */
+/*The following definitions come from libsmb/namequery.c */
-void set_first_token(char *ptr);
-BOOL next_token(char **ptr,char *buff,char *sep, size_t bufsize);
-char **toktocliplist(int *ctok, char *sep);
-int StrCaseCmp(const char *s, const char *t);
-int StrnCaseCmp(const char *s, const char *t, size_t n);
-BOOL strequal(const char *s1, const char *s2);
-BOOL strnequal(const char *s1,const char *s2,size_t n);
-BOOL strcsequal(const char *s1,const char *s2);
-int strwicmp(char *psz1, char *psz2);
-void strlower(char *s);
-void strupper(char *s);
-void strnorm(char *s);
-BOOL strisnormal(char *s);
-void string_replace(char *s,char oldc,char newc);
-char *skip_string(char *buf,size_t n);
-size_t str_charnum(const char *s);
-BOOL trim_string(char *s,const char *front,const char *back);
-BOOL strhasupper(const char *s);
-BOOL strhaslower(const char *s);
-size_t count_chars(const char *s,char c);
-BOOL str_is_all(const char *s,char c);
-char *safe_strcpy(char *dest,const char *src, size_t maxlength);
-char *safe_strcat(char *dest, const char *src, size_t maxlength);
-char *alpha_strcpy(char *dest, const char *src, const char *other_safe_chars, size_t maxlength);
-char *StrnCpy(char *dest,const char *src,size_t n);
-char *strncpyn(char *dest, const char *src,size_t n, char c);
-size_t strhex_to_str(char *p, size_t len, const char *strhex);
-BOOL in_list(char *s,char *list,BOOL casesensitive);
-void string_free(char **s);
-BOOL string_set(char **dest,const char *src);
-void string_sub(char *s,const char *pattern,const char *insert, size_t len);
-void fstring_sub(char *s,const char *pattern,const char *insert);
-void pstring_sub(char *s,const char *pattern,const char *insert);
-void all_string_sub(char *s,const char *pattern,const char *insert, size_t len);
-void split_at_last_component(char *path, char *front, char sep, char *back);
-char *octal_string(int i);
-char *string_truncate(char *s, int length);
+struct node_status *node_status_query(int fd,struct nmb_name *name,
+ struct in_addr to_ip, int *num_names);
+BOOL name_status_find(const char *q_name, int q_type, int type, struct in_addr to_ip, char *name);
+BOOL name_register(int fd, const char *name, int name_type,
+ struct in_addr name_ip, int opcode,
+ BOOL bcast,
+ struct in_addr to_ip, int *count);
+struct in_addr *name_query(int fd,const char *name,int name_type,
+ BOOL bcast,BOOL recurse,
+ struct in_addr to_ip, int *count);
+FILE *startlmhosts(char *fname);
+BOOL getlmhostsent( FILE *fp, pstring name, int *name_type, struct in_addr *ipaddr);
+void endlmhosts(FILE *fp);
+BOOL name_register_wins(const char *name, int name_type);
+BOOL name_resolve_bcast(const char *name, int name_type,
+ struct in_addr **return_ip_list, int *return_count);
+BOOL resolve_name(const char *name, struct in_addr *return_ip, int name_type);
+BOOL resolve_srv_name(const char* srv_name, fstring dest_host,
+ struct in_addr *ip);
+BOOL find_master_ip(char *group, struct in_addr *master_ip);
+BOOL lookup_dc_name(const char *srcname, const char *domain,
+ struct in_addr *dc_ip, char *ret_name);
+BOOL get_dc_list(BOOL pdc_only, char *group, struct in_addr **ip_list, int *count);
+BOOL get_lmb_list(struct in_addr **ip_list, int *count);
+
+/*The following definitions come from libsmb/nmblib.c */
+
+void debug_nmb_packet(struct packet_struct *p);
+char *nmb_namestr(struct nmb_name *n);
+struct packet_struct *copy_packet(struct packet_struct *packet);
+void free_packet(struct packet_struct *packet);
+struct packet_struct *parse_packet(char *buf,int length,
+ enum packet_type packet_type);
+struct packet_struct *read_packet(int fd,enum packet_type packet_type);
+void make_nmb_name( struct nmb_name *n, const char *name, int type);
+BOOL nmb_name_equal(struct nmb_name *n1, struct nmb_name *n2);
+int build_packet(char *buf, struct packet_struct *p);
+BOOL send_packet(struct packet_struct *p);
+struct packet_struct *receive_packet(int fd,enum packet_type type,int t);
+struct packet_struct *receive_nmb_packet(int fd, int t, int trn_id);
+struct packet_struct *receive_dgram_packet(int fd, int t, char *mailslot_name);
+BOOL match_mailslot_name(struct packet_struct *p, char *mailslot_name);
+void sort_query_replies(char *data, int n, struct in_addr ip);
+char *dns_to_netbios_name(char *dns_name);
+int name_mangle( char *In, char *Out, char name_type );
+int name_extract(char *buf,int ofs,char *name);
+int name_len(char *s1);
+
+/*The following definitions come from libsmb/nterr.c */
+
+char *get_nt_error_msg(NTSTATUS nt_code);
+char *get_nt_error_c_code(NTSTATUS nt_code);
+
+/*The following definitions come from libsmb/passchange.c */
+
+BOOL remote_password_change(const char *remote_machine, const char *user_name,
+ const char *old_passwd, const char *new_passwd,
+ char *err_str, size_t err_str_len);
+
+/*The following definitions come from libsmb/pwd_cache.c */
+
+void pwd_init(struct pwd_info *pwd);
+BOOL pwd_is_nullpwd(const struct pwd_info *pwd);
+BOOL pwd_compare(struct pwd_info *pwd1, struct pwd_info *pwd2);
+void pwd_read(struct pwd_info *pwd, char *passwd_report, BOOL do_encrypt);
+void pwd_set_nullpwd(struct pwd_info *pwd);
+void pwd_set_cleartext(struct pwd_info *pwd, char *clr);
+void pwd_get_cleartext(struct pwd_info *pwd, char *clr);
+void pwd_set_lm_nt_16(struct pwd_info *pwd, uchar lm_pwd[16], uchar nt_pwd[16]);
+void pwd_get_lm_nt_16(struct pwd_info *pwd, uchar lm_pwd[16], uchar nt_pwd[16]);
+void pwd_make_lm_nt_16(struct pwd_info *pwd, char *clr);
+void pwd_make_lm_nt_owf(struct pwd_info *pwd, uchar cryptkey[8]);
+void pwd_get_lm_nt_owf(struct pwd_info *pwd, uchar lm_owf[24], uchar nt_owf[24]);
-/*The following definitions come from lib/util_unistr.c */
+/*The following definitions come from libsmb/smbdes.c */
-size_t unix_PutUniCode(char *dst,const char *src, ssize_t len, BOOL null_terminate);
-size_t dos_PutUniCode(char *dst,const char *src, ssize_t len, BOOL null_terminate);
-void unistr_to_dos(char *dest, const char *src, size_t len);
-char *skip_unibuf(char *src, size_t len);
-char *dos_unistrn2(uint16 *src, int len);
-char *dos_unistr2(uint16 *src);
-char *dos_unistr2_to_str(UNISTR2 *str);
-void ascii_to_unistr(uint16 *dest, const char *src, int maxlen);
-void unistr_to_ascii(char *dest, const uint16 *src, int len);
-void unistr2_to_ascii(char *dest, const UNISTR2 *str, size_t maxlen);
-uint32 buffer2_to_uint32(BUFFER2 *str);
-char *dos_buffer2_to_str(BUFFER2 *str);
-char *dos_buffer2_to_multistr(BUFFER2 *str);
-size_t dos_struni2(char *dst, const char *src, size_t max_len);
-char *dos_unistr(char *buf);
-int unistrcpy(char *dst, char *src);
-void default_unicode_map(smb_ucs2_t **pp_cp_to_ucs2, uint16 **pp_ucs2_to_cp);
-BOOL load_unicode_map(const char *codepage, smb_ucs2_t **pp_cp_to_ucs2, uint16 **pp_ucs2_to_cp);
-BOOL load_dos_unicode_map(int codepage);
-BOOL load_unix_unicode_map(const char *unix_char_set, BOOL override);
-smb_ucs2_t *multibyte_to_unicode(smb_ucs2_t *dst, const char *src,
- size_t dst_len, smb_ucs2_t *cp_to_ucs2);
-char *unicode_to_unix(char *dst, const smb_ucs2_t *src, size_t dst_len);
-smb_ucs2_t *unix_to_unicode(smb_ucs2_t *dst, const char *src, size_t dst_len);
-size_t unicode_to_unix_char(char *dst, const smb_ucs2_t src);
-char *unicode_to_dos(char *dst, const smb_ucs2_t *src, size_t dst_len);
-size_t unicode_to_dos_char(char *dst, const smb_ucs2_t src);
-smb_ucs2_t *dos_to_unicode(smb_ucs2_t *dst, const char *src, size_t dst_len);
-size_t strlen_w(const smb_ucs2_t *src);
-smb_ucs2_t *safe_strcpy_w(smb_ucs2_t *dest,const smb_ucs2_t *src, size_t maxlength);
-smb_ucs2_t *safe_strcat_w(smb_ucs2_t *dest, const smb_ucs2_t *src, size_t maxlength);
-int strcmp_w(const smb_ucs2_t *s1, const smb_ucs2_t *s2);
-int strncmp_w(const smb_ucs2_t *s1, const smb_ucs2_t *s2, size_t len);
-smb_ucs2_t *strstr_w(const smb_ucs2_t *s1, const smb_ucs2_t *s2);
-smb_ucs2_t *strchr_w(const smb_ucs2_t *s, smb_ucs2_t c);
-smb_ucs2_t *strrchr_w(const smb_ucs2_t *s, smb_ucs2_t c);
-smb_ucs2_t *strtok_w(smb_ucs2_t *s1, const smb_ucs2_t *s2);
-smb_ucs2_t *strdup_w(const smb_ucs2_t *s);
-int isupper_w( smb_ucs2_t val);
-int islower_w( smb_ucs2_t val);
-int isdigit_w( smb_ucs2_t val);
-int isxdigit_w( smb_ucs2_t val);
-int isspace_w( smb_ucs2_t val);
-smb_ucs2_t toupper_w( smb_ucs2_t val );
-smb_ucs2_t tolower_w( smb_ucs2_t val );
-void set_first_token_w(smb_ucs2_t *ptr);
-BOOL next_token_w(smb_ucs2_t **ptr, smb_ucs2_t *buff, smb_ucs2_t *sep, size_t bufsize);
-smb_ucs2_t **toktocliplist_w(int *ctok, smb_ucs2_t *sep);
-int StrCaseCmp_w(const smb_ucs2_t *s, const smb_ucs2_t *t);
-int StrnCaseCmp_w(const smb_ucs2_t *s, const smb_ucs2_t *t, size_t n);
-BOOL strequal_w(const smb_ucs2_t *s1, const smb_ucs2_t *s2);
-BOOL strnequal_w(const smb_ucs2_t *s1,const smb_ucs2_t *s2,size_t n);
-BOOL strcsequal_w(const smb_ucs2_t *s1,const smb_ucs2_t *s2);
-void strlower_w(smb_ucs2_t *s);
-void strupper_w(smb_ucs2_t *s);
-void strnorm_w(smb_ucs2_t *s);
-BOOL strisnormal_w(smb_ucs2_t *s);
-void string_replace_w(smb_ucs2_t *s, smb_ucs2_t oldc, smb_ucs2_t newc);
-smb_ucs2_t *skip_string_w(smb_ucs2_t *buf,size_t n);
-size_t str_charnum_w(const smb_ucs2_t *s);
-BOOL trim_string_w(smb_ucs2_t *s,const smb_ucs2_t *front,const smb_ucs2_t *back);
-BOOL strhasupper_w(const smb_ucs2_t *s);
-BOOL strhaslower_w(const smb_ucs2_t *s);
-size_t count_chars_w(const smb_ucs2_t *s,smb_ucs2_t c);
-BOOL str_is_all_w(const smb_ucs2_t *s,smb_ucs2_t c);
-smb_ucs2_t *alpha_strcpy_w(smb_ucs2_t *dest, const smb_ucs2_t *src, const smb_ucs2_t *other_safe_chars, size_t maxlength);
-smb_ucs2_t *StrnCpy_w(smb_ucs2_t *dest,const smb_ucs2_t *src,size_t n);
-smb_ucs2_t *strncpyn_w(smb_ucs2_t *dest, const smb_ucs2_t *src,size_t n, smb_ucs2_t c);
-size_t strhex_to_str_w(char *p, size_t len, const smb_ucs2_t *strhex);
-BOOL in_list_w(smb_ucs2_t *s,smb_ucs2_t *list,BOOL casesensitive);
-BOOL string_init_w(smb_ucs2_t **dest,const smb_ucs2_t *src);
-void string_free_w(smb_ucs2_t **s);
-BOOL string_set_w(smb_ucs2_t **dest,const smb_ucs2_t *src);
-void string_sub_w(smb_ucs2_t *s,const smb_ucs2_t *pattern,const smb_ucs2_t *insert, size_t len);
-void fstring_sub_w(smb_ucs2_t *s,const smb_ucs2_t *pattern,const smb_ucs2_t *insert);
-void pstring_sub_w(smb_ucs2_t *s,const smb_ucs2_t *pattern,smb_ucs2_t *insert);
-void all_string_sub_w(smb_ucs2_t *s,const smb_ucs2_t *pattern,const smb_ucs2_t *insert, size_t len);
-void split_at_last_component_w(smb_ucs2_t *path, smb_ucs2_t *front, smb_ucs2_t sep, smb_ucs2_t *back);
-smb_ucs2_t *octal_string_w(int i);
-smb_ucs2_t *string_truncate_w(smb_ucs2_t *s, size_t length);
-smb_ucs2_t doscp2ucs2(int w);
-int ucs2doscp(smb_ucs2_t w);
-int rpcstr_pull(char* dest, void *src, int dest_len, int src_len, int flags);
+void E_P16(const unsigned char *p14,unsigned char *p16);
+void E_P24(const unsigned char *p21, const unsigned char *c8, unsigned char *p24);
+void D_P16(const unsigned char *p14, const unsigned char *in, unsigned char *out);
+void E_old_pw_hash( unsigned char *p14, const unsigned char *in, unsigned char *out);
+void cred_hash1(unsigned char *out, const unsigned char *in,unsigned char *key);
+void cred_hash2(unsigned char *out, const unsigned char *in,unsigned char *key);
+void cred_hash3(unsigned char *out,unsigned char *in,unsigned char *key, int forw);
+void SamOEMhash( unsigned char *data, const unsigned char *key, int val);
+void sam_pwd_hash(unsigned int rid, const uchar *in, uchar *out, int forw);
-/*The following definitions come from lib/wins_srv.c */
+/*The following definitions come from libsmb/smbencrypt.c */
-BOOL wins_srv_load_list( char *src );
-struct in_addr wins_srv_ip( void );
-void wins_srv_died( struct in_addr boothill_ip );
-unsigned long wins_srv_count( void );
+void SMBencrypt(uchar *passwd, uchar *c8, uchar *p24);
+void E_md4hash(uchar *passwd, uchar *p16);
+void nt_lm_owf_gen(char *pwd, uchar nt_p16[16], uchar p16[16]);
+void SMBOWFencrypt(uchar passwd[16], uchar *c8, uchar p24[24]);
+void NTLMSSPOWFencrypt(uchar passwd[8], uchar *ntlmchalresp, uchar p24[24]);
+void SMBNTencrypt(uchar *passwd, uchar *c8, uchar *p24);
+BOOL make_oem_passwd_hash(char data[516], const char *passwd, uchar old_pw_hash[16], BOOL unicode);
+BOOL encode_pw_buffer(char buffer[516], const char *new_pass,
+ int new_pw_len, BOOL nt_pass_set);
+BOOL decode_pw_buffer(char in_buffer[516], char *new_pwrd,
+ int new_pwrd_size, uint32 *new_pw_len,
+ uchar nt_p16[16], uchar p16[16]);
+void nt_owf_genW(const UNISTR2 *pwd, uchar nt_p16[16]);
+
+/*The following definitions come from libsmb/smberr.c */
+
+char *smb_dos_err_name(uint8 class, uint16 num);
+char *get_dos_error_msg(WERROR result);
+char *smb_dos_err_class(uint8 class);
+char *smb_dos_errstr(char *inbuf);
+char *werror_str(WERROR status);
+WERROR map_werror_from_unix(int error);
+
+/*The following definitions come from libsmb/unexpected.c */
+
+void unexpected_packet(struct packet_struct *p);
+void clear_unexpected(time_t t);
+struct packet_struct *receive_unexpected(enum packet_type packet_type, int id,
+ char *mailslot_name);
/*The following definitions come from locking/brlock.c */
@@ -1440,6 +1440,9 @@
struct name_record **n);
void kill_async_dns_child(void);
+/*The following definitions come from nmbd/nmbd.c */
+
+
/*The following definitions come from nmbd/nmbd_become_dmb.c */
void add_domain_names(time_t t);
@@ -1470,9 +1473,6 @@
void collect_all_workgroup_names_from_wins_server(time_t t);
void sync_all_dmbs(time_t t);
-/*The following definitions come from nmbd/nmbd.c */
-
-
/*The following definitions come from nmbd/nmbd_elections.c */
void check_master_browser_exists(time_t t);
@@ -2346,14 +2346,19 @@
/*The following definitions come from printing/print_cups.c */
+/*The following definitions come from printing/print_generic.c */
+
+
+/*The following definitions come from printing/print_svid.c */
+
+void sysv_printer_fn(void (*fn)(char *, char *));
+int sysv_printername_ok(char *name);
+
/*The following definitions come from printing/printfsp.c */
files_struct *print_fsp_open(connection_struct *conn, char *fname);
void print_fsp_end(files_struct *fsp, BOOL normal_close);
-/*The following definitions come from printing/print_generic.c */
-
-
/*The following definitions come from printing/printing.c */
BOOL print_backend_init(void);
@@ -2378,11 +2383,6 @@
BOOL print_queue_resume(struct current_user *user, int snum, WERROR *errcode);
BOOL print_queue_purge(struct current_user *user, int snum, WERROR *errcode);
-/*The following definitions come from printing/print_svid.c */
-
-void sysv_printer_fn(void (*fn)(char *, char *));
-int sysv_printername_ok(char *name);
-
/*The following definitions come from profile/profile.c */
void profile_message(int msg_type, pid_t src, void *buf, size_t len);
@@ -2436,39 +2436,6 @@
BOOL change_trust_account_password( char *domain, char *remote_machine_list);
-/*The following definitions come from rpcclient/cmd_dfs.c */
-
-
-/*The following definitions come from rpcclient/cmd_lsarpc.c */
-
-
-/*The following definitions come from rpcclient/cmd_netlogon.c */
-
-
-/*The following definitions come from rpcclient/cmd_reg.c */
-
-
-/*The following definitions come from rpcclient/cmd_samr.c */
-
-void display_sam_info_1(SAM_ENTRY1 *e1, SAM_STR1 *s1);
-void display_sam_info_4(SAM_ENTRY4 *e4, SAM_STR4 *s4);
-
-/*The following definitions come from rpcclient/cmd_spoolss.c */
-
-BOOL get_short_archi(char *short_archi, char *long_archi);
-void set_drv_info_3_env (DRIVER_INFO_3 *info, const char *arch);
-
-/*The following definitions come from rpcclient/cmd_srvsvc.c */
-
-
-/*The following definitions come from rpcclient/rpcclient.c */
-
-void fetch_machine_sid(struct cli_state *cli);
-void init_rpcclient_creds(struct ntuser_creds *creds, char* username,
- char* domain, char* password);
-struct cli_state *setup_connection(struct cli_state *cli, char *system_name,
- struct ntuser_creds *creds);
-
/*The following definitions come from rpc_parse/parse_dfs.c */
void init_dfs_q_dfs_exist(DFS_Q_DFS_EXIST *q_d);
@@ -4078,6 +4045,39 @@
NTSTATUS _wks_query_info(pipes_struct *p, WKS_Q_QUERY_INFO *q_u, WKS_R_QUERY_INFO *r_u);
+/*The following definitions come from rpcclient/cmd_dfs.c */
+
+
+/*The following definitions come from rpcclient/cmd_lsarpc.c */
+
+
+/*The following definitions come from rpcclient/cmd_netlogon.c */
+
+
+/*The following definitions come from rpcclient/cmd_reg.c */
+
+
+/*The following definitions come from rpcclient/cmd_samr.c */
+
+void display_sam_info_1(SAM_ENTRY1 *e1, SAM_STR1 *s1);
+void display_sam_info_4(SAM_ENTRY4 *e4, SAM_STR4 *s4);
+
+/*The following definitions come from rpcclient/cmd_spoolss.c */
+
+BOOL get_short_archi(char *short_archi, char *long_archi);
+void set_drv_info_3_env (DRIVER_INFO_3 *info, const char *arch);
+
+/*The following definitions come from rpcclient/cmd_srvsvc.c */
+
+
+/*The following definitions come from rpcclient/rpcclient.c */
+
+void fetch_machine_sid(struct cli_state *cli);
+void init_rpcclient_creds(struct ntuser_creds *creds, char* username,
+ char* domain, char* password);
+struct cli_state *setup_connection(struct cli_state *cli, char *system_name,
+ struct ntuser_creds *creds);
+
/*The following definitions come from smbd/blocking.c */
BOOL push_blocking_lock_request( char *inbuf, int length, int lock_timeout, int lock_num);
@@ -4541,24 +4541,6 @@
void sys_utmp_claim(const char *username, const char *hostname,
const char *id_str, int id_num);
-/*The following definitions come from smbd/vfs.c */
-
-BOOL vfs_init(connection_struct *conn);
-BOOL vfs_directory_exist(connection_struct *conn, char *dname, SMB_STRUCT_STAT *st);
-int vfs_mkdir(connection_struct *conn, char *fname, mode_t mode);
-char *vfs_getwd(connection_struct *conn, char *unix_path);
-BOOL vfs_object_exist(connection_struct *conn,char *fname,SMB_STRUCT_STAT *sbuf);
-BOOL vfs_file_exist(connection_struct *conn,char *fname,SMB_STRUCT_STAT *sbuf);
-ssize_t vfs_read_data(files_struct *fsp, char *buf, size_t byte_count);
-ssize_t vfs_write_data(files_struct *fsp,char *buffer,size_t N);
-int vfs_allocate_file_space(files_struct *fsp, SMB_OFF_T len);
-int vfs_set_filelen(files_struct *fsp, SMB_OFF_T len);
-SMB_OFF_T vfs_transfer_file(files_struct *in, files_struct *out, SMB_OFF_T n);
-char *vfs_readdirname(connection_struct *conn, void *p);
-int vfs_ChDir(connection_struct *conn, char *path);
-char *vfs_GetWd(connection_struct *conn, char *path);
-BOOL reduce_name(connection_struct *conn, char *s,char *dir,BOOL widelinks);
-
/*The following definitions come from smbd/vfs-wrap.c */
int vfswrap_dummy_connect(connection_struct *conn, char *service, char *user);
@@ -4602,14 +4584,29 @@
int vfswrap_chmod_acl(connection_struct *conn, char *name, mode_t mode);
int vfswrap_fchmod_acl(files_struct *fsp, int fd, mode_t mode);
-/*The following definitions come from smbwrapper/realcalls.c */
+/*The following definitions come from smbd/vfs.c */
-int real_utime(const char *name, struct utimbuf *buf);
-int real_utimes(const char *name, struct timeval tv[2]);
+BOOL vfs_init(connection_struct *conn);
+BOOL vfs_directory_exist(connection_struct *conn, char *dname, SMB_STRUCT_STAT *st);
+int vfs_mkdir(connection_struct *conn, char *fname, mode_t mode);
+char *vfs_getwd(connection_struct *conn, char *unix_path);
+BOOL vfs_object_exist(connection_struct *conn,char *fname,SMB_STRUCT_STAT *sbuf);
+BOOL vfs_file_exist(connection_struct *conn,char *fname,SMB_STRUCT_STAT *sbuf);
+ssize_t vfs_read_data(files_struct *fsp, char *buf, size_t byte_count);
+ssize_t vfs_write_data(files_struct *fsp,char *buffer,size_t N);
+int vfs_allocate_file_space(files_struct *fsp, SMB_OFF_T len);
+int vfs_set_filelen(files_struct *fsp, SMB_OFF_T len);
+SMB_OFF_T vfs_transfer_file(files_struct *in, files_struct *out, SMB_OFF_T n);
+char *vfs_readdirname(connection_struct *conn, void *p);
+int vfs_ChDir(connection_struct *conn, char *path);
+char *vfs_GetWd(connection_struct *conn, char *path);
+BOOL reduce_name(connection_struct *conn, char *s,char *dir,BOOL widelinks);
/*The following definitions come from smbwrapper/shared.c */
void smbw_setup_shared(void);
+void smbw_lockit(void);
+void smbw_unlockit(void);
char *smbw_getshared(const char *name);
void smbw_setshared(const char *name, const char *val);
int smbw_setenv(const char *name, const char *value);
@@ -4625,7 +4622,7 @@
char *smbw_parse_path(const char *fname, char *server, char *share, char *path);
int smbw_path(const char *path);
int smbw_errno(struct cli_state *c);
-void get_envvar_auth_data(char *server, char *share, char **workgroup,
+int get_envvar_auth_data(char *server, char *share, char **workgroup,
char **username, char **password);
void smbw_set_auth_data_fn(smbw_get_auth_data_fn fn);
struct smbw_server *smbw_server(char *server, char *share);
@@ -4655,9 +4652,9 @@
struct smbw_dir *smbw_dir(int fd);
int smbw_dirp(DIR *dirp);
int smbw_dir_open(const char *fname);
-int smbw_dir_fstat(int fd, struct stat *st);
+int smbw_dir_fstat(int fd, struct SMBW_stat *st);
int smbw_dir_close(int fd);
-int smbw_getdents(unsigned int fd, struct dirent *dirp, int count);
+int smbw_getdents(unsigned int fd, struct SMBW_dirent *dirp, int count);
int smbw_chdir(const char *name);
off_t smbw_dir_lseek(int fd, off_t offset, int whence);
int smbw_mkdir(const char *fname, mode_t mode);
@@ -4665,22 +4662,106 @@
char *smbw_getcwd(char *buf, size_t size);
int smbw_fchdir(unsigned int fd);
DIR *smbw_opendir(const char *fname);
-struct dirent *smbw_readdir(DIR *dirp);
+struct SMBW_dirent *smbw_readdir(DIR *dirp);
+int smbw_readdir_r(DIR *dirp,
+ struct SMBW_dirent *__restrict entry,
+ struct SMBW_dirent **__restrict result);
int smbw_closedir(DIR *dirp);
-void smbw_seekdir(DIR *dirp, off_t offset);
-off_t smbw_telldir(DIR *dirp);
+void smbw_seekdir(DIR *dirp, long long offset);
+long long smbw_telldir(DIR *dirp);
/*The following definitions come from smbwrapper/smbw_stat.c */
-void smbw_setup_stat(struct stat *st, char *fname, size_t size, int mode);
+int smbw_convert_mode(int in);
+void smbw_setup_stat(struct SMBW_stat *st, char *fname, size_t size, int mode);
BOOL smbw_getatr(struct smbw_server *srv, char *path,
uint16 *mode, size_t *size,
time_t *c_time, time_t *a_time, time_t *m_time,
SMB_INO_T *ino);
int smbw_stat_printjob(struct smbw_server *srv,char *path,
size_t *size, time_t *m_time);
-int smbw_fstat(int fd, struct stat *st);
-int smbw_stat(const char *fname, struct stat *st);
+int smbw_fstat(int fd, struct SMBW_stat *st);
+int smbw_stat(const char *fname, struct SMBW_stat *st);
+
+/*The following definitions come from smbwrapper/wrapper.c */
+
+int open(__const char *name, int flags, ...);
+int _open(char *name, int flags, mode_t mode);
+int __open(char *name, int flags, mode_t mode);
+int open64 (__const char *name, int flags, ...);
+int _open64(char *name, int flags, mode_t mode);
+int __open64(char *name, int flags, mode_t mode);
+ssize_t pread(int fd, void *buf, size_t size, off_t ofs);
+ssize_t pread64(int fd, void *buf, size_t size, off64_t ofs);
+ssize_t pwrite(int fd, const void *buf, size_t size, off_t ofs);
+ssize_t pwrite64(int fd, const void *buf, size_t size, off64_t ofs);
+int chdir(const char *name);
+int __chdir(char *name);
+int _chdir(char *name);
+int close(int fd);
+int __close(int fd);
+int _close(int fd);
+int fchdir(int fd);
+int __fchdir(int fd);
+int _fchdir(int fd);
+int fcntl (int fd, int cmd, ...);
+int __fcntl(int fd, int cmd, ...);
+int _fcntl(int fd, int cmd, ...);
+int getdents(int fd, struct dirent *dirp, unsigned int count);
+int __getdents(int fd, struct dirent *dirp, unsigned int count);
+int _getdents(int fd, struct dirent *dirp, unsigned int count);
+int getdents64(int fd, struct dirent64 *external, unsigned int count);
+off_t lseek(int fd, off_t offset, int whence);
+off_t __lseek(int fd, off_t offset, int whence);
+off_t _lseek(int fd, off_t offset, int whence);
+ssize_t read(int fd, void *buf, size_t count);
+ssize_t __read(int fd, void *buf, size_t count);
+ssize_t _read(int fd, void *buf, size_t count);
+ssize_t write(int fd, const void *buf, size_t count);
+ssize_t __write(int fd, const void *buf, size_t count);
+ssize_t _write(int fd, const void *buf, size_t count);
+int access(const char *name, int mode);
+int chmod(const char *name, mode_t mode);
+int chown(const char *name, uid_t owner, gid_t group);
+char *getcwd(char *buf, size_t size);
+int mkdir(const char *name, mode_t mode);
+int __fxstat(int vers, int fd, struct stat *st);
+int __xstat(int vers, const char *name, struct stat *st);
+int __lxstat(int vers, const char *name, struct stat *st);
+int stat(const char *name, struct stat *st);
+int lstat(const char *name, struct stat *st);
+int fstat(int fd, struct stat *st);
+int unlink(const char *name);
+int utime(const char *name, const struct utimbuf *tvp);
+int utimes(const char *name, const struct timeval *tvp);
+int readlink(const char *path, char *buf, size_t bufsize);
+int rename(const char *oldname, const char *newname);
+int rmdir(const char *name);
+int symlink(const char *topath, const char *frompath);
+int dup(int fd);
+int dup2(int oldfd, int newfd);
+DIR *opendir(const char *name);
+struct dirent *readdir(DIR *dir);
+int closedir(DIR *dir);
+long telldir(DIR *dir);
+void seekdir(DIR *dir, long offset);
+int creat(const char *path, mode_t mode);
+int creat64(const char *path, mode_t mode);
+int __xstat64 (int ver, const char *name, struct stat64 *st64);
+int stat64(const char *name, struct stat64 *st64);
+int __fxstat64(int ver, int fd, struct stat64 *st64);
+int fstat64(int fd, struct stat64 *st64);
+int __lxstat64(int ver, const char *name, struct stat64 *st64);
+int lstat64(const char *name, struct stat64 *st64);
+int _llseek(unsigned int fd, unsigned long offset_high, unsigned long offset_low, loff_t *result, unsigned int whence);
+struct dirent64 *readdir64(DIR *dir);
+int readdir_r(DIR *dir, struct dirent *external, struct dirent **result);
+int readdir64_r(DIR *dir, struct dirent64 *external, struct dirent64 **result);
+int fork(void);
+void *malloc(size_t size);
+void *calloc(size_t nmemb, size_t size);
+void *realloc(void *ptr, size_t size);
+void free(void *ptr);
/*The following definitions come from tdb/spinlock.c */
Only in samba-2.2.3a/source/include: stamp-h
Only in samba-2.2.3a/source/smbwrapper: CVS
diff -r -u samba-2.2.3a.debian/source/smbwrapper/README samba-2.2.3a/source/smbwrapper/README
--- samba-2.2.3a.debian/source/smbwrapper/README Sun Oct 18 22:49:48 1998
+++ samba-2.2.3a/source/smbwrapper/README Wed Dec 25 15:46:33 2002
@@ -4,8 +4,16 @@
*** This is code under development. Some things don't work yet ***
+[
+ As of 25 December 2002, it seems to work completely and properly with
+ Linux 2.4 with glibc (Debian "Woody").
+
+ Derrell Lipman
+]
+
Currently this code has been tested on:
+- Linux 2.4 with glibc-2.2.5 (Debian "Woody")
- Linux 2.0 with glibc2 (RH5.1)
- Linux 2.1 with glibc2
- Solaris 2.5.1 with gcc
Only in samba-2.2.3a.debian/source/smbwrapper: init.c
Only in samba-2.2.3a.debian/source/smbwrapper: realcalls.c
Only in samba-2.2.3a.debian/source/smbwrapper: realcalls.h
diff -r -u samba-2.2.3a.debian/source/smbwrapper/shared.c samba-2.2.3a/source/smbwrapper/shared.c
--- samba-2.2.3a.debian/source/smbwrapper/shared.c Sat Feb 2 19:46:57 2002
+++ samba-2.2.3a/source/smbwrapper/shared.c Wed Dec 25 15:46:34 2002
@@ -67,7 +67,7 @@
/*****************************************************
lock the shared variable area
*******************************************************/
-static void lockit(void)
+void smbw_lockit(void)
{
if (shared_fd == 0) {
char *p = getenv("SMBW_HANDLE");
@@ -88,7 +88,7 @@
/*****************************************************
unlock the shared variable area
*******************************************************/
-static void unlockit(void)
+void smbw_unlockit(void)
{
locked--;
if (locked == 0) {
@@ -105,7 +105,7 @@
int i;
struct stat st;
- lockit();
+ smbw_lockit();
/* maybe the area has changed */
if (fstat(shared_fd, &st)) goto failed;
@@ -120,7 +120,7 @@
}
}
- unlockit();
+ smbw_unlockit();
i=0;
while (i < shared_size) {
@@ -160,7 +160,7 @@
/* we don't allow variable overwrite */
if (smbw_getshared(name)) return;
- lockit();
+ smbw_lockit();
l1 = strlen(name)+1;
l2 = strlen(val)+1;
@@ -186,7 +186,7 @@
exit(1);
}
- unlockit();
+ smbw_unlockit();
}
diff -r -u samba-2.2.3a.debian/source/smbwrapper/smbsh.c samba-2.2.3a/source/smbwrapper/smbsh.c
--- samba-2.2.3a.debian/source/smbwrapper/smbsh.c Sat Feb 2 19:46:57 2002
+++ samba-2.2.3a/source/smbwrapper/smbsh.c Wed Dec 25 15:46:34 2002
@@ -25,7 +25,10 @@
static void smbsh_usage(void)
{
- printf("smbsh [options]\n\n");
+ printf("smbsh [options] [command [args] ...]\n\n");
+ printf(" -p prepend library name\n");
+ printf(" -a append library name\n");
+ printf(" -n");
printf(" -W workgroup\n");
printf(" -U username\n");
printf(" -P prefix\n");
@@ -40,8 +43,11 @@
{
char *p, *u;
char *libd = BINDIR;
- pstring line, wd;
+ pstring line, wd, pre, post;
+ int prespace = PSTRING_LEN;
+ int postspace = PSTRING_LEN;
int opt;
+ int no_ask = 0;
extern char *optarg;
extern int optind;
extern FILE *dbf;
@@ -57,8 +63,25 @@
smbw_setup_shared();
- while ((opt = getopt(argc, argv, "W:U:R:d:P:l:hL:")) != EOF) {
+ *pre = *post = '\0';
+
+ while ((opt = getopt(argc, argv, "p:a:nW:U:R:d:P:l:hL:")) != EOF) {
switch (opt) {
+ case 'p': /* prepend library before smbwrapper.so */
+ if (*pre != '\0')
+ pstrcat(pre, " ");
+ pstrcat(pre, optarg);
+ break;
+
+ case 'a': /* append library after smbwrapper.so */
+ pstrcat(post, " ");
+ pstrcat(post, optarg);
+ break;
+
+ case 'n': /* don't ask for username/password */
+ no_ask++;
+ break;
+
case 'L':
libd = optarg;
break;
@@ -94,27 +117,30 @@
}
- if (!smbw_getshared("USER")) {
- printf("Username: ");
- u = fgets_slash(line, sizeof(line)-1, stdin);
- smbw_setshared("USER", u);
- }
-
- if (!smbw_getshared("PASSWORD")) {
- p = getpass("Password: ");
- smbw_setshared("PASSWORD", p);
- }
-
- smbw_setenv("PS1", "smbsh$ ");
+ if (! no_ask) {
+ if (!smbw_getshared("USER")) {
+ printf("Username: ");
+ u = fgets_slash(line, sizeof(line)-1, stdin);
+ smbw_setshared("USER", u);
+ }
+
+ if (!smbw_getshared("PASSWORD")) {
+ p = getpass("Password: ");
+ smbw_setshared("PASSWORD", p);
+ }
+ }
sys_getwd(wd);
-
slprintf(line,sizeof(line)-1,"PWD_%d", (int)getpid());
-
smbw_setshared(line, wd);
- slprintf(line,sizeof(line)-1,"%s/smbwrapper.so", libd);
+ pstrcpy(line, pre);
+ pstrcat(line, " ");
+ pstrcat(line, libd);
+ pstrcat(line, "/smbwrapper.so");
+ pstrcat(line, post);
smbw_setenv("LD_PRELOAD", line);
+ smbw_setenv("LD_BIND_NOW", "true");
slprintf(line,sizeof(line)-1,"%s/smbwrapper.32.so", libd);
@@ -128,9 +154,14 @@
smbw_setenv("_RLD_LIST", line);
}
- {
- char *shellpath = getenv("SHELL");
- if(shellpath)
+ if (optind < argc) {
+ execvp(argv[optind], &argv[optind]);
+ } else {
+ char *shellpath = getenv("SHELL");
+
+ smbw_setenv("PS1", "smbsh$ ");
+
+ if(shellpath)
execl(shellpath,"smbsh",NULL);
else
execl("/bin/sh","smbsh",NULL);
Only in samba-2.2.3a.debian/source/smbwrapper: smbsh.in
diff -r -u samba-2.2.3a.debian/source/smbwrapper/smbw.c samba-2.2.3a/source/smbwrapper/smbw.c
--- samba-2.2.3a.debian/source/smbwrapper/smbw.c Sat Feb 2 19:46:57 2002
+++ samba-2.2.3a/source/smbwrapper/smbw.c Wed Dec 25 15:46:34 2002
@@ -20,7 +20,7 @@
*/
#include "includes.h"
-#include "realcalls.h"
+#include "wrapper.h"
pstring smbw_cwd;
@@ -45,7 +45,7 @@
void smbw_init(void)
{
extern BOOL in_client;
- static int initialised;
+ static int initialised = 0;
static pstring servicesf = CONFIGFILE;
extern FILE *dbf;
char *p;
@@ -406,22 +406,53 @@
return cli_errno(c);
}
-/* Return a username and password given a server and share name */
-
-void get_envvar_auth_data(char *server, char *share, char **workgroup,
+/*
+ * Return a username and password given a server and share name
+ *
+ * It is the caller's responsibility to free the memory allocated for the
+ * workgroup, username, and password.
+ *
+ * Returns 0 upon success;
+ * non-zero otherwise, and errno is set to indicate the error.
+ */
+int get_envvar_auth_data(char *server, char *share, char **workgroup,
char **username, char **password)
{
- /* Fall back to shared memory/environment variables */
+ char *u;
+ char *p;
+ char *w;
- *username = smbw_getshared("USER");
- if (!*username) *username = getenv("USER");
- if (!*username) *username = "guest";
+ /* Fall back to shared memory/environment variables */
- *workgroup = smbw_getshared("WORKGROUP");
- if (!*workgroup) *workgroup = lp_workgroup();
+ u = smbw_getshared("USER");
+ if (u == NULL) u = getenv("USER");
+ if (u == NULL) u = "guest";
+
+ w = smbw_getshared("WORKGROUP");
+ if (w == NULL) w = lp_workgroup();
+
+ p = smbw_getshared("PASSWORD");
+ if (p == NULL) p = "";
+
+ if ((*username = strdup(u)) == NULL) {
+ errno = ENOMEM;
+ return -1;
+ }
+
+ if ((*workgroup = strdup(w)) == NULL) {
+ errno = ENOMEM;
+ free(*username);
+ return -1;
+ }
+
+ if ((*password = strdup(p)) == NULL) {
+ errno = ENOMEM;
+ free(*workgroup);
+ free(*username);
+ return -1;
+ }
- *password = smbw_getshared("PASSWORD");
- if (!*password) *password = "";
+ return 0;
}
static smbw_get_auth_data_fn get_auth_data_fn = get_envvar_auth_data;
@@ -454,19 +485,28 @@
ip = ipzero;
ZERO_STRUCT(c);
- get_auth_data_fn(server, share, &workgroup, &username, &password);
+ if (get_auth_data_fn(server, share, &workgroup,
+ &username, &password) != 0)
+ return NULL;
/* try to use an existing connection */
for (srv=smbw_srvs;srv;srv=srv->next) {
if (strcmp(server,srv->server_name)==0 &&
strcmp(share,srv->share_name)==0 &&
strcmp(workgroup,srv->workgroup)==0 &&
- strcmp(username, srv->username) == 0)
+ strcmp(username, srv->username) == 0) {
+ free(username);
+ free(workgroup);
+ free(password);
return srv;
+ }
}
if (server[0] == 0) {
errno = EPERM;
+ free(username);
+ free(workgroup);
+ free(password);
return NULL;
}
@@ -489,6 +529,9 @@
if (!(server_n = smbw_getshared(s))) {
if (!find_master_ip(group, &sip)) {
errno = ENOENT;
+ free(username);
+ free(workgroup);
+ free(password);
return NULL;
}
fstrcpy(group, inet_ntoa(sip));
@@ -508,10 +551,32 @@
}
/* have to open a new connection */
- if (!cli_initialise(&c) || !cli_connect(&c, server_n, &ip)) {
- errno = ENOENT;
- return NULL;
- }
+ if (!cli_initialise(&c)) {
+ errno = ENOENT;
+ free(username);
+ free(workgroup);
+ free(password);
+ return NULL;
+ }
+
+ /* Force use of port 139 for first try, so browse lists can work*/
+ c.port = 139;
+
+ /* Attempt to connect */
+ if (!cli_connect(&c, server_n, &ip)) {
+ /*
+ * Port 139 connection failed. Try port 445 to handle
+ * connections to newer (e.g. XP) hosts with NetBIOS disabled.
+ */
+ c.port = 445;
+ if (!cli_connect(&c, server_n, &ip)) {
+ errno = ENOENT;
+ free(username);
+ free(workgroup);
+ free(password);
+ return NULL;
+ }
+ }
if (!cli_session_request(&c, &calling, &called)) {
cli_shutdown(&c);
@@ -520,6 +585,9 @@
goto again;
}
errno = ENOENT;
+ free(username);
+ free(workgroup);
+ free(password);
return NULL;
}
@@ -528,6 +596,9 @@
if (!cli_negprot(&c)) {
cli_shutdown(&c);
errno = ENOENT;
+ free(username);
+ free(workgroup);
+ free(password);
return NULL;
}
@@ -539,6 +610,9 @@
!cli_session_setup(&c, "", "", 1,"", 0, workgroup)) {
cli_shutdown(&c);
errno = EPERM;
+ free(username);
+ free(workgroup);
+ free(password);
return NULL;
}
@@ -548,9 +622,14 @@
password, strlen(password)+1)) {
errno = smbw_errno(&c);
cli_shutdown(&c);
+ free(username);
+ free(workgroup);
+ free(password);
return NULL;
}
+ free(password); /* not used any more so clean up now */
+
smbw_setshared(ipenv,inet_ntoa(ip));
DEBUG(4,(" tconx ok\n"));
@@ -579,17 +658,8 @@
goto failed;
}
- srv->workgroup = strdup(workgroup);
- if (!srv->workgroup) {
- errno = ENOMEM;
- goto failed;
- }
-
- srv->username = strdup(username);
- if (!srv->username) {
- errno = ENOMEM;
- goto failed;
- }
+ srv->workgroup = workgroup;
+ srv->username = username;
/* some programs play with file descriptors fairly intimately. We
try to get out of the way by duping to a high fd number */
@@ -607,6 +677,9 @@
failed:
cli_shutdown(&c);
+ free(username);
+ free(workgroup);
+
if (!srv) return NULL;
SAFE_FREE(srv->server_name);
@@ -640,6 +713,9 @@
int eno=0, fd = -1;
struct smbw_file *file=NULL;
+ DEBUG(4,("smbw_open(fname=%s, flags=%d, mode=%o\n",
+ fname, flags, mode));
+
smbw_init();
if (!fname) {
@@ -695,6 +771,7 @@
errno = ENOMEM;
goto failed;
}
+
file->srv = srv;
file->fd = open(SMBW_DUMMY, O_WRONLY);
if (file->fd == -1) {
@@ -919,7 +996,7 @@
*******************************************************/
int smbw_access(const char *name, int mode)
{
- struct stat st;
+ struct SMBW_stat st;
DEBUG(4,("smbw_access(%s, 0x%x)\n", name, mode));
@@ -936,11 +1013,11 @@
}
/*****************************************************
-a wrapper for realink() - needed for correct errno setting
+a wrapper for readlink() - needed for correct errno setting
*******************************************************/
int smbw_readlink(const char *path, char *buf, size_t bufsize)
{
- struct stat st;
+ struct SMBW_stat st;
int ret;
ret = smbw_stat(path, &st);
@@ -1411,9 +1488,9 @@
struct smbw_file *file, *next_file;
struct smbw_server *srv, *next_srv;
- if (pipe(p)) return real_fork();
+ if (pipe(p)) return (* smbw_libc.fork)();
- child = real_fork();
+ child = (* smbw_libc.fork)();
if (child) {
/* block the parent for a moment until the sockets are
@@ -1473,91 +1550,3 @@
}
#endif
-#ifdef HAVE_EXPLICIT_LARGEFILE_SUPPORT
-#ifdef HAVE_STAT64
-/* this can't be in wrapped.c because of include conflicts */
- void stat64_convert(struct stat *st, struct stat64 *st64)
-{
- st64->st_size = st->st_size;
- st64->st_mode = st->st_mode;
- st64->st_ino = st->st_ino;
- st64->st_dev = st->st_dev;
- st64->st_rdev = st->st_rdev;
- st64->st_nlink = st->st_nlink;
- st64->st_uid = st->st_uid;
- st64->st_gid = st->st_gid;
- st64->st_atime = st->st_atime;
- st64->st_mtime = st->st_mtime;
- st64->st_ctime = st->st_ctime;
- st64->st_blksize = st->st_blksize;
- st64->st_blocks = st->st_blocks;
-}
-#endif
-
-#ifdef HAVE_READDIR64
- void dirent64_convert(struct dirent *d, struct dirent64 *d64)
-{
- d64->d_ino = d->d_ino;
- d64->d_off = d->d_off;
- d64->d_reclen = d->d_reclen;
- pstrcpy(d64->d_name, d->d_name);
-}
-#endif
-#endif
-
-
-#ifdef HAVE___XSTAT
-/* Definition of `struct stat' used in the linux kernel.. */
-struct kernel_stat {
- unsigned short int st_dev;
- unsigned short int __pad1;
- unsigned long int st_ino;
- unsigned short int st_mode;
- unsigned short int st_nlink;
- unsigned short int st_uid;
- unsigned short int st_gid;
- unsigned short int st_rdev;
- unsigned short int __pad2;
- unsigned long int st_size;
- unsigned long int st_blksize;
- unsigned long int st_blocks;
- unsigned long int st_atime;
- unsigned long int __unused1;
- unsigned long int st_mtime;
- unsigned long int __unused2;
- unsigned long int st_ctime;
- unsigned long int __unused3;
- unsigned long int __unused4;
- unsigned long int __unused5;
-};
-
-/*
- * Prototype for gcc in 'fussy' mode.
- */
- void xstat_convert(int vers, struct stat *st, struct kernel_stat *kbuf);
- void xstat_convert(int vers, struct stat *st, struct kernel_stat *kbuf)
-{
-#ifdef _STAT_VER_LINUX_OLD
- if (vers == _STAT_VER_LINUX_OLD) {
- memcpy(st, kbuf, sizeof(*st));
- return;
- }
-#endif
-
- ZERO_STRUCTP(st);
-
- st->st_dev = kbuf->st_dev;
- st->st_ino = kbuf->st_ino;
- st->st_mode = kbuf->st_mode;
- st->st_nlink = kbuf->st_nlink;
- st->st_uid = kbuf->st_uid;
- st->st_gid = kbuf->st_gid;
- st->st_rdev = kbuf->st_rdev;
- st->st_size = kbuf->st_size;
- st->st_blksize = kbuf->st_blksize;
- st->st_blocks = kbuf->st_blocks;
- st->st_atime = kbuf->st_atime;
- st->st_mtime = kbuf->st_mtime;
- st->st_ctime = kbuf->st_ctime;
-}
-#endif
diff -r -u samba-2.2.3a.debian/source/smbwrapper/smbw.h samba-2.2.3a/source/smbwrapper/smbw.h
--- samba-2.2.3a.debian/source/smbwrapper/smbw.h Fri Nov 10 16:52:47 2000
+++ samba-2.2.3a/source/smbwrapper/smbw.h Wed Dec 25 15:46:34 2002
@@ -22,6 +22,8 @@
#ifndef _SMBW_H
#define _SMBW_H
+#include "wrapper.h"
+
#define SMBW_PREFIX "/smb/"
#define SMBW_DUMMY "/dev/null"
@@ -56,17 +58,123 @@
struct smbw_server *srv;
};
+struct smbw_extended_info
+{
+ uint32 type;
+ char comment[64];
+};
+
+struct smbw_file_info
+{
+ struct file_info file_info;
+ struct smbw_extended_info extended;
+};
+
struct smbw_dir {
struct smbw_dir *next, *prev;
int fd;
int offset, count, malloced;
struct smbw_server *srv;
- struct file_info *list;
+ struct smbw_file_info *list;
char *path;
+ int want_extended;
+
+ /*
+ * Create a dirent structure here rather than having it static in
+ * smbw_readdir(), so that multi-threaded applications work.
+ */
+ SMBW_dirent dirent;
};
-typedef void (*smbw_get_auth_data_fn)(char *server, char *share,
- char **workgroup, char **username,
- char **password);
+/*
+ * Return a username and password given a server and share name
+ *
+ * It is the caller's responsibility to free the memory allocated for the
+ * workgroup, username, and password.
+ *
+ * Returns 0 upon success;
+ * non-zero otherwise, and errno is set to indicate the error.
+ */
+typedef int (*smbw_get_auth_data_fn)(char *server, char *share,
+ char **workgroup, char **username,
+ char **password);
+
+
+
+/*The following definitions come from smbwrapper/shared.c */
+
+void smbw_setup_shared(void);
+char *smbw_getshared(const char *name);
+void smbw_setshared(const char *name, const char *val);
+int smbw_setenv(const char *name, const char *value);
+int smbw_shared_fd(int fd);
+
+/*The following definitions come from smbwrapper/smbw.c */
+
+void smbw_init(void);
+int smbw_fd(int fd);
+int smbw_local_fd(int fd);
+ino_t smbw_inode(const char *name);
+void clean_fname(char *name);
+char *smbw_parse_path(const char *fname, char *server, char *share, char *path);
+int smbw_path(const char *path);
+int get_envvar_auth_data(char *server, char *share, char **workgroup,
+ char **username, char **password);
+void smbw_set_auth_data_fn(smbw_get_auth_data_fn fn);
+struct smbw_server *smbw_server(char *server, char *share);
+struct smbw_file *smbw_file(int fd);
+int smbw_open(const char *fname, int flags, mode_t mode);
+ssize_t smbw_pread(int fd, void *buf, size_t count, off_t ofs);
+ssize_t smbw_read(int fd, void *buf, size_t count);
+ssize_t smbw_write(int fd, void *buf, size_t count);
+ssize_t smbw_pwrite(int fd, void *buf, size_t count, off_t ofs);
+int smbw_close(int fd);
+int smbw_fcntl(int fd, int cmd, long arg);
+int smbw_access(const char *name, int mode);
+int smbw_readlink(const char *path, char *buf, size_t bufsize);
+int smbw_unlink(const char *fname);
+int smbw_rename(const char *oldname, const char *newname);
+int smbw_utime(const char *fname, void *buf);
+int smbw_utimes(const char *fname, void *buf);
+int smbw_chown(const char *fname, uid_t owner, gid_t group);
+int smbw_chmod(const char *fname, mode_t newmode);
+off_t smbw_lseek(int fd, off_t offset, int whence);
+int smbw_dup(int fd);
+int smbw_dup2(int fd, int fd2);
+int smbw_fork(void);
+
+/*The following definitions come from smbwrapper/smbw_dir.c */
+
+struct smbw_dir *smbw_dir(int fd);
+int smbw_dirp(DIR *dirp);
+int smbw_dir_open(const char *fname);
+int smbw_dir_fstat(int fd, SMBW_stat *st);
+int smbw_dir_close(int fd);
+int smbw_getdents(unsigned int fd, SMBW_dirent *dirp, int count);
+int smbw_chdir(const char *name);
+off_t smbw_dir_lseek(int fd, off_t offset, int whence);
+int smbw_mkdir(const char *fname, mode_t mode);
+int smbw_rmdir(const char *fname);
+char *smbw_getcwd(char *buf, size_t size);
+int smbw_fchdir(unsigned int fd);
+DIR *smbw_opendir(const char *fname);
+SMBW_dirent *smbw_readdir(DIR *dirp);
+int smbw_closedir(DIR *dirp);
+void smbw_seekdir(DIR *dirp, long long offset);
+long long smbw_telldir(DIR *dirp);
+
+/*The following definitions come from smbwrapper/smbw_stat.c */
+
+int smbw_convert_mode(int in);
+void smbw_setup_stat(SMBW_stat *st, char *fname, size_t size, int mode);
+BOOL smbw_getatr(struct smbw_server *srv, char *path,
+ uint16 *mode, size_t *size,
+ time_t *c_time, time_t *a_time, time_t *m_time,
+ SMB_INO_T *ino);
+int smbw_stat_printjob(struct smbw_server *srv,char *path,
+ size_t *size, time_t *m_time);
+int smbw_fstat(int fd, SMBW_stat *st);
+int smbw_stat(const char *fname, SMBW_stat *st);
+
#endif /* _SMBW_H */
diff -r -u samba-2.2.3a.debian/source/smbwrapper/smbw_dir.c samba-2.2.3a/source/smbwrapper/smbw_dir.c
--- samba-2.2.3a.debian/source/smbwrapper/smbw_dir.c Sat Feb 2 19:46:57 2002
+++ samba-2.2.3a/source/smbwrapper/smbw_dir.c Wed Dec 25 16:17:03 2002
@@ -20,16 +20,16 @@
*/
#include "includes.h"
-#include "realcalls.h"
+#include "wrapper.h"
extern pstring smbw_cwd;
extern fstring smbw_prefix;
+extern struct bitmap *smbw_file_bmap;
+extern int smbw_busy;
static struct smbw_dir *smbw_dirs;
+static int ServerFD= -1;
-extern struct bitmap *smbw_file_bmap;
-
-extern int smbw_busy;
/*****************************************************
map a fd to a smbw_dir structure
@@ -75,14 +75,19 @@
/*****************************************************
add a entry to a directory listing
*******************************************************/
-static void smbw_dir_add(struct file_info *finfo, const char *mask, void *state)
+static void smbw_dir_add(struct file_info *file_info, const char *mask, void *state)
{
- DEBUG(5,("%s\n", finfo->name));
+ struct smbw_extended_info *extended = state;
+ struct smbw_file_info *finfo;
+
+ DEBUG(5,("%s\n", file_info->name));
if (cur_dir->malloced == cur_dir->count) {
- cur_dir->list = (struct file_info *)Realloc(cur_dir->list,
- sizeof(cur_dir->list[0])*
- (cur_dir->count+100));
+ cur_dir->list =
+ (struct smbw_file_info *)
+ Realloc(cur_dir->list,
+ sizeof(cur_dir->list[0])*
+ (cur_dir->count+100));
if (!cur_dir->list) {
/* oops */
return;
@@ -90,7 +95,15 @@
cur_dir->malloced += 100;
}
- cur_dir->list[cur_dir->count] = *finfo;
+ finfo = &cur_dir->list[cur_dir->count];
+
+ finfo->file_info = *file_info;
+ if (extended != NULL)
+ finfo->extended = *extended;
+ else {
+ finfo->extended.type = 0;
+ *finfo->extended.comment = '\0';
+ }
cur_dir->count++;
}
@@ -100,16 +113,41 @@
static void smbw_share_add(const char *share, uint32 type,
const char *comment, void *state)
{
- struct file_info finfo;
+ struct smbw_file_info finfo;
if (strcmp(share,"IPC$") == 0) return;
ZERO_STRUCT(finfo);
- pstrcpy(finfo.name, share);
- finfo.mode = aRONLY | aDIR;
+ pstrcpy(finfo.file_info.name, share);
+ finfo.file_info.mode = aRONLY | (type == 0 ? aDIR : 0);
+ switch(type) {
+ case STYPE_DISKTREE:
+ finfo.extended.type = DT_DIR;
+ break;
+
+ case STYPE_PRINTQ:
+ finfo.extended.type = DT_CHR;
+ break;
+
+ case STYPE_DEVICE:
+ finfo.extended.type = DT_BLK;
+ break;
+
+ case STYPE_IPC:
+ /* never gets here; IPC$ is blocked before here */
+ finfo.extended.type = DT_FIFO;
+ break;
+
+ default:
+ DEBUG(1,("Unexpected share type 0x%lx\n", type));
+ break;
+
+ }
+ strncpy(finfo.extended.comment, comment,
+ sizeof(finfo.extended.comment));
- smbw_dir_add(&finfo, NULL, NULL);
+ smbw_dir_add(&finfo.file_info, NULL, &finfo.extended);
}
@@ -119,14 +157,17 @@
static void smbw_server_add(const char *name, uint32 type,
const char *comment, void *state)
{
- struct file_info finfo;
+ int count;
+ struct smbw_file_info finfo;
ZERO_STRUCT(finfo);
- pstrcpy(finfo.name, name);
- finfo.mode = aRONLY | aDIR;
-
- smbw_dir_add(&finfo, NULL, NULL);
+ pstrcpy(finfo.file_info.name, name);
+ finfo.file_info.mode = aRONLY | aDIR;
+ finfo.extended.type = DT_DIR;
+ strncpy(finfo.extended.comment, comment,
+ sizeof(finfo.extended.comment));
+ smbw_dir_add(&finfo.file_info, NULL, &finfo.extended);
}
@@ -140,7 +181,6 @@
ZERO_STRUCT(finfo);
pstrcpy(finfo.name, job->name);
- finfo.mode = aRONLY | aDIR;
finfo.mtime = job->t;
finfo.atime = job->t;
finfo.ctime = job->t;
@@ -194,6 +234,8 @@
cur_dir = dir;
+ dir->srv = srv;
+
slprintf(mask, sizeof(mask)-1, "%s\\*", path);
all_string_sub(mask,"\\\\","\\",0);
@@ -258,9 +300,8 @@
bitmap_set(smbw_file_bmap, fd);
- dir->fd = fd;
- dir->srv = srv;
dir->path = strdup(s);
+ dir->fd = fd;
DEBUG(4,(" -> %d\n", dir->count));
@@ -277,7 +318,7 @@
/*****************************************************
a wrapper for fstat() on a directory
*******************************************************/
-int smbw_dir_fstat(int fd, struct stat *st)
+int smbw_dir_fstat(int fd, struct SMBW_stat *st)
{
struct smbw_dir *dir;
@@ -322,10 +363,11 @@
/*****************************************************
a wrapper for getdents()
*******************************************************/
-int smbw_getdents(unsigned int fd, struct dirent *dirp, int count)
+int smbw_getdents(unsigned int fd, struct SMBW_dirent *dirp, int count)
{
struct smbw_dir *dir;
int n=0;
+ struct smbw_file_info *info;
smbw_busy++;
@@ -336,26 +378,37 @@
return -1;
}
- while (count>=DIRP_SIZE && (dir->offset < dir->count)) {
-#if HAVE_DIRENT_D_OFF
- dirp->d_off = (dir->offset+1)*DIRP_SIZE;
-#endif
- dirp->d_reclen = DIRP_SIZE;
- fstrcpy(&dirp->d_name[0], dir->list[dir->offset].name);
- dirp->d_ino = smbw_inode(dir->list[dir->offset].name);
+ while (count>=sizeof(struct SMBW_dirent) &&
+ (dir->offset < dir->count)) {
+ dirp->d_off = (dir->offset+1)*sizeof(struct SMBW_dirent);
+ dirp->d_reclen = sizeof(struct SMBW_dirent);
+
+ info = &dir->list[dir->offset];
+
+ if (dir->want_extended) {
+ snprintf(&dirp->d_name[0],
+ sizeof(dirp->d_name),
+ "%s:%s:%ld",
+ info->file_info.name,
+ info->extended.comment,
+ smbw_convert_mode(info->file_info.mode));
+ }
+ else
+ fstrcpy(&dirp->d_name[0], info->file_info.name);
+
+ dirp->d_ino = smbw_inode(info->file_info.name);
+ dirp->d_type = info->extended.type;
dir->offset++;
count -= dirp->d_reclen;
-#if HAVE_DIRENT_D_OFF
if (dir->offset == dir->count) {
dirp->d_off = -1;
}
-#endif
- dirp = (struct dirent *)(((char *)dirp) + DIRP_SIZE);
+ dirp++;
n++;
}
smbw_busy--;
- return n*DIRP_SIZE;
+ return n*sizeof(struct SMBW_dirent);
}
@@ -375,7 +428,7 @@
len = strlen(smbw_prefix);
- if (smbw_busy) return real_chdir(name);
+ if (smbw_busy) return (* smbw_libc.chdir)(name);
smbw_busy++;
@@ -396,7 +449,7 @@
}
if (strncmp(cwd,smbw_prefix,strlen(smbw_prefix))) {
- if (real_chdir(cwd) == 0) {
+ if ((* smbw_libc.chdir)(cwd) == 0) {
goto success2;
}
goto failed;
@@ -424,7 +477,7 @@
success1:
/* we don't want the old directory to be busy */
- real_chdir("/");
+ (* smbw_libc.chdir)("/");
success2:
@@ -567,7 +620,7 @@
smbw_init();
if (smbw_busy) {
- return (char *)real_getcwd(buf, size);
+ return (char *)(* smbw_libc.getcwd)(buf, size);
}
smbw_busy++;
@@ -610,7 +663,7 @@
return chdir(dir->path);
}
- ret = real_fchdir(fd);
+ ret = (* smbw_libc.fchdir)(fd);
if (ret == 0) {
sys_getwd(smbw_cwd);
}
@@ -625,9 +678,17 @@
DIR *smbw_opendir(const char *fname)
{
int fd;
+ char *p;
+ struct smbw_dir *d;
smbw_busy++;
+ /* magic character at end of name enables appending comment */
+ if ((p = strrchr(fname, ':')) != NULL && p[1] == '\0')
+ *p = '\0';
+ else
+ p = NULL;
+
fd = smbw_dir_open(fname);
if (fd == -1) {
@@ -637,27 +698,45 @@
smbw_busy--;
- return (DIR *)smbw_dir(fd);
+ d = smbw_dir(fd);
+ if (d != NULL && p != NULL)
+ d->want_extended = 1;
+
+ return (DIR *) d;
}
/*****************************************************
read one entry from a directory
*******************************************************/
-struct dirent *smbw_readdir(DIR *dirp)
+struct SMBW_dirent *smbw_readdir(DIR *dirp)
{
struct smbw_dir *d = (struct smbw_dir *)dirp;
- static union {
- char buf[DIRP_SIZE];
- struct dirent de;
- } dbuf;
- if (smbw_getdents(d->fd, &dbuf.de, DIRP_SIZE) > 0)
- return &dbuf.de;
+ if (smbw_getdents(d->fd, &d->dirent, sizeof(struct SMBW_dirent)) > 0)
+ return &d->dirent;
return NULL;
}
/*****************************************************
+read one entry from a directory in a reentrant fashion
+*******************************************************/
+int smbw_readdir_r(DIR *dirp,
+ struct SMBW_dirent *__restrict entry,
+ struct SMBW_dirent **__restrict result)
+{
+ struct smbw_dir *d = (struct smbw_dir *)dirp;
+
+ if (smbw_getdents(d->fd, entry, sizeof(struct SMBW_dirent)) > 0) {
+ if (result != NULL) *result = entry;
+ return 0;
+ }
+
+ if (result != NULL) *result = NULL;
+ return EBADF;
+}
+
+/*****************************************************
close a DIR*
*******************************************************/
int smbw_closedir(DIR *dirp)
@@ -669,16 +748,21 @@
/*****************************************************
seek in a directory
*******************************************************/
-void smbw_seekdir(DIR *dirp, off_t offset)
+void smbw_seekdir(DIR *dirp, long long offset)
{
struct smbw_dir *d = (struct smbw_dir *)dirp;
- smbw_dir_lseek(d->fd,offset, SEEK_SET);
+ if (offset == -1)
+ d->want_extended = 1;
+ else if (offset == -2)
+ d->want_extended = 0;
+ else
+ smbw_dir_lseek(d->fd,offset, SEEK_SET);
}
/*****************************************************
current loc in a directory
*******************************************************/
-off_t smbw_telldir(DIR *dirp)
+long long smbw_telldir(DIR *dirp)
{
struct smbw_dir *d = (struct smbw_dir *)dirp;
return smbw_dir_lseek(d->fd,0,SEEK_CUR);
diff -r -u samba-2.2.3a.debian/source/smbwrapper/smbw_stat.c samba-2.2.3a/source/smbwrapper/smbw_stat.c
--- samba-2.2.3a.debian/source/smbwrapper/smbw_stat.c Sat Feb 2 19:46:57 2002
+++ samba-2.2.3a/source/smbwrapper/smbw_stat.c Wed Dec 25 15:46:34 2002
@@ -20,28 +20,35 @@
*/
#include "includes.h"
+#include "wrapper.h"
extern int smbw_busy;
-/*****************************************************
-setup basic info in a stat structure
-*******************************************************/
-void smbw_setup_stat(struct stat *st, char *fname, size_t size, int mode)
+int smbw_convert_mode(int in)
{
- st->st_mode = 0;
+ int out = 0;
- if (IS_DOS_DIR(mode)) {
- st->st_mode = SMBW_DIR_MODE;
+ if (IS_DOS_DIR(in)) {
+ out = SMBW_DIR_MODE;
} else {
- st->st_mode = SMBW_FILE_MODE;
+ out = SMBW_FILE_MODE;
}
- if (IS_DOS_ARCHIVE(mode)) st->st_mode |= S_IXUSR;
- if (IS_DOS_SYSTEM(mode)) st->st_mode |= S_IXGRP;
- if (IS_DOS_HIDDEN(mode)) st->st_mode |= S_IXOTH;
- if (!IS_DOS_READONLY(mode)) st->st_mode |= S_IWUSR;
+ if (IS_DOS_ARCHIVE(in)) out |= S_IXUSR;
+ if (IS_DOS_SYSTEM(in)) out |= S_IXGRP;
+ if (IS_DOS_HIDDEN(in)) out |= S_IXOTH;
+ if (!IS_DOS_READONLY(in)) out |= S_IWUSR;
+
+ return out;
+}
+/*****************************************************
+setup basic info in a stat structure
+*******************************************************/
+void smbw_setup_stat(struct SMBW_stat *st, char *fname, size_t size, int mode)
+{
+ st->st_mode = smbw_convert_mode(mode);
st->st_size = size;
st->st_blksize = 512;
st->st_blocks = (size+511)/512;
@@ -123,7 +130,7 @@
/*****************************************************
a wrapper for fstat()
*******************************************************/
-int smbw_fstat(int fd, struct stat *st)
+int smbw_fstat(int fd, struct SMBW_stat *st)
{
struct smbw_file *file;
time_t c_time, a_time, m_time;
@@ -169,7 +176,7 @@
/*****************************************************
a wrapper for stat()
*******************************************************/
-int smbw_stat(const char *fname, struct stat *st)
+int smbw_stat(const char *fname, struct SMBW_stat *st)
{
struct smbw_server *srv;
fstring server, share;
Only in samba-2.2.3a.debian/source/smbwrapper: wrapped.c
Only in samba-2.2.3a/source/smbwrapper: wrapper.c
Only in samba-2.2.3a/source/smbwrapper: wrapper.h
More information about the samba-technical
mailing list