From a897c3ceda9fc2fad22edc2d884e5ecd87995592 Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Sun, 18 Aug 2002 15:46:41 +0000 Subject: make the LOCK1 test randomise the time for the blocking lock test (This used to be commit 28d325227c9b7ab48a47df006204319b21f7e7f7) --- source3/torture/torture.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source3/torture') diff --git a/source3/torture/torture.c b/source3/torture/torture.c index 101f4071cb..f3b816c80f 100644 --- a/source3/torture/torture.c +++ b/source3/torture/torture.c @@ -829,7 +829,7 @@ static BOOL run_locktest1(int dummy) printf("Testing lock timeouts\n"); t1 = time(NULL); - if (cli_lock(&cli2, fnum3, 0, 4, 10*1000, WRITE_LOCK)) { + if (cli_lock(&cli2, fnum3, 0, 4, (1 + (random() % 20)) * 1000, WRITE_LOCK)) { printf("lock3 succeeded! This is a locking bug\n"); return False; } else { -- cgit From 789e6e6b4e2aea9802d67fdb9dfcd7c283ef811d Mon Sep 17 00:00:00 2001 From: Simo Sorce Date: Sun, 18 Aug 2002 18:04:00 +0000 Subject: A new utility to test VFS system and modules Just now it is acommandline tool like smbclient and rpcclient that is able to perform operations on the file system passing through the vfs layer It is not complete yet, some functions have simply faked up data, but module loading works yet and basic operations too. Thanks to Eric Lorimer for helping out with the initial setup. Simo. (This used to be commit 42ae5eb82657d4905bdaf247286f95599380afbb) --- source3/torture/cmd_vfs.c | 872 ++++++++++++++++++++++++++++++++++++++++++++++ source3/torture/vfstest.c | 551 +++++++++++++++++++++++++++++ source3/torture/vfstest.h | 45 +++ 3 files changed, 1468 insertions(+) create mode 100644 source3/torture/cmd_vfs.c create mode 100644 source3/torture/vfstest.c create mode 100644 source3/torture/vfstest.h (limited to 'source3/torture') diff --git a/source3/torture/cmd_vfs.c b/source3/torture/cmd_vfs.c new file mode 100644 index 0000000000..3657d3f70d --- /dev/null +++ b/source3/torture/cmd_vfs.c @@ -0,0 +1,872 @@ +/* + Unix SMB/CIFS implementation. + VFS module functions + + Copyright (C) Simo Sorce 2002 + Copyright (C) Eric Lorimer 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. +*/ + +#include "includes.h" +#include "vfstest.h" + +static char *null_string = ""; + +static NTSTATUS cmd_load_module(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + struct smb_vfs_handle_struct *handle; + + if (argc != 2) { + printf("Usage: load \n"); + return NT_STATUS_OK; + } + vfs->conn->vfs_private = NULL; + handle = (struct smb_vfs_handle_struct *) smb_xmalloc(sizeof(smb_vfs_handle_struct)); + handle->handle = NULL; + DLIST_ADD(vfs->conn->vfs_private, handle) + if (!vfs_init_custom(vfs->conn, argv[1])) { + DEBUG(0, ("load: error=-1 (vfs_init_custom failed for %s)\n", argv[1])); + return NT_STATUS_UNSUCCESSFUL; + } + printf("load: ok\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_populate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + char c; + size_t size; + if (argc != 3) { + printf("Usage: populate \n"); + return NT_STATUS_OK; + } + c = argv[1][0]; + size = atoi(argv[2]); + vfs->data = (char *)talloc(mem_ctx, size); + if (vfs->data == NULL) { + printf("read: error=-1 (not enough memory)"); + return NT_STATUS_UNSUCCESSFUL; + } + memset(vfs->data, c, size); + vfs->data_size = size; + return NT_STATUS_OK; +} + +static NTSTATUS cmd_show_data(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + size_t offset; + size_t len; + if (argc != 1 && argc != 3) { + printf("Usage: showdata [ ]\n"); + return NT_STATUS_OK; + } + if (vfs->data == NULL || vfs->data_size == 0) { + printf("show_data: error=-1 (buffer empty)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + if (argc == 3) { + offset = atoi(argv[1]); + len = atoi(argv[2]); + } else { + offset = 0; + len = vfs->data_size; + } + if ((offset + len) > vfs->data_size) { + printf("show_data: error=-1 (not enough data in buffer)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + dump_data(0, (char *)(vfs->data) + offset, len); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_connect(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + vfs->conn->vfs_ops.connect(vfs->conn, lp_servicename(vfs->conn->service), "vfstest"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_disconnect(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + vfs->conn->vfs_ops.disconnect(vfs->conn); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_disk_free(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + SMB_BIG_UINT diskfree, bsize, dfree, dsize; + if (argc != 2) { + printf("Usage: disk_free \n"); + return NT_STATUS_OK; + } + + diskfree = vfs->conn->vfs_ops.disk_free(vfs->conn, argv[1], False, &bsize, &dfree, &dsize); + printf("disk_free: %ld, bsize = %ld, dfree = %ld, dsize = %ld\n", diskfree, bsize, dfree, dsize); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_opendir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + if (argc != 2) { + printf("Usage: opendir \n"); + return NT_STATUS_OK; + } + + vfs->currentdir = vfs->conn->vfs_ops.opendir(vfs->conn, argv[1]); + if (vfs->currentdir == NULL) { + printf("opendir error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("opendir: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_readdir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + struct dirent *dent; + + if (vfs->currentdir == NULL) { + printf("readdir: error=-1 (no open directory)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + dent = vfs->conn->vfs_ops.readdir(vfs->conn, vfs->currentdir); + if (dent == NULL) { + printf("readdir: NULL\n"); + return NT_STATUS_OK; + } + + printf("readdir: %s\n", dent->d_name); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_mkdir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + if (argc != 2) { + printf("Usage: mkdir \n"); + return NT_STATUS_OK; + } + + if (vfs->conn->vfs_ops.mkdir(vfs->conn, argv[1], 00755) == -1) { + printf("mkdir error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("mkdir: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_closedir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int ret; + + if (vfs->currentdir == NULL) { + printf("closedir: failure (no directory open)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + ret = vfs->conn->vfs_ops.closedir(vfs->conn, vfs->currentdir); + if (ret == -1) { + printf("closedir failure: %s\n", strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("closedir: ok\n"); + vfs->currentdir = NULL; + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_open(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int flags, mode, fd; + + flags = O_RDWR | O_CREAT; + mode = 00400; + + if (argc != 2) { + printf("Usage: open \n"); + return NT_STATUS_OK; + } + + fd = vfs->conn->vfs_ops.open(vfs->conn, argv[1], flags, mode); + if (fd == -1) { + printf("open: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + vfs->files[fd] = (struct files_struct *)malloc(sizeof(struct files_struct)); + vfs->files[fd]->fsp_name = strdup(argv[1]); + vfs->files[fd]->fd = fd; + vfs->files[fd]->conn = vfs->conn; + printf("open: fd=%d\n", fd); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_pathfunc(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int ret = -1; + struct func_entry *fptr; + struct func_entry func_table[] = { + { "rmdir", vfs->conn->vfs_ops.rmdir }, + { "unlink", vfs->conn->vfs_ops.unlink }, + { "chdir", vfs->conn->vfs_ops.chdir }, + { NULL } + }; + + if (argc != 2) { + printf("Usage: %s \n", argv[0]); + return NT_STATUS_OK; + } + + for (fptr=func_table; *fptr->name; fptr++) + if (strcmp(fptr->name, argv[0]) == 0 ) + ret = fptr->fn(vfs->conn, argv[1]); + + if (ret == -1) { + printf("%s: error=%d (%s)\n", argv[0], errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("%s: ok\n", argv[0]); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_close(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int fd, ret; + + if (argc != 2) { + printf("Usage: close \n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + if (vfs->files[fd] == NULL) { + printf("close: error=-1 (invalid file descriptor)\n"); + return NT_STATUS_OK; + } + + ret = vfs->conn->vfs_ops.close(vfs->files[fd], fd); + if (ret == -1 ) + printf("close: error=%d (%s)\n", errno, strerror(errno)); + else + printf("close: ok\n"); + + SAFE_FREE(vfs->files[fd]->fsp_name); + SAFE_FREE(vfs->files[fd]); + vfs->files[fd] = NULL; + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_read(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int fd; + size_t size, rsize; + + if (argc != 3) { + printf("Usage: read \n"); + return NT_STATUS_OK; + } + + /* do some error checking on these */ + fd = atoi(argv[1]); + size = atoi(argv[2]); + vfs->data = (char *)talloc(mem_ctx, size); + if (vfs->data == NULL) { + printf("read: error=-1 (not enough memory)"); + return NT_STATUS_UNSUCCESSFUL; + } + vfs->data_size = size; + + rsize = 0; + while (rsize < size) { + int isize; + isize = vfs->conn->vfs_ops.read(vfs->files[fd], fd, vfs->data, size); + if (isize == -1) { + printf("read: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + rsize += isize; + } + + printf("read: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_write(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int fd, size, wsize; + + if (argc != 3) { + printf("Usage: write \n"); + return NT_STATUS_OK; + } + + /* some error checking should go here */ + fd = atoi(argv[1]); + size = atoi(argv[2]); + if (vfs->data == NULL) { + printf("write: error=-1 (buffer empty, please populate it before writing)"); + return NT_STATUS_UNSUCCESSFUL; + } + + if (vfs->data_size < size) { + printf("write: error=-1 (buffer too small, please put some more data in)"); + return NT_STATUS_UNSUCCESSFUL; + } + + wsize = vfs->conn->vfs_ops.write(vfs->files[fd], fd, vfs->data, size); + + if (wsize == -1) { + printf("write: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("write: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_lseek(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int fd, offset, whence; + SMB_OFF_T pos; + + if (argc != 4) { + printf("Usage: lseek \n...where whence is 1 => SEEK_SET, 2 => SEEK_CUR, 3 => SEEK_END\n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + offset = atoi(argv[2]); + whence = atoi(argv[3]); + switch (whence) { + case 1: whence = SEEK_SET; break; + case 2: whence = SEEK_CUR; break; + default: whence = SEEK_END; + } + + pos = vfs->conn->vfs_ops.lseek(vfs->files[fd], fd, offset, whence); + if (pos == (SMB_OFF_T)-1) { + printf("lseek: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("lseek: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_rename(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int ret; + if (argc != 3) { + printf("Usage: rename \n"); + return NT_STATUS_OK; + } + + ret = vfs->conn->vfs_ops.rename(vfs->conn, argv[1], argv[2]); + if (ret == -1) { + printf("rename: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("rename: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_fsync(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int ret, fd; + if (argc != 2) { + printf("Usage: fsync \n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + ret = vfs->conn->vfs_ops.fsync(vfs->files[fd], fd); + if (ret == -1) { + printf("fsync: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("fsync: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_stat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int ret; + char *user; + char *group; + struct passwd *pwd; + struct group *grp; + SMB_STRUCT_STAT st; + + if (argc != 2) { + printf("Usage: stat \n"); + return NT_STATUS_OK; + } + + ret = vfs->conn->vfs_ops.stat(vfs->conn, argv[1], &st); + if (ret == -1) { + printf("stat: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + pwd = sys_getpwuid(st.st_uid); + if (pwd != NULL) user = strdup(pwd->pw_name); + else user = null_string; + grp = sys_getgrgid(st.st_gid); + if (grp != NULL) group = strdup(grp->gr_name); + else group = null_string; + + printf("stat: ok\n"); + printf(" File: %s", argv[1]); + if (S_ISREG(st.st_mode)) printf(" Regular File\n"); + else if (S_ISDIR(st.st_mode)) printf(" Directory\n"); + else if (S_ISCHR(st.st_mode)) printf(" Character Device\n"); + else if (S_ISBLK(st.st_mode)) printf(" Block Device\n"); + else if (S_ISFIFO(st.st_mode)) printf(" Fifo\n"); + else if (S_ISLNK(st.st_mode)) printf(" Symbolic Link\n"); + else if (S_ISSOCK(st.st_mode)) printf(" Socket\n"); + printf(" Size: %10d", st.st_size); + printf(" Blocks: %9d", st.st_blocks); + printf(" IO Block: %d\n", st.st_blksize); + printf(" Device: 0x%.10x", st.st_dev); + printf(" Inode: %10d", st.st_ino); + printf(" Links: %10d\n", st.st_nlink); + printf(" Access: %05d ", (st.st_mode) & 0x7fff); + printf(" Uid: %5d/%.16s Gid: %5d/%.16s\n", st.st_uid, user, st.st_gid, group); + printf(" Access: %s", ctime(&(st.st_atime))); + printf(" Modify: %s", ctime(&(st.st_mtime))); + printf(" Change: %s", ctime(&(st.st_ctime))); + if (user != null_string) SAFE_FREE(user); + if (group!= null_string) SAFE_FREE(group); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_fstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int fd; + char *user; + char *group; + struct passwd *pwd; + struct group *grp; + SMB_STRUCT_STAT st; + + if (argc != 2) { + printf("Usage: fstat \n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + if (fd < 0 || fd > 1024) { + printf("fstat: error=%d (file descriptor out of range)\n", EBADF); + return NT_STATUS_OK; + } + + if (vfs->files[fd] == NULL) { + printf("fstat: error=%d (invalid file descriptor)\n", EBADF); + return NT_STATUS_OK; + } + + if (vfs->conn->vfs_ops.fstat(vfs->files[fd], fd, &st) == -1) { + printf("fstat: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + pwd = sys_getpwuid(st.st_uid); + if (pwd != NULL) user = strdup(pwd->pw_name); + else user = null_string; + grp = sys_getgrgid(st.st_gid); + if (grp != NULL) group = strdup(grp->gr_name); + else group = null_string; + + printf("fstat: ok\n"); + if (S_ISREG(st.st_mode)) printf(" Regular File\n"); + else if (S_ISDIR(st.st_mode)) printf(" Directory\n"); + else if (S_ISCHR(st.st_mode)) printf(" Character Device\n"); + else if (S_ISBLK(st.st_mode)) printf(" Block Device\n"); + else if (S_ISFIFO(st.st_mode)) printf(" Fifo\n"); + else if (S_ISLNK(st.st_mode)) printf(" Symbolic Link\n"); + else if (S_ISSOCK(st.st_mode)) printf(" Socket\n"); + printf(" Size: %10d", st.st_size); + printf(" Blocks: %9d", st.st_blocks); + printf(" IO Block: %d\n", st.st_blksize); + printf(" Device: 0x%10x", st.st_dev); + printf(" Inode: %10d", st.st_ino); + printf(" Links: %10d\n", st.st_nlink); + printf(" Access: %05d ", (st.st_mode) & 0x7fff); + printf(" Uid: %5d/%.16s Gid: %5d/%.16s\n", st.st_uid, user, st.st_gid, group); + printf(" Access: %s", ctime(&(st.st_atime))); + printf(" Modify: %s", ctime(&(st.st_mtime))); + printf(" Change: %s", ctime(&(st.st_ctime))); + if (user != null_string) SAFE_FREE(user); + if (group!= null_string) SAFE_FREE(group); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_lstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + char *user; + char *group; + struct passwd *pwd; + struct group *grp; + SMB_STRUCT_STAT st; + + if (argc != 2) { + printf("Usage: lstat \n"); + return NT_STATUS_OK; + } + + if (vfs->conn->vfs_ops.lstat(vfs->conn, argv[1], &st) == -1) { + printf("lstat: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + pwd = sys_getpwuid(st.st_uid); + if (pwd != NULL) user = strdup(pwd->pw_name); + else user = null_string; + grp = sys_getgrgid(st.st_gid); + if (grp != NULL) group = strdup(grp->gr_name); + else group = null_string; + + printf("lstat: ok\n"); + if (S_ISREG(st.st_mode)) printf(" Regular File\n"); + else if (S_ISDIR(st.st_mode)) printf(" Directory\n"); + else if (S_ISCHR(st.st_mode)) printf(" Character Device\n"); + else if (S_ISBLK(st.st_mode)) printf(" Block Device\n"); + else if (S_ISFIFO(st.st_mode)) printf(" Fifo\n"); + else if (S_ISLNK(st.st_mode)) printf(" Symbolic Link\n"); + else if (S_ISSOCK(st.st_mode)) printf(" Socket\n"); + printf(" Size: %10d", st.st_size); + printf(" Blocks: %9d", st.st_blocks); + printf(" IO Block: %d\n", st.st_blksize); + printf(" Device: 0x%10x", st.st_dev); + printf(" Inode: %10d", st.st_ino); + printf(" Links: %10d\n", st.st_nlink); + printf(" Access: %05d ", (st.st_mode) & 0x7fff); + printf(" Uid: %5d/%.16s Gid: %5d/%.16s\n", st.st_uid, user, st.st_gid, group); + printf(" Access: %s", ctime(&(st.st_atime))); + printf(" Modify: %s", ctime(&(st.st_mtime))); + printf(" Change: %s", ctime(&(st.st_ctime))); + if (user != null_string) SAFE_FREE(user); + if (group!= null_string) SAFE_FREE(group); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_chmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + mode_t mode; + if (argc != 3) { + printf("Usage: chmod \n"); + return NT_STATUS_OK; + } + + mode = atoi(argv[2]); + if (vfs->conn->vfs_ops.chmod(vfs->conn, argv[1], mode) == -1) { + printf("chmod: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("chmod: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_fchmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int fd; + mode_t mode; + if (argc != 3) { + printf("Usage: fchmod \n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + mode = atoi(argv[2]); + if (fd < 0 || fd > 1024) { + printf("fchmod: error=%d (file descriptor out of range)\n", EBADF); + return NT_STATUS_OK; + } + if (vfs->files[fd] == NULL) { + printf("fchmod: error=%d (invalid file descriptor)\n", EBADF); + return NT_STATUS_OK; + } + + if (vfs->conn->vfs_ops.fchmod(vfs->files[fd], fd, mode) == -1) { + printf("fchmod: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("fchmod: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_chown(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + uid_t uid; + gid_t gid; + if (argc != 4) { + printf("Usage: chown \n"); + return NT_STATUS_OK; + } + + uid = atoi(argv[2]); + gid = atoi(argv[3]); + if (vfs->conn->vfs_ops.chown(vfs->conn, argv[1], uid, gid) == -1) { + printf("chown: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("chown: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_fchown(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + uid_t uid; + gid_t gid; + int fd; + if (argc != 4) { + printf("Usage: fchown \n"); + return NT_STATUS_OK; + } + + uid = atoi(argv[2]); + gid = atoi(argv[3]); + fd = atoi(argv[1]); + if (fd < 0 || fd > 1024) { + printf("fchown: faliure=%d (file descriptor out of range)\n", EBADF); + return NT_STATUS_OK; + } + if (vfs->files[fd] == NULL) { + printf("fchown: error=%d (invalid file descriptor)\n", EBADF); + return NT_STATUS_OK; + } + if (vfs->conn->vfs_ops.fchown(vfs->files[fd], fd, uid, gid) == -1) { + printf("fchown error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("fchown: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_getwd(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + char buf[PATH_MAX]; + if (vfs->conn->vfs_ops.getwd(vfs->conn, buf) == NULL) { + printf("getwd: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("getwd: %s\n", buf); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_utime(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + struct utimbuf times; + if (argc != 4) { + printf("Usage: utime \n"); + return NT_STATUS_OK; + } + times.actime = atoi(argv[2]); + times.modtime = atoi(argv[3]); + if (vfs->conn->vfs_ops.utime(vfs->conn, argv[1], ×) != 0) { + printf("utime: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("utime: ok\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_ftruncate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int fd; + SMB_OFF_T off; + if (argc != 3) { + printf("Usage: ftruncate \n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + off = atoi(argv[2]); + if (fd < 0 || fd > 1024) { + printf("ftruncate: error=%d (file descriptor out of range)\n", EBADF); + return NT_STATUS_OK; + } + if (vfs->files[fd] == NULL) { + printf("ftruncate: error=%d (invalid file descriptor)\n", EBADF); + return NT_STATUS_OK; + } + + if (vfs->conn->vfs_ops.ftruncate(vfs->files[fd], fd, off) == -1) { + printf("ftruncate: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("ftruncate: ok\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_lock(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + printf("lock: Not yet implemented!\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_symlink(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + if (argc != 3) { + printf("Usage: symlink \n"); + return NT_STATUS_OK; + } + + if (vfs->conn->vfs_ops.symlink(vfs->conn, argv[1], argv[2]) == -1) { + printf("symlink: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("symlink: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_readlink(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + char buffer[PATH_MAX]; + int size; + + if (argc != 2) { + printf("Usage: readlink \n"); + return NT_STATUS_OK; + } + + if ((size = vfs->conn->vfs_ops.readlink(vfs->conn, argv[1], buffer, PATH_MAX)) == -1) { + printf("readlink: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + buffer[size] = '\0'; + printf("readlink: %s\n", buffer); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_link(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + if (argc != 3) { + printf("Usage: link \n"); + return NT_STATUS_OK; + } + + if (vfs->conn->vfs_ops.link(vfs->conn, argv[1], argv[2]) == -1) { + printf("link: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("link: ok\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_mknod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + printf("lock: Not yet implemented!\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_realpath(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + char respath[PATH_MAX]; + + if (argc != 2) { + printf("Usage: realpath \n"); + return NT_STATUS_OK; + } + + if (vfs->conn->vfs_ops.realpath(vfs->conn, argv[1], respath) == NULL) { + printf("realpath: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("realpath: ok\n"); + return NT_STATUS_OK; +} + +struct cmd_set vfs_commands[] = { + + { "VFS Commands" }, + + { "load", cmd_load_module, "Load a module", "load " }, + { "populate", cmd_populate, "Populate a data buffer", "populate " }, + { "showdata", cmd_show_data, "Show data currently in data buffer", "show_data [ ]"}, + { "connect", cmd_connect, "VFS connect()", "connect" }, + { "disconnect", cmd_disconnect, "VFS disconnect()", "disconnect" }, + { "disk_free", cmd_disk_free, "VFS disk_free()", "disk_free " }, + { "opendir", cmd_opendir, "VFS opendir()", "opendir " }, + { "readdir", cmd_readdir, "VFS readdir()", "readdir" }, + { "mkdir", cmd_mkdir, "VFS mkdir()", "mkdir " }, + { "rmdir", cmd_pathfunc, "VFS rmdir()", "rmdir " }, + { "closedir", cmd_closedir, "VFS closedir()", "closedir" }, + { "open", cmd_open, "VFS open()", "open " }, + { "close", cmd_close, "VFS close()", "close " }, + { "read", cmd_read, "VFS read()", "read " }, + { "write", cmd_write, "VFS write()", "write " }, + { "lseek", cmd_lseek, "VFS lseek()", "lseek " }, + { "rename", cmd_rename, "VFS rename()", "rename " }, + { "fsync", cmd_fsync, "VFS fsync()", "fsync " }, + { "stat", cmd_stat, "VFS stat()", "stat " }, + { "fstat", cmd_fstat, "VFS fstat()", "fstat " }, + { "lstat", cmd_lstat, "VFS lstat()", "lstat " }, + { "unlink", cmd_pathfunc, "VFS unlink()", "unlink " }, + { "chmod", cmd_chmod, "VFS chmod()", "chmod " }, + { "fchmod", cmd_fchmod, "VFS fchmod()", "fchmod " }, + { "chown", cmd_chown, "VFS chown()", "chown " }, + { "fchown", cmd_fchown, "VFS fchown()", "fchown " }, + { "chdir", cmd_pathfunc, "VFS chdir()", "chdir " }, + { "getwd", cmd_getwd, "VFS getwd()", "getwd" }, + { "utime", cmd_utime, "VFS utime()", "utime " }, + { "ftruncate", cmd_ftruncate, "VFS ftruncate()", "ftruncate " }, + { "lock", cmd_lock, "VFS lock()", "lock: Not yet implemented!" }, + { "symlink", cmd_symlink, "VFS symlink()", "symlink " }, + { "readlink", cmd_readlink, "VFS readlink()", "readlink " }, + { "link", cmd_link, "VFS link()", "link " }, + { "mknod", cmd_mknod, "VFS mknod()", "mknod: Not yet implemented!" }, + { "realpath", cmd_realpath, "VFS realpath()", "realpath " }, + { NULL } +}; diff --git a/source3/torture/vfstest.c b/source3/torture/vfstest.c new file mode 100644 index 0000000000..18d4514c93 --- /dev/null +++ b/source3/torture/vfstest.c @@ -0,0 +1,551 @@ +/* + Unix SMB/CIFS implementation. + VFS module tester + + Copyright (C) Simo Sorce 2002 + Copyright (C) Eric Lorimer 2002 + + Most of this code was ripped off of rpcclient. + Copyright (C) Tim Potter 2000-2001 + + 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. +*/ + +#include "includes.h" +#include "vfstest.h" + +/* List to hold groups of commands */ +static struct cmd_list { + struct cmd_list *prev, *next; + struct cmd_set *cmd_set; +} *cmd_list; + +TALLOC_CTX *global_ctx; + +/**************************************************************************** +handle completion of commands for readline +****************************************************************************/ +static char **completion_fn(char *text, int start, int end) +{ +#define MAX_COMPLETIONS 100 + char **matches; + int i, count=0; + struct cmd_list *commands = cmd_list; + +#if 0 /* JERRY */ + /* FIXME!!! -- what to do when completing argument? */ + /* for words not at the start of the line fallback + to filename completion */ + if (start) + return NULL; +#endif + + /* make sure we have a list of valid commands */ + if (!commands) + return NULL; + + matches = (char **)malloc(sizeof(matches[0])*MAX_COMPLETIONS); + if (!matches) return NULL; + + matches[count++] = strdup(text); + if (!matches[0]) return NULL; + + while (commands && count < MAX_COMPLETIONS-1) + { + if (!commands->cmd_set) + break; + + for (i=0; commands->cmd_set[i].name; i++) + { + if ((strncmp(text, commands->cmd_set[i].name, strlen(text)) == 0) && + commands->cmd_set[i].fn) + { + matches[count] = strdup(commands->cmd_set[i].name); + if (!matches[count]) + return NULL; + count++; + } + } + + commands = commands->next; + + } + + if (count == 2) { + SAFE_FREE(matches[0]); + matches[0] = strdup(matches[1]); + } + matches[count] = NULL; + return matches; +} + +static char* next_command (char** cmdstr) +{ + static pstring command; + char *p; + + if (!cmdstr || !(*cmdstr)) + return NULL; + + p = strchr_m(*cmdstr, ';'); + if (p) + *p = '\0'; + pstrcpy(command, *cmdstr); + *cmdstr = p; + + return command; +} + + +/* Display help on commands */ +static NTSTATUS cmd_help(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, + int argc, char **argv) +{ + struct cmd_list *tmp; + struct cmd_set *tmp_set; + + /* Usage */ + if (argc > 2) { + printf("Usage: %s [command]\n", argv[0]); + return NT_STATUS_OK; + } + + /* Help on one command */ + + if (argc == 2) { + for (tmp = cmd_list; tmp; tmp = tmp->next) { + + tmp_set = tmp->cmd_set; + + while(tmp_set->name) { + if (strequal(argv[1], tmp_set->name)) { + if (tmp_set->usage && + tmp_set->usage[0]) + printf("%s\n", tmp_set->usage); + else + printf("No help for %s\n", tmp_set->name); + + return NT_STATUS_OK; + } + + tmp_set++; + } + } + + printf("No such command: %s\n", argv[1]); + return NT_STATUS_OK; + } + + /* List all commands */ + + for (tmp = cmd_list; tmp; tmp = tmp->next) { + + tmp_set = tmp->cmd_set; + + while(tmp_set->name) { + + printf("%15s\t\t%s\n", tmp_set->name, + tmp_set->description ? tmp_set->description: + ""); + + tmp_set++; + } + } + + return NT_STATUS_OK; +} + +/* Change the debug level */ +static NTSTATUS cmd_debuglevel(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + if (argc > 2) { + printf("Usage: %s [debuglevel]\n", argv[0]); + return NT_STATUS_OK; + } + + if (argc == 2) { + DEBUGLEVEL = atoi(argv[1]); + } + + printf("debuglevel is %d\n", DEBUGLEVEL); + + return NT_STATUS_OK; +} + +static NTSTATUS cmd_freemem(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + /* Cleanup */ + talloc_destroy(global_ctx); + global_ctx = NULL; + vfs->data = NULL; + vfs->data_size = NULL; +} + +static NTSTATUS cmd_quit(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + /* Cleanup */ + talloc_destroy(global_ctx); + + exit(0); + return NT_STATUS_OK; /* NOTREACHED */ +} + +static struct cmd_set vfstest_commands[] = { + + { "GENERAL OPTIONS" }, + + { "help", cmd_help, "Get help on commands", "[command]" }, + { "?", cmd_help, "Get help on commands", "[command]" }, + { "debuglevel", cmd_debuglevel, "Set debug level", "level" }, + { "freemem", cmd_freemem, "Free currently allocated buffers", "freemem" }, + { "exit", cmd_quit, "Exit program", "" }, + { "quit", cmd_quit, "Exit program", "" }, + + { NULL } +}; + +static struct cmd_set separator_command[] = { + { "---------------", NULL, "----------------------" }, + { NULL } +}; + + +extern struct cmd_set vfs_commands[]; +static struct cmd_set *vfstest_command_list[] = { + vfstest_commands, + vfs_commands, + NULL +}; + +static void add_command_set(struct cmd_set *cmd_set) +{ + struct cmd_list *entry; + + if (!(entry = (struct cmd_list *)malloc(sizeof(struct cmd_list)))) { + DEBUG(0, ("out of memory\n")); + return; + } + + ZERO_STRUCTP(entry); + + entry->cmd_set = cmd_set; + DLIST_ADD(cmd_list, entry); +} + +static NTSTATUS do_cmd(struct vfs_state *vfs, struct cmd_set *cmd_entry, char *cmd) +{ + char *p = cmd, **argv = NULL; + NTSTATUS result = NT_STATUS_UNSUCCESSFUL; + pstring buf; + int argc = 0, i; + + /* Count number of arguments first time through the loop then + allocate memory and strdup them. */ + + again: + while(next_token(&p, buf, " ", sizeof(buf))) { + if (argv) { + argv[argc] = strdup(buf); + } + + argc++; + } + + if (!argv) { + + /* Create argument list */ + + argv = (char **)malloc(sizeof(char *) * argc); + memset(argv, 0, sizeof(char *) * argc); + + if (!argv) { + fprintf(stderr, "out of memory\n"); + result = NT_STATUS_NO_MEMORY; + goto done; + } + + p = cmd; + argc = 0; + + goto again; + } + + /* Call the function */ + + if (cmd_entry->fn) { + + if (global_ctx == NULL) { + /* Create mem_ctx */ + if (!(global_ctx = talloc_init())) { + DEBUG(0, ("talloc_init() failed\n")); + goto done; + } + } + + /* Run command */ + result = cmd_entry->fn(vfs, global_ctx, argc, argv); + + } else { + fprintf (stderr, "Invalid command\n"); + goto done; + } + + done: + + /* Cleanup */ + + if (argv) { + for (i = 0; i < argc; i++) + SAFE_FREE(argv[i]); + + SAFE_FREE(argv); + } + + return result; +} + +/* Process a command entered at the prompt or as part of -c */ +static NTSTATUS process_cmd(struct vfs_state *vfs, char *cmd) +{ + struct cmd_list *temp_list; + BOOL found = False; + pstring buf; + char *p = cmd; + NTSTATUS result = NT_STATUS_OK; + int len = 0; + + if (cmd[strlen(cmd) - 1] == '\n') + cmd[strlen(cmd) - 1] = '\0'; + + if (!next_token(&p, buf, " ", sizeof(buf))) { + return NT_STATUS_OK; + } + + /* strip the trainly \n if it exsists */ + len = strlen(buf); + if (buf[len-1] == '\n') + buf[len-1] = '\0'; + + /* Search for matching commands */ + + for (temp_list = cmd_list; temp_list; temp_list = temp_list->next) { + struct cmd_set *temp_set = temp_list->cmd_set; + + while(temp_set->name) { + if (strequal(buf, temp_set->name)) { + found = True; + result = do_cmd(vfs, temp_set, cmd); + + goto done; + } + temp_set++; + } + } + + done: + if (!found && buf[0]) { + printf("command not found: %s\n", buf); + return NT_STATUS_OK; + } + + if (!NT_STATUS_IS_OK(result)) { + printf("result was %s\n", nt_errstr(result)); + } + + return result; +} + +void exit_server(char *reason) +{ + DEBUG(3,("Server exit (%s)\n", (reason ? reason : ""))); + exit(0); +} + +static int server_fd = -1; +int last_message = -1; + +int smbd_server_fd(void) +{ + return server_fd; +} + +BOOL reload_services(BOOL test) +{ + return True; +} + +/* Print usage information */ +static void usage(void) +{ + printf("Usage: vfstest [options]\n"); + + printf("\t-c or --command \"command string\" execute semicolon separated cmds\n"); + printf("\t-d or --debug debuglevel set the debuglevel\n"); + printf("\t-l or --logfile logfile logfile to use instead of stdout\n"); + printf("\t-h or --help Print this help message.\n"); + printf("\n"); +} + +/* Main function */ + +int main(int argc, char *argv[]) +{ + extern pstring global_myname; + static int got_pass = 0; + BOOL interactive = True; + int opt; + int olddebug; + static char *cmdstr = ""; + const char *server; + struct cli_state *cli; + fstring password="", + username="", + domain=""; + static char *opt_authfile=NULL, + *opt_username=NULL, + *opt_domain=NULL, + *opt_configfile=NULL, + *opt_logfile=NULL; + static int opt_debuglevel; + pstring logfile; + struct cmd_set **cmd_set; + struct in_addr server_ip; + NTSTATUS nt_status; + extern BOOL AllowDebugChange; + static struct vfs_state vfs; + int i; + + + /* make sure the vars that get altered (4th field) are in + a fixed location or certain compilers complain */ + poptContext pc; + struct poptOption long_options[] = { +/* {"conf", 's', POPT_ARG_STRING, &opt_configfile, 's'},*/ + {"debug", 'd', POPT_ARG_INT, &opt_debuglevel, 'd'}, + {"debuglevel", 'd', POPT_ARG_INT, &opt_debuglevel, 'd'}, +/* {"user", 'U', POPT_ARG_STRING, &opt_username, 'U'},*/ + {"command", 'c', POPT_ARG_STRING, &cmdstr}, + {"logfile", 'l', POPT_ARG_STRING, &opt_logfile, 'l'}, + {"help", 'h', POPT_ARG_NONE, 0, 'h'}, + { 0, 0, 0, 0} + }; + + + setlinebuf(stdout); + + DEBUGLEVEL = 1; + AllowDebugChange = False; + + pc = poptGetContext("vfstest", argc, (const char **) argv, + long_options, 0); + + while((opt = poptGetNextOpt(pc)) != -1) { + switch (opt) { + case 'l': + slprintf(logfile, sizeof(logfile) - 1, "%s.client", + opt_logfile); + lp_set_logfile(logfile); + interactive = False; + break; + + case 'd': + DEBUGLEVEL = opt_debuglevel; + break; + + /* + case 'U': { + char *lp; + + pstrcpy(username,opt_username); + + if ((lp=strchr_m(username,'%'))) { + *lp = 0; + pstrcpy(password,lp+1); + got_pass = 1; + memset(strchr_m(opt_username,'%') + 1, 'X', + strlen(password)); + } + break; + } + */ + + case 'h': + default: + usage(); + exit(1); + } + } + + + poptFreeContext(pc); + + /* the following functions are part of the Samba debugging + facilities. See lib/debug.c */ + setup_logging("vfstest", interactive); + if (!interactive) + reopen_logs(); + + /* Load command lists */ + + cmd_set = vfstest_command_list; + + while(*cmd_set) { + add_command_set(*cmd_set); + add_command_set(separator_command); + cmd_set++; + } + + /* some basic initialization stuff */ + vfs.conn = (struct connection_struct *)malloc(sizeof(struct connection_struct)); + vfs.conn->user = "vfstest"; + for (i=0; i < 1024; i++) + vfs.files[i] = NULL; + + /* Do anything specified with -c */ + if (cmdstr[0]) { + char *cmd; + char *p = cmdstr; + + while((cmd=next_command(&p)) != NULL) { + process_cmd(&vfs, cmd); + } + + return 0; + } + + /* Initialize VFS */ + vfs.conn->vfs_private = NULL; + smbd_vfs_init(vfs.conn); + + /* Loop around accepting commands */ + + while(1) { + pstring prompt; + char *line; + + slprintf(prompt, sizeof(prompt) - 1, "vfstest $> "); + + line = smb_readline(prompt, NULL, completion_fn); + + if (line == NULL) + break; + + if (line[0] != '\n') + process_cmd(&vfs, line); + } + + free(vfs.conn); + return 0; +} diff --git a/source3/torture/vfstest.h b/source3/torture/vfstest.h new file mode 100644 index 0000000000..b086faa402 --- /dev/null +++ b/source3/torture/vfstest.h @@ -0,0 +1,45 @@ +/* + Unix SMB/CIFS implementation. + VFS module tester + + Copyright (C) Simo Sorce 2002 + Copyright (C) Eric Lorimer 2002 + + Most of this code was ripped off of rpcclient. + Copyright (C) Tim Potter 2000-2001 + + 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. +*/ + +struct func_entry { + char *name; + int (*fn)(struct connection_struct *conn, const char *path); +}; + +struct vfs_state { + struct connection_struct *conn; + struct files_struct *files[1024]; + DIR *currentdir; + void *data; + size_t data_size; +}; + +struct cmd_set { + char *name; + NTSTATUS (*fn)(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, + char **argv); + char *description; + char *usage; +}; -- cgit From d433fc4dd3ff753a684b4e07c7f09d11ee704c21 Mon Sep 17 00:00:00 2001 From: Simo Sorce Date: Sun, 18 Aug 2002 19:22:10 +0000 Subject: improvements and bugfix open calls now understands flags and mode bug on read (This used to be commit 751d057713a3fa8a5a141eaed4e8401e7802cfc9) --- source3/torture/cmd_vfs.c | 88 ++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 71 insertions(+), 17 deletions(-) (limited to 'source3/torture') diff --git a/source3/torture/cmd_vfs.c b/source3/torture/cmd_vfs.c index 3657d3f70d..eb934932ea 100644 --- a/source3/torture/cmd_vfs.c +++ b/source3/torture/cmd_vfs.c @@ -57,7 +57,7 @@ static NTSTATUS cmd_populate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int arg size = atoi(argv[2]); vfs->data = (char *)talloc(mem_ctx, size); if (vfs->data == NULL) { - printf("read: error=-1 (not enough memory)"); + printf("populate: error=-1 (not enough memory)"); return NT_STATUS_UNSUCCESSFUL; } memset(vfs->data, c, size); @@ -198,13 +198,72 @@ static NTSTATUS cmd_closedir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int arg static NTSTATUS cmd_open(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) { int flags, mode, fd; + char *flagstr; - flags = O_RDWR | O_CREAT; mode = 00400; - if (argc != 2) { - printf("Usage: open \n"); - return NT_STATUS_OK; + if (argc < 3 || argc > 5) { + printf("Usage: open \n"); + printf(" flags: O = O_RDONLY\n"); + printf(" R = O_RDWR\n"); + printf(" W = O_WRONLY\n"); + printf(" C = O_CREAT\n"); + printf(" E = O_EXCL\n"); + printf(" T = O_TRUNC\n"); + printf(" A = O_APPEND\n"); + printf(" N = O_NONBLOCK/O_NDELAY\n"); + printf(" S = O_SYNC\n"); + printf(" F = O_NOFOLLOW\n"); + printf(" mode: see open.2\n"); + printf(" mode is ignored if C flag not present\n"); + printf(" mode defaults to 00400\n"); + return NT_STATUS_OK; + } + flags = 0; + flagstr = argv[2]; + while (*flagstr) { + switch (*flagstr) { + case 'O': + flags |= O_RDONLY; + break; + case 'R': + flags |= O_RDWR; + break; + case 'W': + flags |= O_WRONLY; + break; + case 'C': + flags |= O_CREAT; + break; + case 'E': + flags |= O_EXCL; + break; + case 'T': + flags |= O_TRUNC; + break; + case 'A': + flags |= O_APPEND; + break; + case 'N': + flags |= O_NONBLOCK; + break; + case 'S': + flags |= O_SYNC; + break; + case 'F': + flags |= O_NOFOLLOW; + break; + default: + printf("open: error=-1 (invalid flag!)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + flagstr++; + } + if ((flags & O_CREAT) && argc == 4) { + if (sscanf(argv[3], "%o", &mode) == 0) { + printf("open: error=-1 (invalid mode!)\n"); + return NT_STATUS_UNSUCCESSFUL; + } } fd = vfs->conn->vfs_ops.open(vfs->conn, argv[1], flags, mode); @@ -300,15 +359,10 @@ static NTSTATUS cmd_read(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, c } vfs->data_size = size; - rsize = 0; - while (rsize < size) { - int isize; - isize = vfs->conn->vfs_ops.read(vfs->files[fd], fd, vfs->data, size); - if (isize == -1) { - printf("read: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - rsize += isize; + rsize = vfs->conn->vfs_ops.read(vfs->files[fd], fd, vfs->data, size); + if (rsize == -1) { + printf("read: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; } printf("read: ok\n"); @@ -461,7 +515,7 @@ static NTSTATUS cmd_stat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, c printf(" Device: 0x%.10x", st.st_dev); printf(" Inode: %10d", st.st_ino); printf(" Links: %10d\n", st.st_nlink); - printf(" Access: %05d ", (st.st_mode) & 0x7fff); + printf(" Access: %05o", (st.st_mode) & 007777); printf(" Uid: %5d/%.16s Gid: %5d/%.16s\n", st.st_uid, user, st.st_gid, group); printf(" Access: %s", ctime(&(st.st_atime))); printf(" Modify: %s", ctime(&(st.st_mtime))); @@ -523,7 +577,7 @@ static NTSTATUS cmd_fstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, printf(" Device: 0x%10x", st.st_dev); printf(" Inode: %10d", st.st_ino); printf(" Links: %10d\n", st.st_nlink); - printf(" Access: %05d ", (st.st_mode) & 0x7fff); + printf(" Access: %05o", (st.st_mode) & 007777); printf(" Uid: %5d/%.16s Gid: %5d/%.16s\n", st.st_uid, user, st.st_gid, group); printf(" Access: %s", ctime(&(st.st_atime))); printf(" Modify: %s", ctime(&(st.st_mtime))); @@ -573,7 +627,7 @@ static NTSTATUS cmd_lstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, printf(" Device: 0x%10x", st.st_dev); printf(" Inode: %10d", st.st_ino); printf(" Links: %10d\n", st.st_nlink); - printf(" Access: %05d ", (st.st_mode) & 0x7fff); + printf(" Access: %05o", (st.st_mode) & 007777); printf(" Uid: %5d/%.16s Gid: %5d/%.16s\n", st.st_uid, user, st.st_gid, group); printf(" Access: %s", ctime(&(st.st_atime))); printf(" Modify: %s", ctime(&(st.st_mtime))); -- cgit From db9a33fd38c1ac445e5edc1c80499ac3300a4824 Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Sun, 18 Aug 2002 20:06:41 +0000 Subject: nicer locking timeout test (This used to be commit 2307869798c99f75d2624bb3c144e780e358a3c9) --- source3/torture/torture.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) (limited to 'source3/torture') diff --git a/source3/torture/torture.c b/source3/torture/torture.c index f3b816c80f..e7a8eb04b6 100644 --- a/source3/torture/torture.c +++ b/source3/torture/torture.c @@ -785,6 +785,7 @@ static BOOL run_locktest1(int dummy) char *fname = "\\lockt1.lck"; int fnum1, fnum2, fnum3; time_t t1, t2; + unsigned lock_timeout; if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) { return False; @@ -827,9 +828,10 @@ static BOOL run_locktest1(int dummy) } - printf("Testing lock timeouts\n"); + lock_timeout = (1 + (random() % 20)); + printf("Testing lock timeout with timeout=%u\n", lock_timeout); t1 = time(NULL); - if (cli_lock(&cli2, fnum3, 0, 4, (1 + (random() % 20)) * 1000, WRITE_LOCK)) { + if (cli_lock(&cli2, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK)) { printf("lock3 succeeded! This is a locking bug\n"); return False; } else { @@ -841,6 +843,8 @@ static BOOL run_locktest1(int dummy) if (t2 - t1 < 5) { printf("error: This server appears not to support timed lock requests\n"); } + printf("server slept for %u seconds for a %u second timeout\n", + t2-t1, lock_timeout); if (!cli_close(&cli1, fnum2)) { printf("close1 failed (%s)\n", cli_errstr(&cli1)); @@ -3863,6 +3867,7 @@ static void usage(void) argc--; argv++; + srandom(time(NULL)); fstrcpy(workgroup, lp_workgroup()); -- cgit From c9df8aa9cdd7400c346e9ef318a52d7256a015f0 Mon Sep 17 00:00:00 2001 From: Simo Sorce Date: Sun, 18 Aug 2002 20:28:16 +0000 Subject: O_NOFOLLOW does not exist on solaris 8 ?? (This used to be commit 4280300d80d831b78ca50a0a4325b9e239a8bb63) --- source3/torture/cmd_vfs.c | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'source3/torture') diff --git a/source3/torture/cmd_vfs.c b/source3/torture/cmd_vfs.c index eb934932ea..680d5bdfdc 100644 --- a/source3/torture/cmd_vfs.c +++ b/source3/torture/cmd_vfs.c @@ -213,7 +213,9 @@ static NTSTATUS cmd_open(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, c printf(" A = O_APPEND\n"); printf(" N = O_NONBLOCK/O_NDELAY\n"); printf(" S = O_SYNC\n"); +#ifdef O_NOFOLLOW printf(" F = O_NOFOLLOW\n"); +#endif printf(" mode: see open.2\n"); printf(" mode is ignored if C flag not present\n"); printf(" mode defaults to 00400\n"); @@ -250,9 +252,11 @@ static NTSTATUS cmd_open(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, c case 'S': flags |= O_SYNC; break; +#ifdef O_NOFOLLOW case 'F': flags |= O_NOFOLLOW; break; +#endif default: printf("open: error=-1 (invalid flag!)\n"); return NT_STATUS_UNSUCCESSFUL; -- cgit From cb2478befbcac990f6b601262a351733657ea497 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 19 Aug 2002 00:19:44 +0000 Subject: Add 'conf' command to load different smb.conf files (This used to be commit 9b4deb1e0f36968bf9b83120b12e6692b20df9d4) --- source3/torture/vfstest.c | 26 ++++++++++++++++++++++---- 1 file changed, 22 insertions(+), 4 deletions(-) (limited to 'source3/torture') diff --git a/source3/torture/vfstest.c b/source3/torture/vfstest.c index 18d4514c93..b8773d5785 100644 --- a/source3/torture/vfstest.c +++ b/source3/torture/vfstest.c @@ -108,7 +108,24 @@ static char* next_command (char** cmdstr) return command; } +/* Load specified configuration file */ +static NTSTATUS cmd_conf(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, + int argc, char **argv) +{ + if (argc != 2) { + printf("Usage: %s \n", argv[0]); + return NT_STATUS_OK; + } + if (!lp_load(argv[1], False, True, False)) { + printf("Error loading \"%s\"\n", argv[1]); + return NT_STATUS_OK; + } + + printf("\"%s\" successfully loaded\n", argv[1]); + return NT_STATUS_OK; +} + /* Display help on commands */ static NTSTATUS cmd_help(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) @@ -206,10 +223,11 @@ static struct cmd_set vfstest_commands[] = { { "GENERAL OPTIONS" }, - { "help", cmd_help, "Get help on commands", "[command]" }, - { "?", cmd_help, "Get help on commands", "[command]" }, - { "debuglevel", cmd_debuglevel, "Set debug level", "level" }, - { "freemem", cmd_freemem, "Free currently allocated buffers", "freemem" }, + { "conf", cmd_conf, "Load smb configuration file", "conf " }, + { "help", cmd_help, "Get help on commands", "" }, + { "?", cmd_help, "Get help on commands", "" }, + { "debuglevel", cmd_debuglevel, "Set debug level", "" }, + { "freemem", cmd_freemem, "Free currently allocated buffers", "" }, { "exit", cmd_quit, "Exit program", "" }, { "quit", cmd_quit, "Exit program", "" }, -- cgit From a90c9b2ccdbb8e41c54293b57808a6c61a4be8a7 Mon Sep 17 00:00:00 2001 From: Simo Sorce Date: Mon, 19 Aug 2002 16:54:06 +0000 Subject: make IRIX happy (This used to be commit bac73fa972c24503f12968810059745c81fa57a9) --- source3/torture/cmd_vfs.c | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) (limited to 'source3/torture') diff --git a/source3/torture/cmd_vfs.c b/source3/torture/cmd_vfs.c index 680d5bdfdc..29af3c9a5f 100644 --- a/source3/torture/cmd_vfs.c +++ b/source3/torture/cmd_vfs.c @@ -212,7 +212,9 @@ static NTSTATUS cmd_open(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, c printf(" T = O_TRUNC\n"); printf(" A = O_APPEND\n"); printf(" N = O_NONBLOCK/O_NDELAY\n"); +#ifdef O_SYNC printf(" S = O_SYNC\n"); +#endif #ifdef O_NOFOLLOW printf(" F = O_NOFOLLOW\n"); #endif @@ -249,9 +251,11 @@ static NTSTATUS cmd_open(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, c case 'N': flags |= O_NONBLOCK; break; +#ifdef O_SYNC case 'S': flags |= O_SYNC; break; +#endif #ifdef O_NOFOLLOW case 'F': flags |= O_NOFOLLOW; @@ -288,22 +292,22 @@ static NTSTATUS cmd_open(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, c static NTSTATUS cmd_pathfunc(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) { int ret = -1; - struct func_entry *fptr; - struct func_entry func_table[] = { - { "rmdir", vfs->conn->vfs_ops.rmdir }, - { "unlink", vfs->conn->vfs_ops.unlink }, - { "chdir", vfs->conn->vfs_ops.chdir }, - { NULL } - }; if (argc != 2) { printf("Usage: %s \n", argv[0]); return NT_STATUS_OK; } - for (fptr=func_table; *fptr->name; fptr++) - if (strcmp(fptr->name, argv[0]) == 0 ) - ret = fptr->fn(vfs->conn, argv[1]); + if (strcmp("rmdir", argv[0]) == 0 ) { + ret = vfs->conn->vfs_ops.rmdir(vfs->conn, argv[1]); + } else if (strcmp("unlink", argv[0]) == 0 ) { + ret = vfs->conn->vfs_ops.unlink(vfs->conn, argv[1]); + } else if (strcmp("chdir", argv[0]) == 0 ) { + ret = vfs->conn->vfs_ops.chdir(vfs->conn, argv[1]); + } else { + printf("%s: error=%d (invalid function name!)\n", argv[0], errno); + return NT_STATUS_UNSUCCESSFUL; + } if (ret == -1) { printf("%s: error=%d (%s)\n", argv[0], errno, strerror(errno)); -- cgit From 89c68c1bc3624e756533c9d16794402c29d71321 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 20 Aug 2002 17:58:09 +0000 Subject: Remove unused variables (This used to be commit 20f1765c32b2dd048e1572cd1b1e490459f7d5dc) --- source3/torture/vfstest.c | 19 +++---------------- 1 file changed, 3 insertions(+), 16 deletions(-) (limited to 'source3/torture') diff --git a/source3/torture/vfstest.c b/source3/torture/vfstest.c index b8773d5785..0cdff84ed4 100644 --- a/source3/torture/vfstest.c +++ b/source3/torture/vfstest.c @@ -207,7 +207,8 @@ static NTSTATUS cmd_freemem(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc talloc_destroy(global_ctx); global_ctx = NULL; vfs->data = NULL; - vfs->data_size = NULL; + vfs->data_size = 0; + return NT_STATUS_OK; } static NTSTATUS cmd_quit(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) @@ -420,27 +421,13 @@ static void usage(void) int main(int argc, char *argv[]) { - extern pstring global_myname; - static int got_pass = 0; BOOL interactive = True; int opt; - int olddebug; static char *cmdstr = ""; - const char *server; - struct cli_state *cli; - fstring password="", - username="", - domain=""; - static char *opt_authfile=NULL, - *opt_username=NULL, - *opt_domain=NULL, - *opt_configfile=NULL, - *opt_logfile=NULL; + static char *opt_logfile=NULL; static int opt_debuglevel; pstring logfile; struct cmd_set **cmd_set; - struct in_addr server_ip; - NTSTATUS nt_status; extern BOOL AllowDebugChange; static struct vfs_state vfs; int i; -- cgit From dcaceb410d62bc6667b44692eab9506275f3f139 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 20 Aug 2002 19:35:13 +0000 Subject: some fixes (This used to be commit e0c61b31050a3e3fdec2c47c80ef34de3ec73e04) --- source3/torture/vfstest.c | 25 +------------------------ 1 file changed, 1 insertion(+), 24 deletions(-) (limited to 'source3/torture') diff --git a/source3/torture/vfstest.c b/source3/torture/vfstest.c index 0cdff84ed4..9deb309352 100644 --- a/source3/torture/vfstest.c +++ b/source3/torture/vfstest.c @@ -4,6 +4,7 @@ Copyright (C) Simo Sorce 2002 Copyright (C) Eric Lorimer 2002 + Copyright (C) Jelmer Vernooij 2002 Most of this code was ripped off of rpcclient. Copyright (C) Tim Potter 2000-2001 @@ -44,13 +45,8 @@ static char **completion_fn(char *text, int start, int end) int i, count=0; struct cmd_list *commands = cmd_list; -#if 0 /* JERRY */ - /* FIXME!!! -- what to do when completing argument? */ - /* for words not at the start of the line fallback - to filename completion */ if (start) return NULL; -#endif /* make sure we have a list of valid commands */ if (!commands) @@ -437,10 +433,8 @@ int main(int argc, char *argv[]) a fixed location or certain compilers complain */ poptContext pc; struct poptOption long_options[] = { -/* {"conf", 's', POPT_ARG_STRING, &opt_configfile, 's'},*/ {"debug", 'd', POPT_ARG_INT, &opt_debuglevel, 'd'}, {"debuglevel", 'd', POPT_ARG_INT, &opt_debuglevel, 'd'}, -/* {"user", 'U', POPT_ARG_STRING, &opt_username, 'U'},*/ {"command", 'c', POPT_ARG_STRING, &cmdstr}, {"logfile", 'l', POPT_ARG_STRING, &opt_logfile, 'l'}, {"help", 'h', POPT_ARG_NONE, 0, 'h'}, @@ -469,23 +463,6 @@ int main(int argc, char *argv[]) DEBUGLEVEL = opt_debuglevel; break; - /* - case 'U': { - char *lp; - - pstrcpy(username,opt_username); - - if ((lp=strchr_m(username,'%'))) { - *lp = 0; - pstrcpy(password,lp+1); - got_pass = 1; - memset(strchr_m(opt_username,'%') + 1, 'X', - strlen(password)); - } - break; - } - */ - case 'h': default: usage(); -- cgit From 8e71f18acfc4e8e6945eb470b669e8d95447e5a8 Mon Sep 17 00:00:00 2001 From: Simo Sorce Date: Wed, 21 Aug 2002 02:34:49 +0000 Subject: implemented lock and mknod addedd to vfstest the possibility to read a file to imput a stream of commands (This used to be commit 233b14f447994db8fdb4448d19eff0c38c17254d) --- source3/torture/cmd_vfs.c | 125 +++++++++++++++++++++++++++++++++++++++++++--- source3/torture/vfstest.c | 98 ++++++++++++++++++++++++++++++++---- 2 files changed, 207 insertions(+), 16 deletions(-) (limited to 'source3/torture') diff --git a/source3/torture/cmd_vfs.c b/source3/torture/cmd_vfs.c index 29af3c9a5f..24601207e6 100644 --- a/source3/torture/cmd_vfs.c +++ b/source3/torture/cmd_vfs.c @@ -28,16 +28,24 @@ static char *null_string = ""; static NTSTATUS cmd_load_module(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) { struct smb_vfs_handle_struct *handle; + char *path = lp_vfs_path(0); + char name[PATH_MAX]; if (argc != 2) { printf("Usage: load \n"); return NT_STATUS_OK; } + + if (path != NULL && *path != '\0') { + snprintf(name, PATH_MAX, "%s/%s", path, argv[1]); + } else { + snprintf(name, PATH_MAX, "%s", argv[1]); + } vfs->conn->vfs_private = NULL; handle = (struct smb_vfs_handle_struct *) smb_xmalloc(sizeof(smb_vfs_handle_struct)); handle->handle = NULL; DLIST_ADD(vfs->conn->vfs_private, handle) - if (!vfs_init_custom(vfs->conn, argv[1])) { + if (!vfs_init_custom(vfs->conn, name)) { DEBUG(0, ("load: error=-1 (vfs_init_custom failed for %s)\n", argv[1])); return NT_STATUS_UNSUCCESSFUL; } @@ -197,7 +205,8 @@ static NTSTATUS cmd_closedir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int arg static NTSTATUS cmd_open(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) { - int flags, mode, fd; + int flags, fd; + mode_t mode; char *flagstr; mode = 00400; @@ -520,7 +529,7 @@ static NTSTATUS cmd_stat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, c printf(" Size: %10d", st.st_size); printf(" Blocks: %9d", st.st_blocks); printf(" IO Block: %d\n", st.st_blksize); - printf(" Device: 0x%.10x", st.st_dev); + printf(" Device: 0x%10x", st.st_dev); printf(" Inode: %10d", st.st_ino); printf(" Links: %10d\n", st.st_nlink); printf(" Access: %05o", (st.st_mode) & 007777); @@ -808,7 +817,84 @@ static NTSTATUS cmd_ftruncate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int ar static NTSTATUS cmd_lock(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) { - printf("lock: Not yet implemented!\n"); + BOOL ret; + int fd; + int op; + long offset; + long count; + int type; + char *typestr; + + if (argc != 6) { + printf("Usage: lock \n"); + printf(" ops: G = F_GETLK\n"); + printf(" S = F_SETLK\n"); + printf(" W = F_SETLKW\n"); + printf(" type: R = F_RDLCK\n"); + printf(" W = F_WRLCK\n"); + printf(" U = F_UNLCK\n"); + return NT_STATUS_OK; + } + + if (sscanf(argv[1], "%d", &fd) == 0) { + printf("lock: error=-1 (error parsing fd)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + op = 0; + switch (*argv[2]) { + case 'G': + op = F_GETLK; + break; + case 'S': + op = F_SETLK; + break; + case 'W': + op = F_SETLKW; + break; + default: + printf("lock: error=-1 (invalid op flag!)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + if (sscanf(argv[3], "%ld", &offset) == 0) { + printf("lock: error=-1 (error parsing fd)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + if (sscanf(argv[4], "%ld", &count) == 0) { + printf("lock: error=-1 (error parsing fd)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + type = 0; + typestr = argv[5]; + while(*typestr) { + switch (*typestr) { + case 'R': + type |= F_RDLCK; + break; + case 'W': + type |= F_WRLCK; + break; + case 'U': + type |= F_UNLCK; + break; + default: + printf("lock: error=-1 (invalid type flag!)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + typestr++; + } + + printf("lock: debug lock(fd=%d, op=%d, offset=%ld, count=%ld, type=%d))\n", fd, op, offset, count, type); + + if ((ret = vfs->conn->vfs_ops.lock(vfs->files[fd], fd, op, offset, count, type)) == False) { + printf("lock: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("lock: ok\n"); return NT_STATUS_OK; } @@ -868,7 +954,32 @@ static NTSTATUS cmd_link(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, c static NTSTATUS cmd_mknod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) { - printf("lock: Not yet implemented!\n"); + mode_t mode; + SMB_DEV_T dev; + + if (argc != 4) { + printf("Usage: mknod \n"); + printf(" mode is octal\n"); + printf(" dev is hex\n"); + return NT_STATUS_OK; + } + + if (sscanf(argv[2], "%o", &mode) == 0) { + printf("open: error=-1 (invalid mode!)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + if (sscanf(argv[3], "%x", &dev) == 0) { + printf("open: error=-1 (invalid dev!)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + if (vfs->conn->vfs_ops.mknod(vfs->conn, argv[1], mode, dev) == -1) { + printf("mknod: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("mknod: ok\n"); return NT_STATUS_OK; } @@ -924,11 +1035,11 @@ struct cmd_set vfs_commands[] = { { "getwd", cmd_getwd, "VFS getwd()", "getwd" }, { "utime", cmd_utime, "VFS utime()", "utime " }, { "ftruncate", cmd_ftruncate, "VFS ftruncate()", "ftruncate " }, - { "lock", cmd_lock, "VFS lock()", "lock: Not yet implemented!" }, + { "lock", cmd_lock, "VFS lock()", "lock " }, { "symlink", cmd_symlink, "VFS symlink()", "symlink " }, { "readlink", cmd_readlink, "VFS readlink()", "readlink " }, { "link", cmd_link, "VFS link()", "link " }, - { "mknod", cmd_mknod, "VFS mknod()", "mknod: Not yet implemented!" }, + { "mknod", cmd_mknod, "VFS mknod()", "mknod " }, { "realpath", cmd_realpath, "VFS realpath()", "realpath " }, { NULL } }; diff --git a/source3/torture/vfstest.c b/source3/torture/vfstest.c index 9deb309352..b76c289c17 100644 --- a/source3/torture/vfstest.c +++ b/source3/torture/vfstest.c @@ -35,6 +35,8 @@ static struct cmd_list { TALLOC_CTX *global_ctx; +extern pstring user_socket_options; + /**************************************************************************** handle completion of commands for readline ****************************************************************************/ @@ -87,7 +89,7 @@ static char **completion_fn(char *text, int start, int end) return matches; } -static char* next_command (char** cmdstr) +static char* next_command(char** cmdstr) { static pstring command; char *p; @@ -382,6 +384,26 @@ static NTSTATUS process_cmd(struct vfs_state *vfs, char *cmd) return result; } +static void process_file(struct vfs_state *pvfs, char *filename) { + FILE *file; + char command[3 * PATH_MAX]; + + if (*filename == '-') { + file = stdin; + } else { + file = fopen(filename, "r"); + if (file == NULL) { + printf("vfstest: error reading file (%s)!", filename); + printf("errno n.%d: %s", errno, strerror(errno)); + exit(-1); + } + } + + while (fgets(command, 3 * PATH_MAX, file) != NULL) { + process_cmd(pvfs, command); + } +} + void exit_server(char *reason) { DEBUG(3,("Server exit (%s)\n", (reason ? reason : ""))); @@ -396,9 +418,57 @@ int smbd_server_fd(void) return server_fd; } +/**************************************************************************** + Reload the services file. +**************************************************************************/ + BOOL reload_services(BOOL test) { - return True; + BOOL ret; + + if (lp_loaded()) { + pstring fname; + pstrcpy(fname,lp_configfile()); + if (file_exist(fname, NULL) && + !strcsequal(fname, dyn_CONFIGFILE)) { + pstrcpy(dyn_CONFIGFILE, fname); + test = False; + } + } + + reopen_logs(); + + if (test && !lp_file_list_changed()) + return(True); + + lp_killunused(conn_snum_used); + + ret = lp_load(dyn_CONFIGFILE, False, False, True); + + load_printers(); + + /* perhaps the config filename is now set */ + if (!test) + reload_services(True); + + reopen_logs(); + + load_interfaces(); + + { + if (smbd_server_fd() != -1) { + set_socket_options(smbd_server_fd(),"SO_KEEPALIVE"); + set_socket_options(smbd_server_fd(), user_socket_options); + } + } + + mangle_reset_cache(); + reset_stat_cache(); + + /* this forces service parameters to be flushed */ + set_current_service(NULL,True); + + return (ret); } /* Print usage information */ @@ -407,6 +477,7 @@ static void usage(void) printf("Usage: vfstest [options]\n"); printf("\t-c or --command \"command string\" execute semicolon separated cmds\n"); + printf("\t-f or --file filename execute a set of operations as described in the file\n"); printf("\t-d or --debug debuglevel set the debuglevel\n"); printf("\t-l or --logfile logfile logfile to use instead of stdout\n"); printf("\t-h or --help Print this help message.\n"); @@ -420,19 +491,20 @@ int main(int argc, char *argv[]) BOOL interactive = True; int opt; static char *cmdstr = ""; - static char *opt_logfile=NULL; + static char *opt_logfile=NULL; static int opt_debuglevel; pstring logfile; struct cmd_set **cmd_set; extern BOOL AllowDebugChange; static struct vfs_state vfs; int i; - + static char *filename = ""; /* make sure the vars that get altered (4th field) are in a fixed location or certain compilers complain */ poptContext pc; struct poptOption long_options[] = { + {"file", 'f', POPT_ARG_STRING, &filename}, {"debug", 'd', POPT_ARG_INT, &opt_debuglevel, 'd'}, {"debuglevel", 'd', POPT_ARG_INT, &opt_debuglevel, 'd'}, {"command", 'c', POPT_ARG_STRING, &cmdstr}, @@ -473,6 +545,9 @@ int main(int argc, char *argv[]) poptFreeContext(pc); + /* TODO: check output */ + reload_services(False); + /* the following functions are part of the Samba debugging facilities. See lib/debug.c */ setup_logging("vfstest", interactive); @@ -495,7 +570,16 @@ int main(int argc, char *argv[]) for (i=0; i < 1024; i++) vfs.files[i] = NULL; - /* Do anything specified with -c */ + /* some advanced initiliazation stuff */ + smbd_vfs_init(vfs.conn); + + /* Do we have a file input? */ + if (filename[0]) { + process_file(&vfs, filename); + return 0; + } + + /* Do anything specified with -c */ if (cmdstr[0]) { char *cmd; char *p = cmdstr; @@ -507,10 +591,6 @@ int main(int argc, char *argv[]) return 0; } - /* Initialize VFS */ - vfs.conn->vfs_private = NULL; - smbd_vfs_init(vfs.conn); - /* Loop around accepting commands */ while(1) { -- cgit From bf6cd377165046c3003d7243cb45c65a897cc9f7 Mon Sep 17 00:00:00 2001 From: Simo Sorce Date: Sat, 24 Aug 2002 02:06:17 +0000 Subject: if muhammad does not go to the mountain ... (This used to be commit 5246d3693c463e581a7cd40f86878e40456237c3) --- source3/torture/vfstest.c | 2 ++ 1 file changed, 2 insertions(+) (limited to 'source3/torture') diff --git a/source3/torture/vfstest.c b/source3/torture/vfstest.c index b76c289c17..3c67fa4633 100644 --- a/source3/torture/vfstest.c +++ b/source3/torture/vfstest.c @@ -36,6 +36,8 @@ static struct cmd_list { TALLOC_CTX *global_ctx; extern pstring user_socket_options; +extern SIG_ATOMIC_T got_sig_term; +extern SIG_ATOMIC_T reload_after_sighup; /**************************************************************************** handle completion of commands for readline -- cgit From a97a6ed43add0bb98c205ead3b4343a382d898d5 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 29 Aug 2002 10:42:29 +0000 Subject: Adding samtest utility used to test sam backends. Compiles but doesn't do anything (yet). Requires move from samr_make_sam_obj_sd to lib/ (This used to be commit 7904770d341b194574f9dc8da578a5fe4b31aa9f) --- source3/torture/samtest.c | 468 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 468 insertions(+) create mode 100644 source3/torture/samtest.c (limited to 'source3/torture') diff --git a/source3/torture/samtest.c b/source3/torture/samtest.c new file mode 100644 index 0000000000..94c7fa9c07 --- /dev/null +++ b/source3/torture/samtest.c @@ -0,0 +1,468 @@ +/* + Unix SMB/CIFS implementation. + SAM module tester + + Copyright (C) 2002 Jelmer Vernooij + + Parts of the code stolen from rpcclient by Tim Potter + + 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. +*/ + +#include "includes.h" + +struct func_entry { + char *name; + int (*fn)(struct connection_struct *conn, const char *path); +}; + +struct cmd_set { + char *name; + NTSTATUS (*fn)(struct sam_context *sam, TALLOC_CTX *mem_ctx, int argc, + char **argv); + char *description; + char *usage; +}; + +/* List to hold groups of commands */ +static struct cmd_list { + struct cmd_list *prev, *next; + struct cmd_set *cmd_set; +} *cmd_list; + +TALLOC_CTX *global_ctx; + +static char* next_command (char** cmdstr) +{ + static pstring command; + char *p; + + if (!cmdstr || !(*cmdstr)) + return NULL; + + p = strchr_m(*cmdstr, ';'); + if (p) + *p = '\0'; + pstrcpy(command, *cmdstr); + *cmdstr = p; + + return command; +} + +/* Display help on commands */ +static NTSTATUS cmd_help(struct sam_context *sam, TALLOC_CTX *mem_ctx, + int argc, char **argv) +{ + struct cmd_list *tmp; + struct cmd_set *tmp_set; + + /* Usage */ + if (argc > 2) { + printf("Usage: %s [command]\n", argv[0]); + return NT_STATUS_OK; + } + + /* Help on one command */ + + if (argc == 2) { + for (tmp = cmd_list; tmp; tmp = tmp->next) { + + tmp_set = tmp->cmd_set; + + while(tmp_set->name) { + if (strequal(argv[1], tmp_set->name)) { + if (tmp_set->usage && + tmp_set->usage[0]) + printf("%s\n", tmp_set->usage); + else + printf("No help for %s\n", tmp_set->name); + + return NT_STATUS_OK; + } + + tmp_set++; + } + } + + printf("No such command: %s\n", argv[1]); + return NT_STATUS_OK; + } + + /* List all commands */ + + for (tmp = cmd_list; tmp; tmp = tmp->next) { + + tmp_set = tmp->cmd_set; + + while(tmp_set->name) { + + printf("%15s\t\t%s\n", tmp_set->name, + tmp_set->description ? tmp_set->description: + ""); + + tmp_set++; + } + } + + return NT_STATUS_OK; +} + +/* Change the debug level */ +static NTSTATUS cmd_debuglevel(struct sam_context *sam, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + if (argc > 2) { + printf("Usage: %s [debuglevel]\n", argv[0]); + return NT_STATUS_OK; + } + + if (argc == 2) { + DEBUGLEVEL = atoi(argv[1]); + } + + printf("debuglevel is %d\n", DEBUGLEVEL); + + return NT_STATUS_OK; +} + +static NTSTATUS cmd_quit(struct sam_context *sam, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + /* Cleanup */ + talloc_destroy(global_ctx); + + exit(0); + return NT_STATUS_OK; /* NOTREACHED */ +} + +static struct cmd_set samtest_commands[] = { + + { "GENERAL OPTIONS" }, + + { "help", cmd_help, "Get help on commands", "" }, + { "?", cmd_help, "Get help on commands", "" }, + { "debuglevel", cmd_debuglevel, "Set debug level", "" }, + { "exit", cmd_quit, "Exit program", "" }, + { "quit", cmd_quit, "Exit program", "" }, + + { NULL } +}; + +static struct cmd_set separator_command[] = { + { "---------------", NULL, "----------------------" }, + { NULL } +}; + + +/*extern struct cmd_set sam_commands[];*/ +static struct cmd_set *samtest_command_list[] = { + samtest_commands, +/* sam_commands, NOT YET */ + NULL +}; + +static void add_command_set(struct cmd_set *cmd_set) +{ + struct cmd_list *entry; + + if (!(entry = (struct cmd_list *)malloc(sizeof(struct cmd_list)))) { + DEBUG(0, ("out of memory\n")); + return; + } + + ZERO_STRUCTP(entry); + + entry->cmd_set = cmd_set; + DLIST_ADD(cmd_list, entry); +} + +static NTSTATUS do_cmd(struct sam_context *sam, struct cmd_set *cmd_entry, char *cmd) +{ + char *p = cmd, **argv = NULL; + NTSTATUS result = NT_STATUS_UNSUCCESSFUL; + pstring buf; + int argc = 0, i; + + /* Count number of arguments first time through the loop then + allocate memory and strdup them. */ + + again: + while(next_token(&p, buf, " ", sizeof(buf))) { + if (argv) { + argv[argc] = strdup(buf); + } + + argc++; + } + + if (!argv) { + + /* Create argument list */ + + argv = (char **)malloc(sizeof(char *) * argc); + memset(argv, 0, sizeof(char *) * argc); + + if (!argv) { + fprintf(stderr, "out of memory\n"); + result = NT_STATUS_NO_MEMORY; + goto done; + } + + p = cmd; + argc = 0; + + goto again; + } + + /* Call the function */ + + if (cmd_entry->fn) { + + if (global_ctx == NULL) { + /* Create mem_ctx */ + if (!(global_ctx = talloc_init())) { + DEBUG(0, ("talloc_init() failed\n")); + goto done; + } + } + + /* Run command */ + result = cmd_entry->fn(sam, global_ctx, argc, argv); + + } else { + fprintf (stderr, "Invalid command\n"); + goto done; + } + + done: + + /* Cleanup */ + + if (argv) { + for (i = 0; i < argc; i++) + SAFE_FREE(argv[i]); + + SAFE_FREE(argv); + } + + return result; +} + +/* Process a command entered at the prompt or as part of -c */ +static NTSTATUS process_cmd(struct sam_context *sam, char *cmd) +{ + struct cmd_list *temp_list; + BOOL found = False; + pstring buf; + char *p = cmd; + NTSTATUS result = NT_STATUS_OK; + int len = 0; + + if (cmd[strlen(cmd) - 1] == '\n') + cmd[strlen(cmd) - 1] = '\0'; + + if (!next_token(&p, buf, " ", sizeof(buf))) { + return NT_STATUS_OK; + } + + /* strip the trainly \n if it exsists */ + len = strlen(buf); + if (buf[len-1] == '\n') + buf[len-1] = '\0'; + + /* Search for matching commands */ + + for (temp_list = cmd_list; temp_list; temp_list = temp_list->next) { + struct cmd_set *temp_set = temp_list->cmd_set; + + while(temp_set->name) { + if (strequal(buf, temp_set->name)) { + found = True; + result = do_cmd(sam, temp_set, cmd); + + goto done; + } + temp_set++; + } + } + + done: + if (!found && buf[0]) { + printf("command not found: %s\n", buf); + return NT_STATUS_OK; + } + + if (!NT_STATUS_IS_OK(result)) { + printf("result was %s\n", nt_errstr(result)); + } + + return result; +} + +void exit_server(char *reason) +{ + DEBUG(3,("Server exit (%s)\n", (reason ? reason : ""))); + exit(0); +} + +static int server_fd = -1; +int last_message = -1; + +int smbd_server_fd(void) +{ + return server_fd; +} + +BOOL reload_services(BOOL test) +{ + return True; +} + +/* Print usage information */ +static void usage(void) +{ + printf("Usage: samtest [options]\n"); + + printf("\t-c or --command \"command string\" execute semicolon separated cmds\n"); + printf("\t-d or --debug debuglevel set the debuglevel\n"); + printf("\t-l or --logfile logfile logfile to use instead of stdout\n"); + printf("\t-h or --help Print this help message.\n"); + printf("\n"); +} + +/* Main function */ + +int main(int argc, char *argv[]) +{ + BOOL interactive = True; + int opt; + static char *cmdstr = ""; + static char *opt_logfile=NULL; + static int opt_debuglevel; + pstring logfile; + struct cmd_set **cmd_set; + extern BOOL AllowDebugChange; + static struct sam_context sam; + int i; + + + /* make sure the vars that get altered (4th field) are in + a fixed location or certain compilers complain */ + poptContext pc; + struct poptOption long_options[] = { +/* {"conf", 's', POPT_ARG_STRING, &opt_configfile, 's'},*/ + {"debug", 'd', POPT_ARG_INT, &opt_debuglevel, 'd'}, + {"debuglevel", 'd', POPT_ARG_INT, &opt_debuglevel, 'd'}, +/* {"user", 'U', POPT_ARG_STRING, &opt_username, 'U'},*/ + {"command", 'c', POPT_ARG_STRING, &cmdstr}, + {"logfile", 'l', POPT_ARG_STRING, &opt_logfile, 'l'}, + {"help", 'h', POPT_ARG_NONE, 0, 'h'}, + { 0, 0, 0, 0} + }; + + + setlinebuf(stdout); + + DEBUGLEVEL = 1; + AllowDebugChange = False; + + pc = poptGetContext("samtest", argc, (const char **) argv, + long_options, 0); + + while((opt = poptGetNextOpt(pc)) != -1) { + switch (opt) { + case 'l': + slprintf(logfile, sizeof(logfile) - 1, "%s.client", + opt_logfile); + lp_set_logfile(logfile); + interactive = False; + break; + + case 'd': + DEBUGLEVEL = opt_debuglevel; + break; + + /* + case 'U': { + char *lp; + + pstrcpy(username,opt_username); + + if ((lp=strchr_m(username,'%'))) { + *lp = 0; + pstrcpy(password,lp+1); + got_pass = 1; + memset(strchr_m(opt_username,'%') + 1, 'X', + strlen(password)); + } + break; + } + */ + + case 'h': + default: + usage(); + exit(1); + } + } + + + poptFreeContext(pc); + + /* the following functions are part of the Samba debugging + facilities. See lib/debug.c */ + setup_logging("samtest", interactive); + if (!interactive) + reopen_logs(); + + /* Load command lists */ + + cmd_set = samtest_command_list; + + while(*cmd_set) { + add_command_set(*cmd_set); + add_command_set(separator_command); + cmd_set++; + } + + /* Do anything specified with -c */ + if (cmdstr[0]) { + char *cmd; + char *p = cmdstr; + + while((cmd=next_command(&p)) != NULL) { + process_cmd(&sam, cmd); + } + + return 0; + } + + /* Loop around accepting commands */ + + while(1) { + pstring prompt; + char *line; + + slprintf(prompt, sizeof(prompt) - 1, "samtest $> "); + + line = smb_readline(prompt, NULL, NULL); + + if (line == NULL) + break; + + if (line[0] != '\n') + process_cmd(&sam, line); + } + + return 0; +} -- cgit From 88f8ccd2b25151004dfd9c06a98ddc87066428df Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 29 Aug 2002 11:17:14 +0000 Subject: Don't use global memory context (This used to be commit b1e1d548031f270dd51ffa1910c3ae2503e64e8f) --- source3/torture/samtest.c | 1 + source3/torture/vfstest.c | 17 +++++++---------- 2 files changed, 8 insertions(+), 10 deletions(-) (limited to 'source3/torture') diff --git a/source3/torture/samtest.c b/source3/torture/samtest.c index 94c7fa9c07..15caf8820f 100644 --- a/source3/torture/samtest.c +++ b/source3/torture/samtest.c @@ -4,6 +4,7 @@ Copyright (C) 2002 Jelmer Vernooij + Parts of the code stolen from vfstest by Simo Sorce and Eric Lorimer Parts of the code stolen from rpcclient by Tim Potter This program is free software; you can redistribute it and/or modify diff --git a/source3/torture/vfstest.c b/source3/torture/vfstest.c index 3c67fa4633..2186e28cdf 100644 --- a/source3/torture/vfstest.c +++ b/source3/torture/vfstest.c @@ -33,11 +33,7 @@ static struct cmd_list { struct cmd_set *cmd_set; } *cmd_list; -TALLOC_CTX *global_ctx; - extern pstring user_socket_options; -extern SIG_ATOMIC_T got_sig_term; -extern SIG_ATOMIC_T reload_after_sighup; /**************************************************************************** handle completion of commands for readline @@ -204,8 +200,8 @@ static NTSTATUS cmd_debuglevel(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int a static NTSTATUS cmd_freemem(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) { /* Cleanup */ - talloc_destroy(global_ctx); - global_ctx = NULL; + talloc_destroy(mem_ctx); + mem_ctx = NULL; vfs->data = NULL; vfs->data_size = 0; return NT_STATUS_OK; @@ -214,7 +210,7 @@ static NTSTATUS cmd_freemem(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc static NTSTATUS cmd_quit(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) { /* Cleanup */ - talloc_destroy(global_ctx); + talloc_destroy(mem_ctx); exit(0); return NT_STATUS_OK; /* NOTREACHED */ @@ -268,6 +264,7 @@ static NTSTATUS do_cmd(struct vfs_state *vfs, struct cmd_set *cmd_entry, char *c char *p = cmd, **argv = NULL; NTSTATUS result = NT_STATUS_UNSUCCESSFUL; pstring buf; + TALLOC_CTX *mem_ctx; int argc = 0, i; /* Count number of arguments first time through the loop then @@ -305,16 +302,16 @@ static NTSTATUS do_cmd(struct vfs_state *vfs, struct cmd_set *cmd_entry, char *c if (cmd_entry->fn) { - if (global_ctx == NULL) { + if (mem_ctx == NULL) { /* Create mem_ctx */ - if (!(global_ctx = talloc_init())) { + if (!(mem_ctx = talloc_init())) { DEBUG(0, ("talloc_init() failed\n")); goto done; } } /* Run command */ - result = cmd_entry->fn(vfs, global_ctx, argc, argv); + result = cmd_entry->fn(vfs, mem_ctx, argc, argv); } else { fprintf (stderr, "Invalid command\n"); -- cgit From 4d64593834eb8c5074a0d7725614b44082ea8eb0 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 29 Aug 2002 12:05:30 +0000 Subject: Use popt for printing --help message (This used to be commit 355d28d9eae2fd4b94bb591c5c51cad2fab9d2fd) --- source3/torture/samtest.c | 22 ++++++++-------------- source3/torture/vfstest.c | 29 +++++------------------------ 2 files changed, 13 insertions(+), 38 deletions(-) (limited to 'source3/torture') diff --git a/source3/torture/samtest.c b/source3/torture/samtest.c index 15caf8820f..a6d1a288b2 100644 --- a/source3/torture/samtest.c +++ b/source3/torture/samtest.c @@ -43,8 +43,6 @@ static struct cmd_list { struct cmd_set *cmd_set; } *cmd_list; -TALLOC_CTX *global_ctx; - static char* next_command (char** cmdstr) { static pstring command; @@ -140,7 +138,7 @@ static NTSTATUS cmd_debuglevel(struct sam_context *sam, TALLOC_CTX *mem_ctx, int static NTSTATUS cmd_quit(struct sam_context *sam, TALLOC_CTX *mem_ctx, int argc, char **argv) { /* Cleanup */ - talloc_destroy(global_ctx); + talloc_destroy(mem_ctx); exit(0); return NT_STATUS_OK; /* NOTREACHED */ @@ -229,16 +227,16 @@ static NTSTATUS do_cmd(struct sam_context *sam, struct cmd_set *cmd_entry, char if (cmd_entry->fn) { - if (global_ctx == NULL) { + if (mem_ctx == NULL) { /* Create mem_ctx */ - if (!(global_ctx = talloc_init())) { + if (!(mem_ctx = talloc_init())) { DEBUG(0, ("talloc_init() failed\n")); goto done; } } /* Run command */ - result = cmd_entry->fn(sam, global_ctx, argc, argv); + result = cmd_entry->fn(sam, mem_ctx, argc, argv); } else { fprintf (stderr, "Invalid command\n"); @@ -361,17 +359,13 @@ int main(int argc, char *argv[]) a fixed location or certain compilers complain */ poptContext pc; struct poptOption long_options[] = { -/* {"conf", 's', POPT_ARG_STRING, &opt_configfile, 's'},*/ - {"debug", 'd', POPT_ARG_INT, &opt_debuglevel, 'd'}, - {"debuglevel", 'd', POPT_ARG_INT, &opt_debuglevel, 'd'}, -/* {"user", 'U', POPT_ARG_STRING, &opt_username, 'U'},*/ - {"command", 'c', POPT_ARG_STRING, &cmdstr}, - {"logfile", 'l', POPT_ARG_STRING, &opt_logfile, 'l'}, - {"help", 'h', POPT_ARG_NONE, 0, 'h'}, + POPT_AUTOHELP + { NULL, 0, POPT_ARG_INCLUDE_TABLE, popt_common_debug }, + {"command", 'c', POPT_ARG_STRING, &cmdstr, 'c', "Execute semicolon seperated cmds"}, + {"logfile", 'l', POPT_ARG_STRING, &opt_logfile, 'l', "Logfile to use instead of stdout"}, { 0, 0, 0, 0} }; - setlinebuf(stdout); DEBUGLEVEL = 1; diff --git a/source3/torture/vfstest.c b/source3/torture/vfstest.c index 2186e28cdf..824e8108bf 100644 --- a/source3/torture/vfstest.c +++ b/source3/torture/vfstest.c @@ -470,19 +470,6 @@ BOOL reload_services(BOOL test) return (ret); } -/* Print usage information */ -static void usage(void) -{ - printf("Usage: vfstest [options]\n"); - - printf("\t-c or --command \"command string\" execute semicolon separated cmds\n"); - printf("\t-f or --file filename execute a set of operations as described in the file\n"); - printf("\t-d or --debug debuglevel set the debuglevel\n"); - printf("\t-l or --logfile logfile logfile to use instead of stdout\n"); - printf("\t-h or --help Print this help message.\n"); - printf("\n"); -} - /* Main function */ int main(int argc, char *argv[]) @@ -503,12 +490,11 @@ int main(int argc, char *argv[]) a fixed location or certain compilers complain */ poptContext pc; struct poptOption long_options[] = { - {"file", 'f', POPT_ARG_STRING, &filename}, - {"debug", 'd', POPT_ARG_INT, &opt_debuglevel, 'd'}, - {"debuglevel", 'd', POPT_ARG_INT, &opt_debuglevel, 'd'}, - {"command", 'c', POPT_ARG_STRING, &cmdstr}, - {"logfile", 'l', POPT_ARG_STRING, &opt_logfile, 'l'}, - {"help", 'h', POPT_ARG_NONE, 0, 'h'}, + POPT_AUTOHELP + {"file", 'f', POPT_ARG_STRING, &filename, 0, }, + {"command", 'c', POPT_ARG_STRING, &cmdstr, 0, "Execute specified list of commands" }, + {"logfile", 'l', POPT_ARG_STRING, &opt_logfile, 'l', 0, "Write output to specified logfile" }, + { NULL, 0, POPT_ARG_INCLUDE_TABLE, popt_common_debug }, { 0, 0, 0, 0} }; @@ -533,11 +519,6 @@ int main(int argc, char *argv[]) case 'd': DEBUGLEVEL = opt_debuglevel; break; - - case 'h': - default: - usage(); - exit(1); } } -- cgit From 52ea319236d9aab761aa1429e285ae1eead2589b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 29 Aug 2002 16:37:39 +0000 Subject: Correct popt argument info in vfstest Don't use global_ctx in samtest.c (This used to be commit 0428eb422b50135327daf3040067f5982f1b0b92) --- source3/torture/samtest.c | 39 +-------------------------------------- source3/torture/vfstest.c | 2 +- 2 files changed, 2 insertions(+), 39 deletions(-) (limited to 'source3/torture') diff --git a/source3/torture/samtest.c b/source3/torture/samtest.c index a6d1a288b2..56b87dc257 100644 --- a/source3/torture/samtest.c +++ b/source3/torture/samtest.c @@ -189,6 +189,7 @@ static NTSTATUS do_cmd(struct sam_context *sam, struct cmd_set *cmd_entry, char { char *p = cmd, **argv = NULL; NTSTATUS result = NT_STATUS_UNSUCCESSFUL; + TALLOC_CTX *mem_ctx; pstring buf; int argc = 0, i; @@ -327,18 +328,6 @@ BOOL reload_services(BOOL test) return True; } -/* Print usage information */ -static void usage(void) -{ - printf("Usage: samtest [options]\n"); - - printf("\t-c or --command \"command string\" execute semicolon separated cmds\n"); - printf("\t-d or --debug debuglevel set the debuglevel\n"); - printf("\t-l or --logfile logfile logfile to use instead of stdout\n"); - printf("\t-h or --help Print this help message.\n"); - printf("\n"); -} - /* Main function */ int main(int argc, char *argv[]) @@ -382,32 +371,6 @@ int main(int argc, char *argv[]) lp_set_logfile(logfile); interactive = False; break; - - case 'd': - DEBUGLEVEL = opt_debuglevel; - break; - - /* - case 'U': { - char *lp; - - pstrcpy(username,opt_username); - - if ((lp=strchr_m(username,'%'))) { - *lp = 0; - pstrcpy(password,lp+1); - got_pass = 1; - memset(strchr_m(opt_username,'%') + 1, 'X', - strlen(password)); - } - break; - } - */ - - case 'h': - default: - usage(); - exit(1); } } diff --git a/source3/torture/vfstest.c b/source3/torture/vfstest.c index 824e8108bf..9f8062a02e 100644 --- a/source3/torture/vfstest.c +++ b/source3/torture/vfstest.c @@ -493,7 +493,7 @@ int main(int argc, char *argv[]) POPT_AUTOHELP {"file", 'f', POPT_ARG_STRING, &filename, 0, }, {"command", 'c', POPT_ARG_STRING, &cmdstr, 0, "Execute specified list of commands" }, - {"logfile", 'l', POPT_ARG_STRING, &opt_logfile, 'l', 0, "Write output to specified logfile" }, + {"logfile", 'l', POPT_ARG_STRING, &opt_logfile, 'l', "Write output to specified logfile" }, { NULL, 0, POPT_ARG_INCLUDE_TABLE, popt_common_debug }, { 0, 0, 0, 0} }; -- cgit From bf544f12f53ad19919d660bd15028a5ed1eda8a1 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Fri, 30 Aug 2002 17:22:33 +0000 Subject: Added attribute specific OPEN tests (for SYSTEM and HIDDEN). Jeremy. (This used to be commit 4eeef6ef530acf1cc4e08e24af902c15af57ece7) --- source3/torture/torture.c | 44 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) (limited to 'source3/torture') diff --git a/source3/torture/torture.c b/source3/torture/torture.c index e7a8eb04b6..89d62b44a6 100644 --- a/source3/torture/torture.c +++ b/source3/torture/torture.c @@ -3417,6 +3417,50 @@ static BOOL run_opentest(int dummy) cli_unlink(&cli1, fname); + /* Test 8 - attributes test test... */ + fnum1 = cli_nt_create_full(&cli1, fname,FILE_WRITE_DATA, FILE_ATTRIBUTE_HIDDEN, + FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0); + + if (fnum1 == -1) { + printf("test 8 open 1 of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return False; + } + + if (!cli_close(&cli1, fnum1)) { + printf("test 8 close 1 of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return False; + } + + /* FILE_SUPERSEDE && FILE_OVERWRITE_IF have the same effect here. */ + fnum1 = cli_nt_create_full(&cli1, fname,FILE_READ_DATA, FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0); + + if (fnum1 == -1) { + printf("test 8 open 2 of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return False; + } + + if (!cli_close(&cli1, fnum1)) { + printf("test 8 close 2 of %s failed (%s)\n", fname, cli_errstr(&cli1)); + return False; + } + + /* This open should fail with ACCESS_DENIED for FILE_SUPERSEDE, FILE_OVERWRITE and FILE_OVERWRITE_IF. */ + fnum1 = cli_nt_create_full(&cli1, fname,FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_NONE, FILE_OVERWRITE, 0); + + if (fnum1 != -1) { + printf("test 8 open 3 of %s succeeded - should have failed with (NT_STATUS_ACCESS_DENIED)\n", fname); + correct = False; + cli_close(&cli1, fnum1); + } else { + printf("test 8 open 3 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(&cli1), "ACCESS_DENIED"); + } + + printf("Attribute open test #8 passed.\n"); + + cli_unlink(&cli1, fname); + if (!torture_close_connection(&cli1)) { correct = False; } -- cgit From 0b9bf47fda49b743b8b7335d121517709a33ae0f Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Fri, 30 Aug 2002 18:56:00 +0000 Subject: Better error reporting on OPEN test. Jeremy. (This used to be commit 4e836c4ce2b51e42ab4f29c6c916fe6a73a58654) --- source3/torture/torture.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'source3/torture') diff --git a/source3/torture/torture.c b/source3/torture/torture.c index 89d62b44a6..977591bc53 100644 --- a/source3/torture/torture.c +++ b/source3/torture/torture.c @@ -844,7 +844,7 @@ static BOOL run_locktest1(int dummy) printf("error: This server appears not to support timed lock requests\n"); } printf("server slept for %u seconds for a %u second timeout\n", - t2-t1, lock_timeout); + (unsigned int)(t2-t1), lock_timeout); if (!cli_close(&cli1, fnum2)) { printf("close1 failed (%s)\n", cli_errstr(&cli1)); @@ -3454,7 +3454,9 @@ static BOOL run_opentest(int dummy) correct = False; cli_close(&cli1, fnum1); } else { - printf("test 8 open 3 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(&cli1), "ACCESS_DENIED"); + if (check_error(__LINE__, &cli1, ERRDOS, ERRnoaccess, NT_STATUS_ACCESS_DENIED)) { + printf("correct error code NT_STATUS_ACCESS_DENIED/ERRDOS:ERRnoaccess returned\n"); + } } printf("Attribute open test #8 passed.\n"); -- cgit From 8e33a5d6cc45d15f5c9088ce896132aa288d7700 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Fri, 30 Aug 2002 19:06:07 +0000 Subject: Correct error message. Jeremy. (This used to be commit e9392c4a2e1e1ce44fcd1a1105477c17a3410f14) --- source3/torture/torture.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source3/torture') diff --git a/source3/torture/torture.c b/source3/torture/torture.c index 977591bc53..047b4c7a24 100644 --- a/source3/torture/torture.c +++ b/source3/torture/torture.c @@ -3459,7 +3459,7 @@ static BOOL run_opentest(int dummy) } } - printf("Attribute open test #8 passed.\n"); + printf("Attribute open test #8 %s.\n", correct ? "passed" : "failed"); cli_unlink(&cli1, fname); -- cgit From 58b5b6f4036c8d958a62b813b46e873c052a0327 Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Thu, 5 Sep 2002 03:06:26 +0000 Subject: initial mem_ctx to NULL patch from metze (This used to be commit a4351a3923fd87e1c54119d997b673fcac34601b) --- source3/torture/samtest.c | 2 +- source3/torture/vfstest.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'source3/torture') diff --git a/source3/torture/samtest.c b/source3/torture/samtest.c index 56b87dc257..490cc2cdf3 100644 --- a/source3/torture/samtest.c +++ b/source3/torture/samtest.c @@ -189,7 +189,7 @@ static NTSTATUS do_cmd(struct sam_context *sam, struct cmd_set *cmd_entry, char { char *p = cmd, **argv = NULL; NTSTATUS result = NT_STATUS_UNSUCCESSFUL; - TALLOC_CTX *mem_ctx; + TALLOC_CTX *mem_ctx = NULL; pstring buf; int argc = 0, i; diff --git a/source3/torture/vfstest.c b/source3/torture/vfstest.c index 9f8062a02e..c68d2b04d2 100644 --- a/source3/torture/vfstest.c +++ b/source3/torture/vfstest.c @@ -264,7 +264,7 @@ static NTSTATUS do_cmd(struct vfs_state *vfs, struct cmd_set *cmd_entry, char *c char *p = cmd, **argv = NULL; NTSTATUS result = NT_STATUS_UNSUCCESSFUL; pstring buf; - TALLOC_CTX *mem_ctx; + TALLOC_CTX *mem_ctx = NULL; int argc = 0, i; /* Count number of arguments first time through the loop then -- cgit From df920a60b5f207149cbc9dcb63d406abb0d0490c Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Tue, 10 Sep 2002 01:58:51 +0000 Subject: Added final Steve French patch for "required" attributes with old dir listings. Added regression test in smbtorture (in HEAD) also. Jeremy. (This used to be commit 3c9d24d7c3bad2beb641880a97f0eda5cd3e4ec7) --- source3/torture/torture.c | 100 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 100 insertions(+) (limited to 'source3/torture') diff --git a/source3/torture/torture.c b/source3/torture/torture.c index 047b4c7a24..fb62b13657 100644 --- a/source3/torture/torture.c +++ b/source3/torture/torture.c @@ -3533,6 +3533,105 @@ static BOOL run_dirtest(int dummy) return correct; } +static void del_fn(file_info *finfo, const char *mask, void *state) +{ + struct cli_state *pcli = (struct cli_state *)state; + fstring fname; + slprintf(fname, sizeof(fname), "\\LISTDIR\\%s", finfo->name); + + if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0) + return; + + if (finfo->mode & aDIR) { + if (!cli_rmdir(pcli, fname)) + printf("del_fn: failed to rmdir %s\n,", fname ); + } else { + if (!cli_unlink(pcli, fname)) + printf("del_fn: failed to unlink %s\n,", fname ); + } +} + +static BOOL run_dirtest1(int dummy) +{ + int i; + static struct cli_state cli; + int fnum, num_seen; + BOOL correct = True; + + printf("starting directory test\n"); + + if (!torture_open_connection(&cli)) { + return False; + } + + cli_sockopt(&cli, sockops); + + cli_list(&cli, "\\LISTDIR\\*", 0, del_fn, &cli); + cli_list(&cli, "\\LISTDIR\\*", aDIR, del_fn, &cli); + cli_rmdir(&cli, "\\LISTDIR"); + cli_mkdir(&cli, "\\LISTDIR"); + + /* Create 1000 files and 1000 directories. */ + for (i=0;i<1000;i++) { + fstring fname; + slprintf(fname, sizeof(fname), "\\LISTDIR\\f%d", i); + fnum = cli_nt_create_full(&cli, fname, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_ARCHIVE, + FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0); + if (fnum == -1) { + fprintf(stderr,"Failed to open %s\n", fname); + return False; + } + cli_close(&cli, fnum); + } + for (i=0;i<1000;i++) { + fstring fname; + slprintf(fname, sizeof(fname), "\\LISTDIR\\d%d", i); + if (!cli_mkdir(&cli, fname)) { + fprintf(stderr,"Failed to open %s\n", fname); + return False; + } + } + + /* Now ensure that doing an old list sees both files and directories. */ + num_seen = cli_list_old(&cli, "\\LISTDIR\\*", aDIR, list_fn, NULL); + printf("num_seen = %d\n", num_seen ); + /* We should see 100 files + 1000 directories + . and .. */ + if (num_seen != 2002) + correct = False; + + /* Ensure if we have the "must have" bits we only see the + * relevent entries. + */ + num_seen = cli_list_old(&cli, "\\LISTDIR\\*", (aDIR<<8)|aDIR, list_fn, NULL); + printf("num_seen = %d\n", num_seen ); + if (num_seen != 1002) + correct = False; + + num_seen = cli_list_old(&cli, "\\LISTDIR\\*", (aARCH<<8)|aDIR, list_fn, NULL); + printf("num_seen = %d\n", num_seen ); + if (num_seen != 1000) + correct = False; + + /* Delete everything. */ + cli_list(&cli, "\\LISTDIR\\*", 0, del_fn, &cli); + cli_list(&cli, "\\LISTDIR\\*", aDIR, del_fn, &cli); + cli_rmdir(&cli, "\\LISTDIR"); + +#if 0 + printf("Matched %d\n", cli_list(&cli, "a*.*", 0, list_fn, NULL)); + printf("Matched %d\n", cli_list(&cli, "b*.*", 0, list_fn, NULL)); + printf("Matched %d\n", cli_list(&cli, "xyzabc", 0, list_fn, NULL)); +#endif + + if (!torture_close_connection(&cli)) { + correct = False; + } + + printf("finished dirtest1\n"); + + return correct; +} + static BOOL run_error_map_extract(int dummy) { static struct cli_state c_dos; @@ -3761,6 +3860,7 @@ static struct { {"OPLOCK2", run_oplock2, 0}, {"OPLOCK3", run_oplock3, 0}, {"DIR", run_dirtest, 0}, + {"DIR1", run_dirtest1, 0}, {"DENY1", torture_denytest1, 0}, {"DENY2", torture_denytest2, 0}, {"TCON", run_tcon_test, 0}, -- cgit From 1244410cc4d48e3d68dad2c979a9ad2a2f70989e Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 19 Sep 2002 15:39:00 +0000 Subject: Merge in first command for 'samtest' Fix small bug in sam/interface.c Make sam backend to default to a define (This used to be commit 60ab55fedf03a0b505b0b73527e031124a46304e) --- source3/torture/cmd_sam.c | 1002 +++++++++++++++++++++++++++++++++++++++++++++ source3/torture/samtest.c | 14 +- source3/torture/samtest.h | 31 ++ 3 files changed, 1036 insertions(+), 11 deletions(-) create mode 100644 source3/torture/cmd_sam.c create mode 100644 source3/torture/samtest.h (limited to 'source3/torture') diff --git a/source3/torture/cmd_sam.c b/source3/torture/cmd_sam.c new file mode 100644 index 0000000000..d276d52fe6 --- /dev/null +++ b/source3/torture/cmd_sam.c @@ -0,0 +1,1002 @@ +/* + Unix SMB/CIFS implementation. + SAM module functions + + Copyright (C) Jelmer Vernooij 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. +*/ + +#include "includes.h" +#include "samtest.h" + +static NTSTATUS cmd_load_module(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + char *plugin_arg[2]; + NTSTATUS status; + if (argc != 2) { + printf("Usage: load \n"); + return NT_STATUS_OK; + } + + asprintf(&plugin_arg[0], "plugin:%s", argv[1]); + plugin_arg[1] = NULL; + + if(!NT_STATUS_IS_OK(status = make_sam_context_list(&c, plugin_arg))) + { + return status; + } + printf("load: ok\n"); + return NT_STATUS_OK; +} + +#if 0 +static NTSTATUS cmd_populate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + char c; + size_t size; + if (argc != 3) { + printf("Usage: populate \n"); + return NT_STATUS_OK; + } + c = argv[1][0]; + size = atoi(argv[2]); + vfs->data = (char *)talloc(mem_ctx, size); + if (vfs->data == NULL) { + printf("populate: error=-1 (not enough memory)"); + return NT_STATUS_UNSUCCESSFUL; + } + memset(vfs->data, c, size); + vfs->data_size = size; + return NT_STATUS_OK; +} + +static NTSTATUS cmd_show_data(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + size_t offset; + size_t len; + if (argc != 1 && argc != 3) { + printf("Usage: showdata [ ]\n"); + return NT_STATUS_OK; + } + if (vfs->data == NULL || vfs->data_size == 0) { + printf("show_data: error=-1 (buffer empty)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + if (argc == 3) { + offset = atoi(argv[1]); + len = atoi(argv[2]); + } else { + offset = 0; + len = vfs->data_size; + } + if ((offset + len) > vfs->data_size) { + printf("show_data: error=-1 (not enough data in buffer)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + dump_data(0, (char *)(vfs->data) + offset, len); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_connect(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + vfs->conn->vfs_ops.connect(vfs->conn, lp_servicename(vfs->conn->service), "vfstest"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_disconnect(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + vfs->conn->vfs_ops.disconnect(vfs->conn); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_disk_free(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + SMB_BIG_UINT diskfree, bsize, dfree, dsize; + if (argc != 2) { + printf("Usage: disk_free \n"); + return NT_STATUS_OK; + } + + diskfree = vfs->conn->vfs_ops.disk_free(vfs->conn, argv[1], False, &bsize, &dfree, &dsize); + printf("disk_free: %ld, bsize = %ld, dfree = %ld, dsize = %ld\n", diskfree, bsize, dfree, dsize); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_opendir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + if (argc != 2) { + printf("Usage: opendir \n"); + return NT_STATUS_OK; + } + + vfs->currentdir = vfs->conn->vfs_ops.opendir(vfs->conn, argv[1]); + if (vfs->currentdir == NULL) { + printf("opendir error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("opendir: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_readdir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + struct dirent *dent; + + if (vfs->currentdir == NULL) { + printf("readdir: error=-1 (no open directory)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + dent = vfs->conn->vfs_ops.readdir(vfs->conn, vfs->currentdir); + if (dent == NULL) { + printf("readdir: NULL\n"); + return NT_STATUS_OK; + } + + printf("readdir: %s\n", dent->d_name); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_mkdir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + if (argc != 2) { + printf("Usage: mkdir \n"); + return NT_STATUS_OK; + } + + if (vfs->conn->vfs_ops.mkdir(vfs->conn, argv[1], 00755) == -1) { + printf("mkdir error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("mkdir: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_closedir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int ret; + + if (vfs->currentdir == NULL) { + printf("closedir: failure (no directory open)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + ret = vfs->conn->vfs_ops.closedir(vfs->conn, vfs->currentdir); + if (ret == -1) { + printf("closedir failure: %s\n", strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("closedir: ok\n"); + vfs->currentdir = NULL; + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_open(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int flags, fd; + mode_t mode; + char *flagstr; + + mode = 00400; + + if (argc < 3 || argc > 5) { + printf("Usage: open \n"); + printf(" flags: O = O_RDONLY\n"); + printf(" R = O_RDWR\n"); + printf(" W = O_WRONLY\n"); + printf(" C = O_CREAT\n"); + printf(" E = O_EXCL\n"); + printf(" T = O_TRUNC\n"); + printf(" A = O_APPEND\n"); + printf(" N = O_NONBLOCK/O_NDELAY\n"); +#ifdef O_SYNC + printf(" S = O_SYNC\n"); +#endif +#ifdef O_NOFOLLOW + printf(" F = O_NOFOLLOW\n"); +#endif + printf(" mode: see open.2\n"); + printf(" mode is ignored if C flag not present\n"); + printf(" mode defaults to 00400\n"); + return NT_STATUS_OK; + } + flags = 0; + flagstr = argv[2]; + while (*flagstr) { + switch (*flagstr) { + case 'O': + flags |= O_RDONLY; + break; + case 'R': + flags |= O_RDWR; + break; + case 'W': + flags |= O_WRONLY; + break; + case 'C': + flags |= O_CREAT; + break; + case 'E': + flags |= O_EXCL; + break; + case 'T': + flags |= O_TRUNC; + break; + case 'A': + flags |= O_APPEND; + break; + case 'N': + flags |= O_NONBLOCK; + break; +#ifdef O_SYNC + case 'S': + flags |= O_SYNC; + break; +#endif +#ifdef O_NOFOLLOW + case 'F': + flags |= O_NOFOLLOW; + break; +#endif + default: + printf("open: error=-1 (invalid flag!)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + flagstr++; + } + if ((flags & O_CREAT) && argc == 4) { + if (sscanf(argv[3], "%o", &mode) == 0) { + printf("open: error=-1 (invalid mode!)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + } + + fd = vfs->conn->vfs_ops.open(vfs->conn, argv[1], flags, mode); + if (fd == -1) { + printf("open: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + vfs->files[fd] = (struct files_struct *)malloc(sizeof(struct files_struct)); + vfs->files[fd]->fsp_name = strdup(argv[1]); + vfs->files[fd]->fd = fd; + vfs->files[fd]->conn = vfs->conn; + printf("open: fd=%d\n", fd); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_pathfunc(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int ret = -1; + + if (argc != 2) { + printf("Usage: %s \n", argv[0]); + return NT_STATUS_OK; + } + + if (strcmp("rmdir", argv[0]) == 0 ) { + ret = vfs->conn->vfs_ops.rmdir(vfs->conn, argv[1]); + } else if (strcmp("unlink", argv[0]) == 0 ) { + ret = vfs->conn->vfs_ops.unlink(vfs->conn, argv[1]); + } else if (strcmp("chdir", argv[0]) == 0 ) { + ret = vfs->conn->vfs_ops.chdir(vfs->conn, argv[1]); + } else { + printf("%s: error=%d (invalid function name!)\n", argv[0], errno); + return NT_STATUS_UNSUCCESSFUL; + } + + if (ret == -1) { + printf("%s: error=%d (%s)\n", argv[0], errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("%s: ok\n", argv[0]); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_close(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int fd, ret; + + if (argc != 2) { + printf("Usage: close \n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + if (vfs->files[fd] == NULL) { + printf("close: error=-1 (invalid file descriptor)\n"); + return NT_STATUS_OK; + } + + ret = vfs->conn->vfs_ops.close(vfs->files[fd], fd); + if (ret == -1 ) + printf("close: error=%d (%s)\n", errno, strerror(errno)); + else + printf("close: ok\n"); + + SAFE_FREE(vfs->files[fd]->fsp_name); + SAFE_FREE(vfs->files[fd]); + vfs->files[fd] = NULL; + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_read(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int fd; + size_t size, rsize; + + if (argc != 3) { + printf("Usage: read \n"); + return NT_STATUS_OK; + } + + /* do some error checking on these */ + fd = atoi(argv[1]); + size = atoi(argv[2]); + vfs->data = (char *)talloc(mem_ctx, size); + if (vfs->data == NULL) { + printf("read: error=-1 (not enough memory)"); + return NT_STATUS_UNSUCCESSFUL; + } + vfs->data_size = size; + + rsize = vfs->conn->vfs_ops.read(vfs->files[fd], fd, vfs->data, size); + if (rsize == -1) { + printf("read: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("read: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_write(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int fd, size, wsize; + + if (argc != 3) { + printf("Usage: write \n"); + return NT_STATUS_OK; + } + + /* some error checking should go here */ + fd = atoi(argv[1]); + size = atoi(argv[2]); + if (vfs->data == NULL) { + printf("write: error=-1 (buffer empty, please populate it before writing)"); + return NT_STATUS_UNSUCCESSFUL; + } + + if (vfs->data_size < size) { + printf("write: error=-1 (buffer too small, please put some more data in)"); + return NT_STATUS_UNSUCCESSFUL; + } + + wsize = vfs->conn->vfs_ops.write(vfs->files[fd], fd, vfs->data, size); + + if (wsize == -1) { + printf("write: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("write: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_lseek(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int fd, offset, whence; + SMB_OFF_T pos; + + if (argc != 4) { + printf("Usage: lseek \n...where whence is 1 => SEEK_SET, 2 => SEEK_CUR, 3 => SEEK_END\n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + offset = atoi(argv[2]); + whence = atoi(argv[3]); + switch (whence) { + case 1: whence = SEEK_SET; break; + case 2: whence = SEEK_CUR; break; + default: whence = SEEK_END; + } + + pos = vfs->conn->vfs_ops.lseek(vfs->files[fd], fd, offset, whence); + if (pos == (SMB_OFF_T)-1) { + printf("lseek: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("lseek: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_rename(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int ret; + if (argc != 3) { + printf("Usage: rename \n"); + return NT_STATUS_OK; + } + + ret = vfs->conn->vfs_ops.rename(vfs->conn, argv[1], argv[2]); + if (ret == -1) { + printf("rename: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("rename: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_fsync(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int ret, fd; + if (argc != 2) { + printf("Usage: fsync \n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + ret = vfs->conn->vfs_ops.fsync(vfs->files[fd], fd); + if (ret == -1) { + printf("fsync: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("fsync: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_stat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int ret; + char *user; + char *group; + struct passwd *pwd; + struct group *grp; + SMB_STRUCT_STAT st; + + if (argc != 2) { + printf("Usage: stat \n"); + return NT_STATUS_OK; + } + + ret = vfs->conn->vfs_ops.stat(vfs->conn, argv[1], &st); + if (ret == -1) { + printf("stat: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + pwd = sys_getpwuid(st.st_uid); + if (pwd != NULL) user = strdup(pwd->pw_name); + else user = null_string; + grp = sys_getgrgid(st.st_gid); + if (grp != NULL) group = strdup(grp->gr_name); + else group = null_string; + + printf("stat: ok\n"); + printf(" File: %s", argv[1]); + if (S_ISREG(st.st_mode)) printf(" Regular File\n"); + else if (S_ISDIR(st.st_mode)) printf(" Directory\n"); + else if (S_ISCHR(st.st_mode)) printf(" Character Device\n"); + else if (S_ISBLK(st.st_mode)) printf(" Block Device\n"); + else if (S_ISFIFO(st.st_mode)) printf(" Fifo\n"); + else if (S_ISLNK(st.st_mode)) printf(" Symbolic Link\n"); + else if (S_ISSOCK(st.st_mode)) printf(" Socket\n"); + printf(" Size: %10d", st.st_size); + printf(" Blocks: %9d", st.st_blocks); + printf(" IO Block: %d\n", st.st_blksize); + printf(" Device: 0x%10x", st.st_dev); + printf(" Inode: %10d", st.st_ino); + printf(" Links: %10d\n", st.st_nlink); + printf(" Access: %05o", (st.st_mode) & 007777); + printf(" Uid: %5d/%.16s Gid: %5d/%.16s\n", st.st_uid, user, st.st_gid, group); + printf(" Access: %s", ctime(&(st.st_atime))); + printf(" Modify: %s", ctime(&(st.st_mtime))); + printf(" Change: %s", ctime(&(st.st_ctime))); + if (user != null_string) SAFE_FREE(user); + if (group!= null_string) SAFE_FREE(group); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_fstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int fd; + char *user; + char *group; + struct passwd *pwd; + struct group *grp; + SMB_STRUCT_STAT st; + + if (argc != 2) { + printf("Usage: fstat \n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + if (fd < 0 || fd > 1024) { + printf("fstat: error=%d (file descriptor out of range)\n", EBADF); + return NT_STATUS_OK; + } + + if (vfs->files[fd] == NULL) { + printf("fstat: error=%d (invalid file descriptor)\n", EBADF); + return NT_STATUS_OK; + } + + if (vfs->conn->vfs_ops.fstat(vfs->files[fd], fd, &st) == -1) { + printf("fstat: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + pwd = sys_getpwuid(st.st_uid); + if (pwd != NULL) user = strdup(pwd->pw_name); + else user = null_string; + grp = sys_getgrgid(st.st_gid); + if (grp != NULL) group = strdup(grp->gr_name); + else group = null_string; + + printf("fstat: ok\n"); + if (S_ISREG(st.st_mode)) printf(" Regular File\n"); + else if (S_ISDIR(st.st_mode)) printf(" Directory\n"); + else if (S_ISCHR(st.st_mode)) printf(" Character Device\n"); + else if (S_ISBLK(st.st_mode)) printf(" Block Device\n"); + else if (S_ISFIFO(st.st_mode)) printf(" Fifo\n"); + else if (S_ISLNK(st.st_mode)) printf(" Symbolic Link\n"); + else if (S_ISSOCK(st.st_mode)) printf(" Socket\n"); + printf(" Size: %10d", st.st_size); + printf(" Blocks: %9d", st.st_blocks); + printf(" IO Block: %d\n", st.st_blksize); + printf(" Device: 0x%10x", st.st_dev); + printf(" Inode: %10d", st.st_ino); + printf(" Links: %10d\n", st.st_nlink); + printf(" Access: %05o", (st.st_mode) & 007777); + printf(" Uid: %5d/%.16s Gid: %5d/%.16s\n", st.st_uid, user, st.st_gid, group); + printf(" Access: %s", ctime(&(st.st_atime))); + printf(" Modify: %s", ctime(&(st.st_mtime))); + printf(" Change: %s", ctime(&(st.st_ctime))); + if (user != null_string) SAFE_FREE(user); + if (group!= null_string) SAFE_FREE(group); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_lstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + char *user; + char *group; + struct passwd *pwd; + struct group *grp; + SMB_STRUCT_STAT st; + + if (argc != 2) { + printf("Usage: lstat \n"); + return NT_STATUS_OK; + } + + if (vfs->conn->vfs_ops.lstat(vfs->conn, argv[1], &st) == -1) { + printf("lstat: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + pwd = sys_getpwuid(st.st_uid); + if (pwd != NULL) user = strdup(pwd->pw_name); + else user = null_string; + grp = sys_getgrgid(st.st_gid); + if (grp != NULL) group = strdup(grp->gr_name); + else group = null_string; + + printf("lstat: ok\n"); + if (S_ISREG(st.st_mode)) printf(" Regular File\n"); + else if (S_ISDIR(st.st_mode)) printf(" Directory\n"); + else if (S_ISCHR(st.st_mode)) printf(" Character Device\n"); + else if (S_ISBLK(st.st_mode)) printf(" Block Device\n"); + else if (S_ISFIFO(st.st_mode)) printf(" Fifo\n"); + else if (S_ISLNK(st.st_mode)) printf(" Symbolic Link\n"); + else if (S_ISSOCK(st.st_mode)) printf(" Socket\n"); + printf(" Size: %10d", st.st_size); + printf(" Blocks: %9d", st.st_blocks); + printf(" IO Block: %d\n", st.st_blksize); + printf(" Device: 0x%10x", st.st_dev); + printf(" Inode: %10d", st.st_ino); + printf(" Links: %10d\n", st.st_nlink); + printf(" Access: %05o", (st.st_mode) & 007777); + printf(" Uid: %5d/%.16s Gid: %5d/%.16s\n", st.st_uid, user, st.st_gid, group); + printf(" Access: %s", ctime(&(st.st_atime))); + printf(" Modify: %s", ctime(&(st.st_mtime))); + printf(" Change: %s", ctime(&(st.st_ctime))); + if (user != null_string) SAFE_FREE(user); + if (group!= null_string) SAFE_FREE(group); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_chmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + mode_t mode; + if (argc != 3) { + printf("Usage: chmod \n"); + return NT_STATUS_OK; + } + + mode = atoi(argv[2]); + if (vfs->conn->vfs_ops.chmod(vfs->conn, argv[1], mode) == -1) { + printf("chmod: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("chmod: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_fchmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int fd; + mode_t mode; + if (argc != 3) { + printf("Usage: fchmod \n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + mode = atoi(argv[2]); + if (fd < 0 || fd > 1024) { + printf("fchmod: error=%d (file descriptor out of range)\n", EBADF); + return NT_STATUS_OK; + } + if (vfs->files[fd] == NULL) { + printf("fchmod: error=%d (invalid file descriptor)\n", EBADF); + return NT_STATUS_OK; + } + + if (vfs->conn->vfs_ops.fchmod(vfs->files[fd], fd, mode) == -1) { + printf("fchmod: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("fchmod: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_chown(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + uid_t uid; + gid_t gid; + if (argc != 4) { + printf("Usage: chown \n"); + return NT_STATUS_OK; + } + + uid = atoi(argv[2]); + gid = atoi(argv[3]); + if (vfs->conn->vfs_ops.chown(vfs->conn, argv[1], uid, gid) == -1) { + printf("chown: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("chown: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_fchown(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + uid_t uid; + gid_t gid; + int fd; + if (argc != 4) { + printf("Usage: fchown \n"); + return NT_STATUS_OK; + } + + uid = atoi(argv[2]); + gid = atoi(argv[3]); + fd = atoi(argv[1]); + if (fd < 0 || fd > 1024) { + printf("fchown: faliure=%d (file descriptor out of range)\n", EBADF); + return NT_STATUS_OK; + } + if (vfs->files[fd] == NULL) { + printf("fchown: error=%d (invalid file descriptor)\n", EBADF); + return NT_STATUS_OK; + } + if (vfs->conn->vfs_ops.fchown(vfs->files[fd], fd, uid, gid) == -1) { + printf("fchown error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("fchown: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_getwd(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + char buf[PATH_MAX]; + if (vfs->conn->vfs_ops.getwd(vfs->conn, buf) == NULL) { + printf("getwd: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("getwd: %s\n", buf); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_utime(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + struct utimbuf times; + if (argc != 4) { + printf("Usage: utime \n"); + return NT_STATUS_OK; + } + times.actime = atoi(argv[2]); + times.modtime = atoi(argv[3]); + if (vfs->conn->vfs_ops.utime(vfs->conn, argv[1], ×) != 0) { + printf("utime: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("utime: ok\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_ftruncate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int fd; + SMB_OFF_T off; + if (argc != 3) { + printf("Usage: ftruncate \n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + off = atoi(argv[2]); + if (fd < 0 || fd > 1024) { + printf("ftruncate: error=%d (file descriptor out of range)\n", EBADF); + return NT_STATUS_OK; + } + if (vfs->files[fd] == NULL) { + printf("ftruncate: error=%d (invalid file descriptor)\n", EBADF); + return NT_STATUS_OK; + } + + if (vfs->conn->vfs_ops.ftruncate(vfs->files[fd], fd, off) == -1) { + printf("ftruncate: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("ftruncate: ok\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_lock(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + BOOL ret; + int fd; + int op; + long offset; + long count; + int type; + char *typestr; + + if (argc != 6) { + printf("Usage: lock \n"); + printf(" ops: G = F_GETLK\n"); + printf(" S = F_SETLK\n"); + printf(" W = F_SETLKW\n"); + printf(" type: R = F_RDLCK\n"); + printf(" W = F_WRLCK\n"); + printf(" U = F_UNLCK\n"); + return NT_STATUS_OK; + } + + if (sscanf(argv[1], "%d", &fd) == 0) { + printf("lock: error=-1 (error parsing fd)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + op = 0; + switch (*argv[2]) { + case 'G': + op = F_GETLK; + break; + case 'S': + op = F_SETLK; + break; + case 'W': + op = F_SETLKW; + break; + default: + printf("lock: error=-1 (invalid op flag!)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + if (sscanf(argv[3], "%ld", &offset) == 0) { + printf("lock: error=-1 (error parsing fd)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + if (sscanf(argv[4], "%ld", &count) == 0) { + printf("lock: error=-1 (error parsing fd)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + type = 0; + typestr = argv[5]; + while(*typestr) { + switch (*typestr) { + case 'R': + type |= F_RDLCK; + break; + case 'W': + type |= F_WRLCK; + break; + case 'U': + type |= F_UNLCK; + break; + default: + printf("lock: error=-1 (invalid type flag!)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + typestr++; + } + + printf("lock: debug lock(fd=%d, op=%d, offset=%ld, count=%ld, type=%d))\n", fd, op, offset, count, type); + + if ((ret = vfs->conn->vfs_ops.lock(vfs->files[fd], fd, op, offset, count, type)) == False) { + printf("lock: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("lock: ok\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_symlink(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + if (argc != 3) { + printf("Usage: symlink \n"); + return NT_STATUS_OK; + } + + if (vfs->conn->vfs_ops.symlink(vfs->conn, argv[1], argv[2]) == -1) { + printf("symlink: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("symlink: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_readlink(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + char buffer[PATH_MAX]; + int size; + + if (argc != 2) { + printf("Usage: readlink \n"); + return NT_STATUS_OK; + } + + if ((size = vfs->conn->vfs_ops.readlink(vfs->conn, argv[1], buffer, PATH_MAX)) == -1) { + printf("readlink: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + buffer[size] = '\0'; + printf("readlink: %s\n", buffer); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_link(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + if (argc != 3) { + printf("Usage: link \n"); + return NT_STATUS_OK; + } + + if (vfs->conn->vfs_ops.link(vfs->conn, argv[1], argv[2]) == -1) { + printf("link: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("link: ok\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_mknod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + mode_t mode; + SMB_DEV_T dev; + + if (argc != 4) { + printf("Usage: mknod \n"); + printf(" mode is octal\n"); + printf(" dev is hex\n"); + return NT_STATUS_OK; + } + + if (sscanf(argv[2], "%o", &mode) == 0) { + printf("open: error=-1 (invalid mode!)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + if (sscanf(argv[3], "%x", &dev) == 0) { + printf("open: error=-1 (invalid dev!)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + if (vfs->conn->vfs_ops.mknod(vfs->conn, argv[1], mode, dev) == -1) { + printf("mknod: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("mknod: ok\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_realpath(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + char respath[PATH_MAX]; + + if (argc != 2) { + printf("Usage: realpath \n"); + return NT_STATUS_OK; + } + + if (vfs->conn->vfs_ops.realpath(vfs->conn, argv[1], respath) == NULL) { + printf("realpath: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("realpath: ok\n"); + return NT_STATUS_OK; +} + +#endif + +struct cmd_set sam_commands[] = { + + { "SAM Commands" }, + + { "load", cmd_load_module, "Load a module", "load " }, + { NULL } +}; diff --git a/source3/torture/samtest.c b/source3/torture/samtest.c index 490cc2cdf3..3ac65ef0df 100644 --- a/source3/torture/samtest.c +++ b/source3/torture/samtest.c @@ -23,20 +23,13 @@ */ #include "includes.h" +#include "samtest.h" struct func_entry { char *name; int (*fn)(struct connection_struct *conn, const char *path); }; -struct cmd_set { - char *name; - NTSTATUS (*fn)(struct sam_context *sam, TALLOC_CTX *mem_ctx, int argc, - char **argv); - char *description; - char *usage; -}; - /* List to hold groups of commands */ static struct cmd_list { struct cmd_list *prev, *next; @@ -164,9 +157,10 @@ static struct cmd_set separator_command[] = { /*extern struct cmd_set sam_commands[];*/ +extern struct cmd_set sam_commands[]; static struct cmd_set *samtest_command_list[] = { samtest_commands, -/* sam_commands, NOT YET */ + sam_commands, NULL }; @@ -336,12 +330,10 @@ int main(int argc, char *argv[]) int opt; static char *cmdstr = ""; static char *opt_logfile=NULL; - static int opt_debuglevel; pstring logfile; struct cmd_set **cmd_set; extern BOOL AllowDebugChange; static struct sam_context sam; - int i; /* make sure the vars that get altered (4th field) are in diff --git a/source3/torture/samtest.h b/source3/torture/samtest.h new file mode 100644 index 0000000000..2a8516cfc3 --- /dev/null +++ b/source3/torture/samtest.h @@ -0,0 +1,31 @@ +/* + Unix SMB/CIFS implementation. + SAM module tester + + Copyright (C) Jelmer Vernooij 2002 + + Most of this code was ripped off of rpcclient. + Copyright (C) Tim Potter 2000-2001 + + 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. +*/ + +struct cmd_set { + char *name; + NTSTATUS (*fn)(struct sam_context *sam, TALLOC_CTX *mem_ctx, int argc, + char **argv); + char *description; + char *usage; +}; -- cgit From 696fedc7ad26222c94d0ecfda4aa3fa5be2377ca Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 20 Sep 2002 16:59:48 +0000 Subject: Add framework for samtest commands (This used to be commit f1021cbc557bfa0078e932a8268c5c9adcae0ae8) --- source3/torture/cmd_sam.c | 985 +++++----------------------------------------- source3/torture/samtest.c | 12 +- 2 files changed, 117 insertions(+), 880 deletions(-) (limited to 'source3/torture') diff --git a/source3/torture/cmd_sam.c b/source3/torture/cmd_sam.c index d276d52fe6..a2835ed69a 100644 --- a/source3/torture/cmd_sam.c +++ b/source3/torture/cmd_sam.c @@ -22,6 +22,26 @@ #include "includes.h" #include "samtest.h" +#if 0 +static struct cmd_popt_user_opts [] = { + { NULL, 0, POPT_ARG_CALLBACK, cmd_parse_user_opts }, + {"username", 'u', POPT_ARG_STRING, NULL, 1, "Username to use"}, +}; + +static void cmd_parse_user_opts(poptContext con, + enum poptCallbackReason reason, + const struct poptOption *opt, + const char *arg, const void *data) +{ + SAM_ACCOUNT_HANDLE *account = (SAM_ACCOUNT_HANDLE *)data; + switch(opt->val) { + case 'u': + sam_set_account_username(account, arg); + break; + } +} +#endif + static NTSTATUS cmd_load_module(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { char *plugin_arg[2]; @@ -42,961 +62,172 @@ static NTSTATUS cmd_load_module(struct sam_context *c, TALLOC_CTX *mem_ctx, int return NT_STATUS_OK; } -#if 0 -static NTSTATUS cmd_populate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) -{ - char c; - size_t size; - if (argc != 3) { - printf("Usage: populate \n"); - return NT_STATUS_OK; - } - c = argv[1][0]; - size = atoi(argv[2]); - vfs->data = (char *)talloc(mem_ctx, size); - if (vfs->data == NULL) { - printf("populate: error=-1 (not enough memory)"); - return NT_STATUS_UNSUCCESSFUL; - } - memset(vfs->data, c, size); - vfs->data_size = size; - return NT_STATUS_OK; -} - -static NTSTATUS cmd_show_data(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) -{ - size_t offset; - size_t len; - if (argc != 1 && argc != 3) { - printf("Usage: showdata [ ]\n"); - return NT_STATUS_OK; - } - if (vfs->data == NULL || vfs->data_size == 0) { - printf("show_data: error=-1 (buffer empty)\n"); - return NT_STATUS_UNSUCCESSFUL; - } - - if (argc == 3) { - offset = atoi(argv[1]); - len = atoi(argv[2]); - } else { - offset = 0; - len = vfs->data_size; - } - if ((offset + len) > vfs->data_size) { - printf("show_data: error=-1 (not enough data in buffer)\n"); - return NT_STATUS_UNSUCCESSFUL; - } - dump_data(0, (char *)(vfs->data) + offset, len); - return NT_STATUS_OK; -} - -static NTSTATUS cmd_connect(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) -{ - vfs->conn->vfs_ops.connect(vfs->conn, lp_servicename(vfs->conn->service), "vfstest"); - return NT_STATUS_OK; -} - -static NTSTATUS cmd_disconnect(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) -{ - vfs->conn->vfs_ops.disconnect(vfs->conn); - return NT_STATUS_OK; -} - -static NTSTATUS cmd_disk_free(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) -{ - SMB_BIG_UINT diskfree, bsize, dfree, dsize; - if (argc != 2) { - printf("Usage: disk_free \n"); - return NT_STATUS_OK; - } - - diskfree = vfs->conn->vfs_ops.disk_free(vfs->conn, argv[1], False, &bsize, &dfree, &dsize); - printf("disk_free: %ld, bsize = %ld, dfree = %ld, dsize = %ld\n", diskfree, bsize, dfree, dsize); - return NT_STATUS_OK; -} - - -static NTSTATUS cmd_opendir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) -{ - if (argc != 2) { - printf("Usage: opendir \n"); - return NT_STATUS_OK; - } - - vfs->currentdir = vfs->conn->vfs_ops.opendir(vfs->conn, argv[1]); - if (vfs->currentdir == NULL) { - printf("opendir error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("opendir: ok\n"); - return NT_STATUS_OK; -} - - -static NTSTATUS cmd_readdir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) -{ - struct dirent *dent; - - if (vfs->currentdir == NULL) { - printf("readdir: error=-1 (no open directory)\n"); - return NT_STATUS_UNSUCCESSFUL; - } - - dent = vfs->conn->vfs_ops.readdir(vfs->conn, vfs->currentdir); - if (dent == NULL) { - printf("readdir: NULL\n"); - return NT_STATUS_OK; - } - - printf("readdir: %s\n", dent->d_name); - return NT_STATUS_OK; -} - - -static NTSTATUS cmd_mkdir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_get_sec_desc(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - if (argc != 2) { - printf("Usage: mkdir \n"); - return NT_STATUS_OK; - } - - if (vfs->conn->vfs_ops.mkdir(vfs->conn, argv[1], 00755) == -1) { - printf("mkdir error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("mkdir: ok\n"); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } - -static NTSTATUS cmd_closedir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_set_sec_desc(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - int ret; - - if (vfs->currentdir == NULL) { - printf("closedir: failure (no directory open)\n"); - return NT_STATUS_UNSUCCESSFUL; - } - - ret = vfs->conn->vfs_ops.closedir(vfs->conn, vfs->currentdir); - if (ret == -1) { - printf("closedir failure: %s\n", strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("closedir: ok\n"); - vfs->currentdir = NULL; - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } - -static NTSTATUS cmd_open(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_lookup_sid(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - int flags, fd; - mode_t mode; - char *flagstr; - - mode = 00400; - - if (argc < 3 || argc > 5) { - printf("Usage: open \n"); - printf(" flags: O = O_RDONLY\n"); - printf(" R = O_RDWR\n"); - printf(" W = O_WRONLY\n"); - printf(" C = O_CREAT\n"); - printf(" E = O_EXCL\n"); - printf(" T = O_TRUNC\n"); - printf(" A = O_APPEND\n"); - printf(" N = O_NONBLOCK/O_NDELAY\n"); -#ifdef O_SYNC - printf(" S = O_SYNC\n"); -#endif -#ifdef O_NOFOLLOW - printf(" F = O_NOFOLLOW\n"); -#endif - printf(" mode: see open.2\n"); - printf(" mode is ignored if C flag not present\n"); - printf(" mode defaults to 00400\n"); - return NT_STATUS_OK; - } - flags = 0; - flagstr = argv[2]; - while (*flagstr) { - switch (*flagstr) { - case 'O': - flags |= O_RDONLY; - break; - case 'R': - flags |= O_RDWR; - break; - case 'W': - flags |= O_WRONLY; - break; - case 'C': - flags |= O_CREAT; - break; - case 'E': - flags |= O_EXCL; - break; - case 'T': - flags |= O_TRUNC; - break; - case 'A': - flags |= O_APPEND; - break; - case 'N': - flags |= O_NONBLOCK; - break; -#ifdef O_SYNC - case 'S': - flags |= O_SYNC; - break; -#endif -#ifdef O_NOFOLLOW - case 'F': - flags |= O_NOFOLLOW; - break; -#endif - default: - printf("open: error=-1 (invalid flag!)\n"); - return NT_STATUS_UNSUCCESSFUL; - } - flagstr++; - } - if ((flags & O_CREAT) && argc == 4) { - if (sscanf(argv[3], "%o", &mode) == 0) { - printf("open: error=-1 (invalid mode!)\n"); - return NT_STATUS_UNSUCCESSFUL; - } - } - - fd = vfs->conn->vfs_ops.open(vfs->conn, argv[1], flags, mode); - if (fd == -1) { - printf("open: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - vfs->files[fd] = (struct files_struct *)malloc(sizeof(struct files_struct)); - vfs->files[fd]->fsp_name = strdup(argv[1]); - vfs->files[fd]->fd = fd; - vfs->files[fd]->conn = vfs->conn; - printf("open: fd=%d\n", fd); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } - -static NTSTATUS cmd_pathfunc(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_lookup_name(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - int ret = -1; - - if (argc != 2) { - printf("Usage: %s \n", argv[0]); - return NT_STATUS_OK; - } - - if (strcmp("rmdir", argv[0]) == 0 ) { - ret = vfs->conn->vfs_ops.rmdir(vfs->conn, argv[1]); - } else if (strcmp("unlink", argv[0]) == 0 ) { - ret = vfs->conn->vfs_ops.unlink(vfs->conn, argv[1]); - } else if (strcmp("chdir", argv[0]) == 0 ) { - ret = vfs->conn->vfs_ops.chdir(vfs->conn, argv[1]); - } else { - printf("%s: error=%d (invalid function name!)\n", argv[0], errno); - return NT_STATUS_UNSUCCESSFUL; - } - - if (ret == -1) { - printf("%s: error=%d (%s)\n", argv[0], errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("%s: ok\n", argv[0]); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } - -static NTSTATUS cmd_close(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_lookup_account(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - int fd, ret; - - if (argc != 2) { - printf("Usage: close \n"); - return NT_STATUS_OK; - } - - fd = atoi(argv[1]); - if (vfs->files[fd] == NULL) { - printf("close: error=-1 (invalid file descriptor)\n"); - return NT_STATUS_OK; - } - - ret = vfs->conn->vfs_ops.close(vfs->files[fd], fd); - if (ret == -1 ) - printf("close: error=%d (%s)\n", errno, strerror(errno)); - else - printf("close: ok\n"); - - SAFE_FREE(vfs->files[fd]->fsp_name); - SAFE_FREE(vfs->files[fd]); - vfs->files[fd] = NULL; - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } - -static NTSTATUS cmd_read(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_lookup_group(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - int fd; - size_t size, rsize; - - if (argc != 3) { - printf("Usage: read \n"); - return NT_STATUS_OK; - } - - /* do some error checking on these */ - fd = atoi(argv[1]); - size = atoi(argv[2]); - vfs->data = (char *)talloc(mem_ctx, size); - if (vfs->data == NULL) { - printf("read: error=-1 (not enough memory)"); - return NT_STATUS_UNSUCCESSFUL; - } - vfs->data_size = size; - - rsize = vfs->conn->vfs_ops.read(vfs->files[fd], fd, vfs->data, size); - if (rsize == -1) { - printf("read: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("read: ok\n"); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } - -static NTSTATUS cmd_write(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_update_domain(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - int fd, size, wsize; - - if (argc != 3) { - printf("Usage: write \n"); - return NT_STATUS_OK; - } - - /* some error checking should go here */ - fd = atoi(argv[1]); - size = atoi(argv[2]); - if (vfs->data == NULL) { - printf("write: error=-1 (buffer empty, please populate it before writing)"); - return NT_STATUS_UNSUCCESSFUL; - } - - if (vfs->data_size < size) { - printf("write: error=-1 (buffer too small, please put some more data in)"); - return NT_STATUS_UNSUCCESSFUL; - } - - wsize = vfs->conn->vfs_ops.write(vfs->files[fd], fd, vfs->data, size); - - if (wsize == -1) { - printf("write: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("write: ok\n"); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } - -static NTSTATUS cmd_lseek(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_show_domain(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - int fd, offset, whence; - SMB_OFF_T pos; - - if (argc != 4) { - printf("Usage: lseek \n...where whence is 1 => SEEK_SET, 2 => SEEK_CUR, 3 => SEEK_END\n"); - return NT_STATUS_OK; - } - - fd = atoi(argv[1]); - offset = atoi(argv[2]); - whence = atoi(argv[3]); - switch (whence) { - case 1: whence = SEEK_SET; break; - case 2: whence = SEEK_CUR; break; - default: whence = SEEK_END; - } - - pos = vfs->conn->vfs_ops.lseek(vfs->files[fd], fd, offset, whence); - if (pos == (SMB_OFF_T)-1) { - printf("lseek: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("lseek: ok\n"); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } - -static NTSTATUS cmd_rename(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_create_account(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - int ret; - if (argc != 3) { - printf("Usage: rename \n"); - return NT_STATUS_OK; - } - - ret = vfs->conn->vfs_ops.rename(vfs->conn, argv[1], argv[2]); - if (ret == -1) { - printf("rename: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("rename: ok\n"); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } - -static NTSTATUS cmd_fsync(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_update_account(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - int ret, fd; - if (argc != 2) { - printf("Usage: fsync \n"); - return NT_STATUS_OK; - } - - fd = atoi(argv[1]); - ret = vfs->conn->vfs_ops.fsync(vfs->files[fd], fd); - if (ret == -1) { - printf("fsync: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("fsync: ok\n"); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } - -static NTSTATUS cmd_stat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_delete_account(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - int ret; - char *user; - char *group; - struct passwd *pwd; - struct group *grp; - SMB_STRUCT_STAT st; - - if (argc != 2) { - printf("Usage: stat \n"); - return NT_STATUS_OK; - } - - ret = vfs->conn->vfs_ops.stat(vfs->conn, argv[1], &st); - if (ret == -1) { - printf("stat: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - pwd = sys_getpwuid(st.st_uid); - if (pwd != NULL) user = strdup(pwd->pw_name); - else user = null_string; - grp = sys_getgrgid(st.st_gid); - if (grp != NULL) group = strdup(grp->gr_name); - else group = null_string; - - printf("stat: ok\n"); - printf(" File: %s", argv[1]); - if (S_ISREG(st.st_mode)) printf(" Regular File\n"); - else if (S_ISDIR(st.st_mode)) printf(" Directory\n"); - else if (S_ISCHR(st.st_mode)) printf(" Character Device\n"); - else if (S_ISBLK(st.st_mode)) printf(" Block Device\n"); - else if (S_ISFIFO(st.st_mode)) printf(" Fifo\n"); - else if (S_ISLNK(st.st_mode)) printf(" Symbolic Link\n"); - else if (S_ISSOCK(st.st_mode)) printf(" Socket\n"); - printf(" Size: %10d", st.st_size); - printf(" Blocks: %9d", st.st_blocks); - printf(" IO Block: %d\n", st.st_blksize); - printf(" Device: 0x%10x", st.st_dev); - printf(" Inode: %10d", st.st_ino); - printf(" Links: %10d\n", st.st_nlink); - printf(" Access: %05o", (st.st_mode) & 007777); - printf(" Uid: %5d/%.16s Gid: %5d/%.16s\n", st.st_uid, user, st.st_gid, group); - printf(" Access: %s", ctime(&(st.st_atime))); - printf(" Modify: %s", ctime(&(st.st_mtime))); - printf(" Change: %s", ctime(&(st.st_ctime))); - if (user != null_string) SAFE_FREE(user); - if (group!= null_string) SAFE_FREE(group); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } - -static NTSTATUS cmd_fstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_enum_accounts(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - int fd; - char *user; - char *group; - struct passwd *pwd; - struct group *grp; - SMB_STRUCT_STAT st; - - if (argc != 2) { - printf("Usage: fstat \n"); - return NT_STATUS_OK; - } - - fd = atoi(argv[1]); - if (fd < 0 || fd > 1024) { - printf("fstat: error=%d (file descriptor out of range)\n", EBADF); - return NT_STATUS_OK; - } - - if (vfs->files[fd] == NULL) { - printf("fstat: error=%d (invalid file descriptor)\n", EBADF); - return NT_STATUS_OK; - } - - if (vfs->conn->vfs_ops.fstat(vfs->files[fd], fd, &st) == -1) { - printf("fstat: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - pwd = sys_getpwuid(st.st_uid); - if (pwd != NULL) user = strdup(pwd->pw_name); - else user = null_string; - grp = sys_getgrgid(st.st_gid); - if (grp != NULL) group = strdup(grp->gr_name); - else group = null_string; - - printf("fstat: ok\n"); - if (S_ISREG(st.st_mode)) printf(" Regular File\n"); - else if (S_ISDIR(st.st_mode)) printf(" Directory\n"); - else if (S_ISCHR(st.st_mode)) printf(" Character Device\n"); - else if (S_ISBLK(st.st_mode)) printf(" Block Device\n"); - else if (S_ISFIFO(st.st_mode)) printf(" Fifo\n"); - else if (S_ISLNK(st.st_mode)) printf(" Symbolic Link\n"); - else if (S_ISSOCK(st.st_mode)) printf(" Socket\n"); - printf(" Size: %10d", st.st_size); - printf(" Blocks: %9d", st.st_blocks); - printf(" IO Block: %d\n", st.st_blksize); - printf(" Device: 0x%10x", st.st_dev); - printf(" Inode: %10d", st.st_ino); - printf(" Links: %10d\n", st.st_nlink); - printf(" Access: %05o", (st.st_mode) & 007777); - printf(" Uid: %5d/%.16s Gid: %5d/%.16s\n", st.st_uid, user, st.st_gid, group); - printf(" Access: %s", ctime(&(st.st_atime))); - printf(" Modify: %s", ctime(&(st.st_mtime))); - printf(" Change: %s", ctime(&(st.st_ctime))); - if (user != null_string) SAFE_FREE(user); - if (group!= null_string) SAFE_FREE(group); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } - -static NTSTATUS cmd_lstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_lookup_account_sid(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - char *user; - char *group; - struct passwd *pwd; - struct group *grp; - SMB_STRUCT_STAT st; - - if (argc != 2) { - printf("Usage: lstat \n"); - return NT_STATUS_OK; - } - - if (vfs->conn->vfs_ops.lstat(vfs->conn, argv[1], &st) == -1) { - printf("lstat: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - pwd = sys_getpwuid(st.st_uid); - if (pwd != NULL) user = strdup(pwd->pw_name); - else user = null_string; - grp = sys_getgrgid(st.st_gid); - if (grp != NULL) group = strdup(grp->gr_name); - else group = null_string; - - printf("lstat: ok\n"); - if (S_ISREG(st.st_mode)) printf(" Regular File\n"); - else if (S_ISDIR(st.st_mode)) printf(" Directory\n"); - else if (S_ISCHR(st.st_mode)) printf(" Character Device\n"); - else if (S_ISBLK(st.st_mode)) printf(" Block Device\n"); - else if (S_ISFIFO(st.st_mode)) printf(" Fifo\n"); - else if (S_ISLNK(st.st_mode)) printf(" Symbolic Link\n"); - else if (S_ISSOCK(st.st_mode)) printf(" Socket\n"); - printf(" Size: %10d", st.st_size); - printf(" Blocks: %9d", st.st_blocks); - printf(" IO Block: %d\n", st.st_blksize); - printf(" Device: 0x%10x", st.st_dev); - printf(" Inode: %10d", st.st_ino); - printf(" Links: %10d\n", st.st_nlink); - printf(" Access: %05o", (st.st_mode) & 007777); - printf(" Uid: %5d/%.16s Gid: %5d/%.16s\n", st.st_uid, user, st.st_gid, group); - printf(" Access: %s", ctime(&(st.st_atime))); - printf(" Modify: %s", ctime(&(st.st_mtime))); - printf(" Change: %s", ctime(&(st.st_ctime))); - if (user != null_string) SAFE_FREE(user); - if (group!= null_string) SAFE_FREE(group); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } - -static NTSTATUS cmd_chmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_lookup_account_name(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - mode_t mode; - if (argc != 3) { - printf("Usage: chmod \n"); - return NT_STATUS_OK; - } - - mode = atoi(argv[2]); - if (vfs->conn->vfs_ops.chmod(vfs->conn, argv[1], mode) == -1) { - printf("chmod: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("chmod: ok\n"); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } - -static NTSTATUS cmd_fchmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_create_group(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - int fd; - mode_t mode; - if (argc != 3) { - printf("Usage: fchmod \n"); - return NT_STATUS_OK; - } - - fd = atoi(argv[1]); - mode = atoi(argv[2]); - if (fd < 0 || fd > 1024) { - printf("fchmod: error=%d (file descriptor out of range)\n", EBADF); - return NT_STATUS_OK; - } - if (vfs->files[fd] == NULL) { - printf("fchmod: error=%d (invalid file descriptor)\n", EBADF); - return NT_STATUS_OK; - } - - if (vfs->conn->vfs_ops.fchmod(vfs->files[fd], fd, mode) == -1) { - printf("fchmod: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("fchmod: ok\n"); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } - -static NTSTATUS cmd_chown(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_update_group(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - uid_t uid; - gid_t gid; - if (argc != 4) { - printf("Usage: chown \n"); - return NT_STATUS_OK; - } - - uid = atoi(argv[2]); - gid = atoi(argv[3]); - if (vfs->conn->vfs_ops.chown(vfs->conn, argv[1], uid, gid) == -1) { - printf("chown: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("chown: ok\n"); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } - -static NTSTATUS cmd_fchown(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_delete_group(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - uid_t uid; - gid_t gid; - int fd; - if (argc != 4) { - printf("Usage: fchown \n"); - return NT_STATUS_OK; - } - - uid = atoi(argv[2]); - gid = atoi(argv[3]); - fd = atoi(argv[1]); - if (fd < 0 || fd > 1024) { - printf("fchown: faliure=%d (file descriptor out of range)\n", EBADF); - return NT_STATUS_OK; - } - if (vfs->files[fd] == NULL) { - printf("fchown: error=%d (invalid file descriptor)\n", EBADF); - return NT_STATUS_OK; - } - if (vfs->conn->vfs_ops.fchown(vfs->files[fd], fd, uid, gid) == -1) { - printf("fchown error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("fchown: ok\n"); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } - -static NTSTATUS cmd_getwd(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_enum_groups(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - char buf[PATH_MAX]; - if (vfs->conn->vfs_ops.getwd(vfs->conn, buf) == NULL) { - printf("getwd: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("getwd: %s\n", buf); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_utime(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_lookup_group_sid(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - struct utimbuf times; - if (argc != 4) { - printf("Usage: utime \n"); - return NT_STATUS_OK; - } - times.actime = atoi(argv[2]); - times.modtime = atoi(argv[3]); - if (vfs->conn->vfs_ops.utime(vfs->conn, argv[1], ×) != 0) { - printf("utime: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("utime: ok\n"); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_ftruncate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_lookup_group_name(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - int fd; - SMB_OFF_T off; - if (argc != 3) { - printf("Usage: ftruncate \n"); - return NT_STATUS_OK; - } - - fd = atoi(argv[1]); - off = atoi(argv[2]); - if (fd < 0 || fd > 1024) { - printf("ftruncate: error=%d (file descriptor out of range)\n", EBADF); - return NT_STATUS_OK; - } - if (vfs->files[fd] == NULL) { - printf("ftruncate: error=%d (invalid file descriptor)\n", EBADF); - return NT_STATUS_OK; - } - - if (vfs->conn->vfs_ops.ftruncate(vfs->files[fd], fd, off) == -1) { - printf("ftruncate: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("ftruncate: ok\n"); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_lock(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_group_add_member(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - BOOL ret; - int fd; - int op; - long offset; - long count; - int type; - char *typestr; - - if (argc != 6) { - printf("Usage: lock \n"); - printf(" ops: G = F_GETLK\n"); - printf(" S = F_SETLK\n"); - printf(" W = F_SETLKW\n"); - printf(" type: R = F_RDLCK\n"); - printf(" W = F_WRLCK\n"); - printf(" U = F_UNLCK\n"); - return NT_STATUS_OK; - } - - if (sscanf(argv[1], "%d", &fd) == 0) { - printf("lock: error=-1 (error parsing fd)\n"); - return NT_STATUS_UNSUCCESSFUL; - } - - op = 0; - switch (*argv[2]) { - case 'G': - op = F_GETLK; - break; - case 'S': - op = F_SETLK; - break; - case 'W': - op = F_SETLKW; - break; - default: - printf("lock: error=-1 (invalid op flag!)\n"); - return NT_STATUS_UNSUCCESSFUL; - } - - if (sscanf(argv[3], "%ld", &offset) == 0) { - printf("lock: error=-1 (error parsing fd)\n"); - return NT_STATUS_UNSUCCESSFUL; - } - - if (sscanf(argv[4], "%ld", &count) == 0) { - printf("lock: error=-1 (error parsing fd)\n"); - return NT_STATUS_UNSUCCESSFUL; - } - - type = 0; - typestr = argv[5]; - while(*typestr) { - switch (*typestr) { - case 'R': - type |= F_RDLCK; - break; - case 'W': - type |= F_WRLCK; - break; - case 'U': - type |= F_UNLCK; - break; - default: - printf("lock: error=-1 (invalid type flag!)\n"); - return NT_STATUS_UNSUCCESSFUL; - } - typestr++; - } - - printf("lock: debug lock(fd=%d, op=%d, offset=%ld, count=%ld, type=%d))\n", fd, op, offset, count, type); - - if ((ret = vfs->conn->vfs_ops.lock(vfs->files[fd], fd, op, offset, count, type)) == False) { - printf("lock: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("lock: ok\n"); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_symlink(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_group_del_member(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - if (argc != 3) { - printf("Usage: symlink \n"); - return NT_STATUS_OK; - } - - if (vfs->conn->vfs_ops.symlink(vfs->conn, argv[1], argv[2]) == -1) { - printf("symlink: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("symlink: ok\n"); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_readlink(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_group_enum(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - char buffer[PATH_MAX]; - int size; - - if (argc != 2) { - printf("Usage: readlink \n"); - return NT_STATUS_OK; - } - - if ((size = vfs->conn->vfs_ops.readlink(vfs->conn, argv[1], buffer, PATH_MAX)) == -1) { - printf("readlink: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - buffer[size] = '\0'; - printf("readlink: %s\n", buffer); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_link(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_get_sid_groups(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) { - if (argc != 3) { - printf("Usage: link \n"); - return NT_STATUS_OK; - } - - if (vfs->conn->vfs_ops.link(vfs->conn, argv[1], argv[2]) == -1) { - printf("link: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("link: ok\n"); - return NT_STATUS_OK; -} - -static NTSTATUS cmd_mknod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) -{ - mode_t mode; - SMB_DEV_T dev; - - if (argc != 4) { - printf("Usage: mknod \n"); - printf(" mode is octal\n"); - printf(" dev is hex\n"); - return NT_STATUS_OK; - } - - if (sscanf(argv[2], "%o", &mode) == 0) { - printf("open: error=-1 (invalid mode!)\n"); - return NT_STATUS_UNSUCCESSFUL; - } - - if (sscanf(argv[3], "%x", &dev) == 0) { - printf("open: error=-1 (invalid dev!)\n"); - return NT_STATUS_UNSUCCESSFUL; - } - - if (vfs->conn->vfs_ops.mknod(vfs->conn, argv[1], mode, dev) == -1) { - printf("mknod: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } - - printf("mknod: ok\n"); - return NT_STATUS_OK; + return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_realpath(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv) -{ - char respath[PATH_MAX]; - - if (argc != 2) { - printf("Usage: realpath \n"); - return NT_STATUS_OK; - } +struct cmd_set sam_general_commands[] = { - if (vfs->conn->vfs_ops.realpath(vfs->conn, argv[1], respath) == NULL) { - printf("realpath: error=%d (%s)\n", errno, strerror(errno)); - return NT_STATUS_UNSUCCESSFUL; - } + { "General SAM Commands" }, - printf("realpath: ok\n"); - return NT_STATUS_OK; -} - -#endif + { "load", cmd_load_module, "Load a module", "load " }, + { "get_sec_desc", cmd_get_sec_desc, "Get security descriptor info", "get_sec_desc " }, + { "set_sec_desc", cmd_set_sec_desc, "Set security descriptor info", "set_sec_desc " }, + { "lookup_sid", cmd_lookup_sid, "Lookup type of specified SID", "lookup_sid " }, + { "lookup_name", cmd_lookup_name, "Lookup type of specified name", "lookup_name " }, + { NULL } +}; -struct cmd_set sam_commands[] = { +struct cmd_set sam_domain_commands[] = { + { "Domain Commands" }, + { "update_domain", cmd_update_domain, "Update domain information", "update_domain [domain-options] domain-name | domain-sid" }, + { "show_domain", cmd_show_domain, "Show domain information", "show_domain domain-sid | domain-name" }, + { NULL } +}; - { "SAM Commands" }, +struct cmd_set sam_account_commands[] = { + { "Account Commands" }, + { "create_account", cmd_create_account, "Create a new account with specified properties", "create_account [account-options]" }, + { "update_account", cmd_update_account, "Update an existing account", "update_account [account-options] account-sid | account-name" }, + { "delete_account", cmd_delete_account, "Delete an account", "delete_account account-sid | account-name" }, + { "enum_accounts", cmd_enum_accounts, "Enumerate all accounts", "enum_accounts " }, + { "lookup_account", cmd_lookup_account, "Lookup an account by either sid or name", "lookup_account account-sid | account-name" }, + { "lookup_account_sid", cmd_lookup_account_sid, "Lookup an account by sid", "lookup_account_sid account-sid" }, + { "lookup_account_name", cmd_lookup_account_name, "Lookup an account by name", "lookup_account_name account-name" }, + { NULL } +}; - { "load", cmd_load_module, "Load a module", "load " }, +struct cmd_set sam_group_commands[] = { + { "Group Commands" }, + { "create_group", cmd_create_group, "Create a new group", "create_group [group-opts]" }, + { "update_group", cmd_update_group, "Update an existing group", "update_group [group-opts] group-name | group-sid" }, + { "delete_group", cmd_delete_group, "Delete an existing group", "delete_group group-name | group-sid" }, + { "enum_groups", cmd_enum_groups, "Enumerate all groups", "enum_groups " }, + { "lookup_group", cmd_lookup_group, "Lookup a group by SID or name", "lookup_group group-sid | group-name" }, + { "lookup_group_sid", cmd_lookup_group_sid, "Lookup a group by SID", "lookup_group_sid " }, + { "lookup_group_name", cmd_lookup_group_name, "Lookup a group by name", "lookup_group_name " }, + { "group_add_member", cmd_group_add_member, "Add group member to group", "group_add_member " }, + { "group_del_member", cmd_group_del_member, "Delete group member from group", "group_del_member " }, + { "group_enum", cmd_group_enum, "Enumerate all members of specified group", "group_enum group-sid | group-name" }, + + { "get_sid_groups", cmd_get_sid_groups, "Get a list of groups specified sid is a member of", "group_enum " }, { NULL } }; diff --git a/source3/torture/samtest.c b/source3/torture/samtest.c index 3ac65ef0df..0275e0f002 100644 --- a/source3/torture/samtest.c +++ b/source3/torture/samtest.c @@ -100,7 +100,7 @@ static NTSTATUS cmd_help(struct sam_context *sam, TALLOC_CTX *mem_ctx, while(tmp_set->name) { - printf("%15s\t\t%s\n", tmp_set->name, + printf("%20s\t%s\n", tmp_set->name, tmp_set->description ? tmp_set->description: ""); @@ -157,10 +157,16 @@ static struct cmd_set separator_command[] = { /*extern struct cmd_set sam_commands[];*/ -extern struct cmd_set sam_commands[]; +extern struct cmd_set sam_general_commands[]; +extern struct cmd_set sam_domain_commands[]; +extern struct cmd_set sam_account_commands[]; +extern struct cmd_set sam_group_commands[]; static struct cmd_set *samtest_command_list[] = { samtest_commands, - sam_commands, + sam_general_commands, + sam_domain_commands, + sam_account_commands, + sam_group_commands, NULL }; -- cgit From 2cd64003e3b127ca5a204b801155fcb4a7447a48 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 24 Sep 2002 20:18:39 +0000 Subject: - Don't put pointer to sam_domain_handle in sam_methods but single domainsid and domainname - Allocate sam_methods, set domain_sid, domain_name and backend_name in make_sam_methods_backend_entry instead of in the backend - Remove sam_context and domain_sid pointers from the sam_init_function - we don't need those arguments anymore since they're available in sam_methods as well (This used to be commit 50d2527eed0eb26c16f2f7e28badbf08d771380e) --- source3/torture/cmd_sam.c | 102 ++++++++++++++++++++++++---------------------- source3/torture/samtest.c | 22 +++++----- source3/torture/samtest.h | 9 +++- 3 files changed, 74 insertions(+), 59 deletions(-) (limited to 'source3/torture') diff --git a/source3/torture/cmd_sam.c b/source3/torture/cmd_sam.c index a2835ed69a..2b4c21e501 100644 --- a/source3/torture/cmd_sam.c +++ b/source3/torture/cmd_sam.c @@ -22,27 +22,7 @@ #include "includes.h" #include "samtest.h" -#if 0 -static struct cmd_popt_user_opts [] = { - { NULL, 0, POPT_ARG_CALLBACK, cmd_parse_user_opts }, - {"username", 'u', POPT_ARG_STRING, NULL, 1, "Username to use"}, -}; - -static void cmd_parse_user_opts(poptContext con, - enum poptCallbackReason reason, - const struct poptOption *opt, - const char *arg, const void *data) -{ - SAM_ACCOUNT_HANDLE *account = (SAM_ACCOUNT_HANDLE *)data; - switch(opt->val) { - case 'u': - sam_set_account_username(account, arg); - break; - } -} -#endif - -static NTSTATUS cmd_load_module(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_load_module(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { char *plugin_arg[2]; NTSTATUS status; @@ -54,132 +34,158 @@ static NTSTATUS cmd_load_module(struct sam_context *c, TALLOC_CTX *mem_ctx, int asprintf(&plugin_arg[0], "plugin:%s", argv[1]); plugin_arg[1] = NULL; - if(!NT_STATUS_IS_OK(status = make_sam_context_list(&c, plugin_arg))) - { + if(!NT_STATUS_IS_OK(status = make_sam_context_list(&st->context, plugin_arg))) { + free(plugin_arg[0]); return status; } + + free(plugin_arg[0]); + printf("load: ok\n"); return NT_STATUS_OK; } -static NTSTATUS cmd_get_sec_desc(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_get_sec_desc(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_set_sec_desc(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_set_sec_desc(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_lookup_sid(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_lookup_sid(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { - return NT_STATUS_NOT_IMPLEMENTED; + char *name; + uint32 type; + NTSTATUS status; + DOM_SID sid; + if(argc != 2) { + printf("Usage: lookup_sid \n"); + return NT_STATUS_INVALID_PARAMETER; + } + + if (!string_to_sid(&sid, argv[1])){ + printf("Unparseable SID specified!\n"); + return NT_STATUS_INVALID_PARAMETER; + } + + if(!NT_STATUS_IS_OK(status = context_sam_lookup_sid(st->context, st->token, &sid, &name, &type))) { + printf("context_sam_lookup_sid failed!\n"); + return status; + } + + return NT_STATUS_OK; } -static NTSTATUS cmd_lookup_name(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_lookup_name(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { + if(argc != 2) { + printf("Usage: lookup_name \n"); + return NT_STATUS_INVALID_PARAMETER; + } return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_lookup_account(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_lookup_account(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_lookup_group(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_lookup_group(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_update_domain(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_update_domain(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_show_domain(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_show_domain(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_create_account(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_create_account(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_update_account(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_update_account(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_delete_account(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_delete_account(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_enum_accounts(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_enum_accounts(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_lookup_account_sid(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_lookup_account_sid(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_lookup_account_name(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_lookup_account_name(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_create_group(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_create_group(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_update_group(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_update_group(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_delete_group(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_delete_group(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_enum_groups(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_enum_groups(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_lookup_group_sid(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_lookup_group_sid(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_lookup_group_name(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_lookup_group_name(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_group_add_member(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_group_add_member(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_group_del_member(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_group_del_member(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_group_enum(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_group_enum(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } -static NTSTATUS cmd_get_sid_groups(struct sam_context *c, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_get_sid_groups(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; } diff --git a/source3/torture/samtest.c b/source3/torture/samtest.c index 0275e0f002..e68ff5a0bf 100644 --- a/source3/torture/samtest.c +++ b/source3/torture/samtest.c @@ -54,7 +54,7 @@ static char* next_command (char** cmdstr) } /* Display help on commands */ -static NTSTATUS cmd_help(struct sam_context *sam, TALLOC_CTX *mem_ctx, +static NTSTATUS cmd_help(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { struct cmd_list *tmp; @@ -112,7 +112,7 @@ static NTSTATUS cmd_help(struct sam_context *sam, TALLOC_CTX *mem_ctx, } /* Change the debug level */ -static NTSTATUS cmd_debuglevel(struct sam_context *sam, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_debuglevel(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { if (argc > 2) { printf("Usage: %s [debuglevel]\n", argv[0]); @@ -128,7 +128,7 @@ static NTSTATUS cmd_debuglevel(struct sam_context *sam, TALLOC_CTX *mem_ctx, int return NT_STATUS_OK; } -static NTSTATUS cmd_quit(struct sam_context *sam, TALLOC_CTX *mem_ctx, int argc, char **argv) +static NTSTATUS cmd_quit(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { /* Cleanup */ talloc_destroy(mem_ctx); @@ -185,7 +185,7 @@ static void add_command_set(struct cmd_set *cmd_set) DLIST_ADD(cmd_list, entry); } -static NTSTATUS do_cmd(struct sam_context *sam, struct cmd_set *cmd_entry, char *cmd) +static NTSTATUS do_cmd(struct samtest_state *st, struct cmd_set *cmd_entry, char *cmd) { char *p = cmd, **argv = NULL; NTSTATUS result = NT_STATUS_UNSUCCESSFUL; @@ -237,7 +237,7 @@ static NTSTATUS do_cmd(struct sam_context *sam, struct cmd_set *cmd_entry, char } /* Run command */ - result = cmd_entry->fn(sam, mem_ctx, argc, argv); + result = cmd_entry->fn(st, mem_ctx, argc, argv); } else { fprintf (stderr, "Invalid command\n"); @@ -259,7 +259,7 @@ static NTSTATUS do_cmd(struct sam_context *sam, struct cmd_set *cmd_entry, char } /* Process a command entered at the prompt or as part of -c */ -static NTSTATUS process_cmd(struct sam_context *sam, char *cmd) +static NTSTATUS process_cmd(struct samtest_state *st, char *cmd) { struct cmd_list *temp_list; BOOL found = False; @@ -288,7 +288,7 @@ static NTSTATUS process_cmd(struct sam_context *sam, char *cmd) while(temp_set->name) { if (strequal(buf, temp_set->name)) { found = True; - result = do_cmd(sam, temp_set, cmd); + result = do_cmd(st, temp_set, cmd); goto done; } @@ -339,7 +339,7 @@ int main(int argc, char *argv[]) pstring logfile; struct cmd_set **cmd_set; extern BOOL AllowDebugChange; - static struct sam_context sam; + struct samtest_state st; /* make sure the vars that get altered (4th field) are in @@ -353,6 +353,8 @@ int main(int argc, char *argv[]) { 0, 0, 0, 0} }; + ZERO_STRUCT(st); + setlinebuf(stdout); DEBUGLEVEL = 1; @@ -397,7 +399,7 @@ int main(int argc, char *argv[]) char *p = cmdstr; while((cmd=next_command(&p)) != NULL) { - process_cmd(&sam, cmd); + process_cmd(&st, cmd); } return 0; @@ -417,7 +419,7 @@ int main(int argc, char *argv[]) break; if (line[0] != '\n') - process_cmd(&sam, line); + process_cmd(&st, line); } return 0; diff --git a/source3/torture/samtest.h b/source3/torture/samtest.h index 2a8516cfc3..a136ab191e 100644 --- a/source3/torture/samtest.h +++ b/source3/torture/samtest.h @@ -22,10 +22,17 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ +struct samtest_state { + SAM_CONTEXT *context; + NT_USER_TOKEN *token; +}; + struct cmd_set { char *name; - NTSTATUS (*fn)(struct sam_context *sam, TALLOC_CTX *mem_ctx, int argc, + NTSTATUS (*fn)(struct samtest_state *sam, TALLOC_CTX *mem_ctx, int argc, char **argv); char *description; char *usage; }; + + -- cgit From 529848e988fb28b54303408f31e21051ae0b94a6 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 24 Sep 2002 21:18:22 +0000 Subject: Fix bug in get_methods_by_name Fix bug in enum_domains Add samtest commands: - lookup_sid - lookup_name - enum_domains - lookup_domain (This used to be commit 0c01219850e5d9b77b3b2c0b4b87aa3c82e3292b) --- source3/torture/cmd_sam.c | 80 +++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 71 insertions(+), 9 deletions(-) (limited to 'source3/torture') diff --git a/source3/torture/cmd_sam.c b/source3/torture/cmd_sam.c index 2b4c21e501..3ebf91434e 100644 --- a/source3/torture/cmd_sam.c +++ b/source3/torture/cmd_sam.c @@ -26,12 +26,16 @@ static NTSTATUS cmd_load_module(struct samtest_state *st, TALLOC_CTX *mem_ctx, i { char *plugin_arg[2]; NTSTATUS status; - if (argc != 2) { - printf("Usage: load \n"); + if (argc != 2 && argc != 3) { + printf("Usage: load [domain-sid]\n"); return NT_STATUS_OK; } - asprintf(&plugin_arg[0], "plugin:%s", argv[1]); + if (argc == 3) + asprintf(&plugin_arg[0], "%s|plugin:%s", argv[2], argv[1]); + else + asprintf(&plugin_arg[0], "plugin:%s", argv[1]); + plugin_arg[1] = NULL; if(!NT_STATUS_IS_OK(status = make_sam_context_list(&st->context, plugin_arg))) { @@ -61,7 +65,7 @@ static NTSTATUS cmd_lookup_sid(struct samtest_state *st, TALLOC_CTX *mem_ctx, in uint32 type; NTSTATUS status; DOM_SID sid; - if(argc != 2) { + if (argc != 2) { printf("Usage: lookup_sid \n"); return NT_STATUS_INVALID_PARAMETER; } @@ -71,21 +75,36 @@ static NTSTATUS cmd_lookup_sid(struct samtest_state *st, TALLOC_CTX *mem_ctx, in return NT_STATUS_INVALID_PARAMETER; } - if(!NT_STATUS_IS_OK(status = context_sam_lookup_sid(st->context, st->token, &sid, &name, &type))) { + if (!NT_STATUS_IS_OK(status = context_sam_lookup_sid(st->context, st->token, &sid, &name, &type))) { printf("context_sam_lookup_sid failed!\n"); return status; } + printf("Name: %s\n", name); + printf("Type: %d\n", type); /* FIXME: What kind of an integer is type ? */ + return NT_STATUS_OK; } static NTSTATUS cmd_lookup_name(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { - if(argc != 2) { - printf("Usage: lookup_name \n"); + DOM_SID *sid; + uint32 type; + NTSTATUS status; + if (argc != 3) { + printf("Usage: lookup_name \n"); return NT_STATUS_INVALID_PARAMETER; } - return NT_STATUS_NOT_IMPLEMENTED; + + if (!NT_STATUS_IS_OK(status = context_sam_lookup_name(st->context, st->token, argv[1], argv[2], &sid, &type))) { + printf("context_sam_lookup_name failed!\n"); + return status; + } + + printf("SID: %s\n", sid_string_static(sid)); + printf("Type: %d\n", type); + + return NT_STATUS_OK; } static NTSTATUS cmd_lookup_account(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) @@ -98,6 +117,47 @@ static NTSTATUS cmd_lookup_group(struct samtest_state *st, TALLOC_CTX *mem_ctx, return NT_STATUS_NOT_IMPLEMENTED; } +static NTSTATUS cmd_lookup_domain(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + DOM_SID *sid; + NTSTATUS status; + if (argc != 2) { + printf("Usage: lookup_domain \n"); + return NT_STATUS_INVALID_PARAMETER; + } + + if (!NT_STATUS_IS_OK(status = context_sam_lookup_domain(st->context, st->token, argv[1], &sid))) { + printf("context_sam_lookup_name failed!\n"); + return status; + } + + printf("SID: %s\n", sid_string_static(sid)); + + return NT_STATUS_OK; +} + +static NTSTATUS cmd_enum_domains(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) +{ + int32 domain_count, i; + DOM_SID *domain_sids; + char **domain_names; + NTSTATUS status; + + if (!NT_STATUS_IS_OK(status = context_sam_enum_domains(st->context, st->token, &domain_count, &domain_sids, &domain_names))) { + printf("context_sam_enum_domains failed!\n"); + return status; + } + + for (i = 0; i < domain_count; i++) { + printf("%s %s\n", domain_names[i], sid_string_static(&domain_sids[i])); + } + + SAFE_FREE(domain_sids); + SAFE_FREE(domain_names); + + return NT_STATUS_OK; +} + static NTSTATUS cmd_update_domain(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) { return NT_STATUS_NOT_IMPLEMENTED; @@ -194,7 +254,7 @@ struct cmd_set sam_general_commands[] = { { "General SAM Commands" }, - { "load", cmd_load_module, "Load a module", "load " }, + { "load", cmd_load_module, "Load a module", "load [domain-sid]" }, { "get_sec_desc", cmd_get_sec_desc, "Get security descriptor info", "get_sec_desc " }, { "set_sec_desc", cmd_set_sec_desc, "Set security descriptor info", "set_sec_desc " }, { "lookup_sid", cmd_lookup_sid, "Lookup type of specified SID", "lookup_sid " }, @@ -206,6 +266,8 @@ struct cmd_set sam_domain_commands[] = { { "Domain Commands" }, { "update_domain", cmd_update_domain, "Update domain information", "update_domain [domain-options] domain-name | domain-sid" }, { "show_domain", cmd_show_domain, "Show domain information", "show_domain domain-sid | domain-name" }, + { "enum_domains", cmd_enum_domains, "Enumerate all domains", "enum_domains " }, + { "lookup_domain", cmd_lookup_domain, "Lookup a domain by name", "lookup_domain domain-name" }, { NULL } }; -- cgit From efcf29fde63feb31625021d12da59db31c79b454 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 25 Sep 2002 10:17:08 +0000 Subject: samtest should load smb.conf by default add command-line option to samtest to specify alternate config file - use /dev/null to don't load any config file.. add 'conf' command to load specified config file (This used to be commit 237883d1e68e99a3ea3df9b6e182c70cb31b2523) --- source3/torture/samtest.c | 27 ++++++++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) (limited to 'source3/torture') diff --git a/source3/torture/samtest.c b/source3/torture/samtest.c index e68ff5a0bf..5503887e62 100644 --- a/source3/torture/samtest.c +++ b/source3/torture/samtest.c @@ -53,6 +53,24 @@ static char* next_command (char** cmdstr) return command; } +/* Load specified configuration file */ +static NTSTATUS cmd_conf(struct samtest_state *sam, TALLOC_CTX *mem_ctx, + int argc, char **argv) +{ + if (argc != 2) { + printf("Usage: %s \n", argv[0]); + return NT_STATUS_OK; + } + + if (!lp_load(argv[1], False, True, False)) { + printf("Error loading \"%s\"\n", argv[1]); + return NT_STATUS_OK; + } + + printf("\"%s\" successfully loaded\n", argv[1]); + return NT_STATUS_OK; +} + /* Display help on commands */ static NTSTATUS cmd_help(struct samtest_state *st, TALLOC_CTX *mem_ctx, int argc, char **argv) @@ -143,6 +161,7 @@ static struct cmd_set samtest_commands[] = { { "help", cmd_help, "Get help on commands", "" }, { "?", cmd_help, "Get help on commands", "" }, + { "conf", cmd_conf, "Load smb configuration file", "conf " }, { "debuglevel", cmd_debuglevel, "Set debug level", "" }, { "exit", cmd_quit, "Exit program", "" }, { "quit", cmd_quit, "Exit program", "" }, @@ -336,6 +355,7 @@ int main(int argc, char *argv[]) int opt; static char *cmdstr = ""; static char *opt_logfile=NULL; + static char *config_file = dyn_CONFIGFILE; pstring logfile; struct cmd_set **cmd_set; extern BOOL AllowDebugChange; @@ -348,8 +368,9 @@ int main(int argc, char *argv[]) struct poptOption long_options[] = { POPT_AUTOHELP { NULL, 0, POPT_ARG_INCLUDE_TABLE, popt_common_debug }, - {"command", 'c', POPT_ARG_STRING, &cmdstr, 'c', "Execute semicolon seperated cmds"}, + {"command", 'e', POPT_ARG_STRING, &cmdstr, 'e', "Execute semicolon seperated cmds"}, {"logfile", 'l', POPT_ARG_STRING, &opt_logfile, 'l', "Logfile to use instead of stdout"}, + {"configfile", 'c', POPT_ARG_STRING, &config_file, 0,"use different configuration file",NULL}, { 0, 0, 0, 0} }; @@ -374,6 +395,10 @@ int main(int argc, char *argv[]) } } + if (!lp_load(config_file,True,False,False)) { + fprintf(stderr, "Can't load %s - run testparm to debug it\n", config_file); + exit(1); + } poptFreeContext(pc); -- cgit From 8df2ac63f067e7d11959497a09ff4dd00e8087f7 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 25 Sep 2002 11:19:48 +0000 Subject: Fix debuglevel command-line argument (This used to be commit 779aea57450db83fa7870e8a35db55d475682519) --- source3/torture/samtest.c | 1 - 1 file changed, 1 deletion(-) (limited to 'source3/torture') diff --git a/source3/torture/samtest.c b/source3/torture/samtest.c index 5503887e62..2bbf01a6be 100644 --- a/source3/torture/samtest.c +++ b/source3/torture/samtest.c @@ -379,7 +379,6 @@ int main(int argc, char *argv[]) setlinebuf(stdout); DEBUGLEVEL = 1; - AllowDebugChange = False; pc = poptGetContext("samtest", argc, (const char **) argv, long_options, 0); -- cgit From 284dd066a8b848d8c2d93089ed9991647b7db486 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 25 Sep 2002 12:59:47 +0000 Subject: remove extern for AllowDebugChange since we don't use it (This used to be commit 70d9b71ceaeba95712fa61e601376ff5cc8e7714) --- source3/torture/samtest.c | 1 - 1 file changed, 1 deletion(-) (limited to 'source3/torture') diff --git a/source3/torture/samtest.c b/source3/torture/samtest.c index 2bbf01a6be..b5f7ed9f76 100644 --- a/source3/torture/samtest.c +++ b/source3/torture/samtest.c @@ -358,7 +358,6 @@ int main(int argc, char *argv[]) static char *config_file = dyn_CONFIGFILE; pstring logfile; struct cmd_set **cmd_set; - extern BOOL AllowDebugChange; struct samtest_state st; -- cgit