Unix SMB/CIFS implementation.
SMB torture tester
Copyright (C) Andrew Tridgell 1997-1998
-
+ Copyright (C) Jeremy Allison 2009
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
-#include "wbc_async.h"
+#include "nsswitch/libwbclient/wbc_async.h"
+#include "torture/proto.h"
extern char *optarg;
extern int optind;
static fstring multishare_conn_fname;
static bool use_multishare_conn = False;
static bool do_encrypt;
+static const char *local_path = NULL;
bool torture_showall = False;
static double create_procs(bool (*fn)(int), bool *result);
-static struct timeval tp1,tp2;
-
-
-void start_timer(void)
-{
- GetTimeOfDay(&tp1);
-}
-
-double end_timer(void)
-{
- GetTimeOfDay(&tp2);
- return((tp2.tv_sec - tp1.tv_sec) +
- (tp2.tv_usec - tp1.tv_usec)*1.0e-6);
-}
-
-
/* return a pointer to a anonymous shared memory segment of size "size"
which will persist across fork() but will disappear when all processes
exit
int shmid;
void *ret;
+#ifdef __QNXNTO__
+ shmid = shm_open("private", O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
+ if (shmid == -1) {
+ printf("can't get shared memory\n");
+ exit(1);
+ }
+ shm_unlink("private");
+ if (ftruncate(shmid, size) == -1) {
+ printf("can't set shared memory size\n");
+ exit(1);
+ }
+ ret = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, shmid, 0);
+ if (ret == MAP_FAILED) {
+ printf("can't map shared memory\n");
+ exit(1);
+ }
+#else
shmid = shmget(IPC_PRIVATE, size, S_IRUSR | S_IWUSR);
if (shmid == -1) {
printf("can't get shared memory\n");
See Stevens "advanced programming in unix env" for details
*/
shmctl(shmid, IPC_RMID, 0);
-
+#endif
+
return ret;
}
return false;
}
- if (!cli_unix_extensions_version(c, &major, &minor, &caplow, &caphigh)) {
+ status = cli_unix_extensions_version(c, &major, &minor, &caplow,
+ &caphigh);
+ if (!NT_STATUS_IS_OK(status)) {
d_printf("Encryption required and "
"can't get UNIX CIFS extensions "
- "version from server.\n");
+ "version from server: %s\n", nt_errstr(status));
return false;
}
*p = '\0';
return p + 1;
}
-
+
/* No separator. */
return NULL;
}
if (use_kerberos)
flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
+ if (use_oplocks)
+ flags |= CLI_FULL_CONNECTION_OPLOCKS;
+ if (use_level_II_oplocks)
+ flags |= CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS;
status = cli_full_connection(c, myname,
hostname, NULL, port_to_use,
return False;
}
- if (use_oplocks) (*c)->use_oplocks = True;
- if (use_level_II_oplocks) (*c)->use_level_II_oplocks = True;
(*c)->timeout = 120000; /* set a really long timeout (2 minutes) */
if (do_encrypt) {
{
const char *lockfname = "\\torture.lck";
fstring fname;
- int fnum;
- int fnum2;
+ uint16_t fnum;
+ uint16_t fnum2;
pid_t pid2, pid = getpid();
int i, j;
char buf[1024];
bool correct = True;
+ NTSTATUS status;
memset(buf, '\0', sizeof(buf));
- fnum2 = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
- DENY_NONE);
- if (fnum2 == -1)
- fnum2 = cli_open(c, lockfname, O_RDWR, DENY_NONE);
- if (fnum2 == -1) {
+ status = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
+ DENY_NONE, &fnum2);
+ if (!NT_STATUS_IS_OK(status)) {
+ status = cli_open(c, lockfname, O_RDWR, DENY_NONE, &fnum2);
+ }
+ if (!NT_STATUS_IS_OK(status)) {
printf("open of %s failed (%s)\n", lockfname, cli_errstr(c));
return False;
}
-
for (i=0;i<torture_numops;i++) {
unsigned n = (unsigned)sys_random()%10;
if (i % 10 == 0) {
return False;
}
- fnum = cli_open(c, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_ALL);
- if (fnum == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(c, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_ALL, &fnum))) {
printf("open failed (%s)\n", cli_errstr(c));
correct = False;
break;
correct = False;
}
- if (!cli_close(c, fnum)) {
+ if (!NT_STATUS_IS_OK(cli_close(c, fnum))) {
printf("close failed (%s)\n", cli_errstr(c));
correct = False;
}
- if (!cli_unlink(c, fname)) {
+ if (!NT_STATUS_IS_OK(cli_unlink(c, fname, aSYSTEM | aHIDDEN))) {
printf("unlink failed (%s)\n", cli_errstr(c));
correct = False;
}
- if (!cli_unlock(c, fnum2, n*sizeof(int), sizeof(int))) {
+ if (!NT_STATUS_IS_OK(cli_unlock(c, fnum2, n*sizeof(int), sizeof(int)))) {
printf("unlock failed (%s)\n", cli_errstr(c));
correct = False;
}
}
cli_close(c, fnum2);
- cli_unlink(c, lockfname);
+ cli_unlink(c, lockfname, aSYSTEM | aHIDDEN);
printf("%d\n", i);
cli_sockopt(cli, sockops);
ret = rw_torture(cli);
-
+
if (!torture_close_connection(cli)) {
ret = False;
}
static bool rw_torture3(struct cli_state *c, char *lockfname)
{
- int fnum = -1;
+ uint16_t fnum = (uint16_t)-1;
unsigned int i = 0;
char buf[131072];
char buf_rd[131072];
unsigned countprev = 0;
ssize_t sent = 0;
bool correct = True;
+ NTSTATUS status;
srandom(1);
for (i = 0; i < sizeof(buf); i += sizeof(uint32))
if (procnum == 0)
{
- fnum = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
- DENY_NONE);
- if (fnum == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL,
+ DENY_NONE, &fnum))) {
printf("first open read/write of %s failed (%s)\n",
lockfname, cli_errstr(c));
return False;
}
else
{
- for (i = 0; i < 500 && fnum == -1; i++)
+ for (i = 0; i < 500 && fnum == (uint16_t)-1; i++)
{
- fnum = cli_open(c, lockfname, O_RDONLY,
- DENY_NONE);
+ status = cli_open(c, lockfname, O_RDONLY,
+ DENY_NONE, &fnum);
+ if (!NT_STATUS_IS_OK(status)) {
+ break;
+ }
smb_msleep(10);
}
- if (fnum == -1) {
+ if (!NT_STATUS_IS_OK(status)) {
printf("second open read-only of %s failed (%s)\n",
lockfname, cli_errstr(c));
return False;
}
- if (!cli_close(c, fnum)) {
+ if (!NT_STATUS_IS_OK(cli_close(c, fnum))) {
printf("close failed (%s)\n", cli_errstr(c));
correct = False;
}
static bool rw_torture2(struct cli_state *c1, struct cli_state *c2)
{
const char *lockfname = "\\torture2.lck";
- int fnum1;
- int fnum2;
+ uint16_t fnum1;
+ uint16_t fnum2;
int i;
char buf[131072];
char buf_rd[131072];
bool correct = True;
ssize_t bytes_read;
- if (!cli_unlink(c1, lockfname)) {
+ if (!NT_STATUS_IS_OK(cli_unlink(c1, lockfname, aSYSTEM | aHIDDEN))) {
printf("unlink failed (%s) (normal, this file should not exist)\n", cli_errstr(c1));
}
- fnum1 = cli_open(c1, lockfname, O_RDWR | O_CREAT | O_EXCL,
- DENY_NONE);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(c1, lockfname, O_RDWR | O_CREAT | O_EXCL,
+ DENY_NONE, &fnum1))) {
printf("first open read/write of %s failed (%s)\n",
lockfname, cli_errstr(c1));
return False;
}
- fnum2 = cli_open(c2, lockfname, O_RDONLY,
- DENY_NONE);
- if (fnum2 == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(c2, lockfname, O_RDONLY,
+ DENY_NONE, &fnum2))) {
printf("second open read-only of %s failed (%s)\n",
lockfname, cli_errstr(c2));
cli_close(c1, fnum1);
}
}
- if (!cli_close(c2, fnum2)) {
+ if (!NT_STATUS_IS_OK(cli_close(c2, fnum2))) {
printf("close failed (%s)\n", cli_errstr(c2));
correct = False;
}
- if (!cli_close(c1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(c1, fnum1))) {
printf("close failed (%s)\n", cli_errstr(c1));
correct = False;
}
- if (!cli_unlink(c1, lockfname)) {
+ if (!NT_STATUS_IS_OK(cli_unlink(c1, lockfname, aSYSTEM | aHIDDEN))) {
printf("unlink failed (%s)\n", cli_errstr(c1));
correct = False;
}
static bool run_readwritetest(int dummy)
{
- static struct cli_state *cli1, *cli2;
+ struct cli_state *cli1, *cli2;
bool test1, test2 = False;
if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
if (!torture_close_connection(cli)) {
test = False;
}
-
+
return test;
}
static bool run_readwritelarge(int dummy)
{
static struct cli_state *cli1;
- int fnum1;
+ uint16_t fnum1;
const char *lockfname = "\\large.dat";
SMB_OFF_T fsize;
char buf[126*1024];
bool correct = True;
-
+
if (!torture_open_connection(&cli1, 0)) {
return False;
}
cli_sockopt(cli1, sockops);
memset(buf,'\0',sizeof(buf));
-
+
cli1->max_xmit = 128*1024;
-
+
printf("starting readwritelarge\n");
-
- cli_unlink(cli1, lockfname);
- fnum1 = cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE);
- if (fnum1 == -1) {
+ cli_unlink(cli1, lockfname, aSYSTEM | aHIDDEN);
+
+ if (!NT_STATUS_IS_OK(cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE, &fnum1))) {
printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
return False;
}
-
+
cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf));
if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
correct = False;
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("close failed (%s)\n", cli_errstr(cli1));
correct = False;
}
- if (!cli_unlink(cli1, lockfname)) {
+ if (!NT_STATUS_IS_OK(cli_unlink(cli1, lockfname, aSYSTEM | aHIDDEN))) {
printf("unlink failed (%s)\n", cli_errstr(cli1));
correct = False;
}
- fnum1 = cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE, &fnum1))) {
printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
return False;
}
-
+
cli1->max_xmit = 4*1024;
-
+
cli_smbwrite(cli1, fnum1, buf, 0, sizeof(buf));
-
+
if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
correct = False;
printf("readwritelarge test 3 (truncate test) succeeded (size = %x)\n", fsize);
#endif
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("close failed (%s)\n", cli_errstr(cli1));
correct = False;
}
-
+
if (!torture_close_connection(cli1)) {
correct = False;
}
if (!torture_close_connection(cli)) {
correct = False;
}
-
+
return correct;
}
{
struct cli_state *cli1, *cli2;
const char *fname = "\\lockt1.lck";
- int fnum1, fnum2, fnum3;
+ uint16_t fnum1, fnum2, fnum3;
time_t t1, t2;
unsigned lock_timeout;
printf("starting locktest1\n");
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
- fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
- fnum2 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
- if (fnum2 == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum2))) {
printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
- fnum3 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
- if (fnum3 == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum3))) {
printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli2));
return False;
}
printf("server slept for %u seconds for a %u second timeout\n",
(unsigned int)(t2-t1), lock_timeout);
- if (!cli_close(cli1, fnum2)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
printf("close1 failed (%s)\n", cli_errstr(cli1));
return False;
}
NT_STATUS_FILE_LOCK_CONFLICT)) return False;
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("close2 failed (%s)\n", cli_errstr(cli1));
return False;
}
- if (!cli_close(cli2, fnum3)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli2, fnum3))) {
printf("close3 failed (%s)\n", cli_errstr(cli2));
return False;
}
- if (!cli_unlink(cli1, fname)) {
+ if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
printf("unlink failed (%s)\n", cli_errstr(cli1));
return False;
}
{
static struct cli_state *cli;
const char *fname = "\\tcontest.tmp";
- int fnum1;
+ uint16 fnum1;
uint16 cnum1, cnum2, cnum3;
uint16 vuid1, vuid2;
char buf[4];
printf("starting tcontest\n");
- cli_unlink(cli, fname);
+ cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
- fnum1 = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
return False;
}
cli->cnum = cnum1;
cli->vuid = vuid1;
- if (!cli_close(cli, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli, fnum1))) {
printf("close failed (%s)\n", cli_errstr(cli));
return False;
}
if (!tcon_devtest(cli1, "IPC$", "IPC", "IPC", NT_STATUS_OK))
ret = False;
-
+
if (!tcon_devtest(cli1, "IPC$", "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
ret = False;
if (!tcon_devtest(cli1, share, "IPC", NULL, NT_STATUS_BAD_DEVICE_TYPE))
ret = False;
-
+
if (!tcon_devtest(cli1, share, "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE))
ret = False;
{
static struct cli_state *cli;
const char *fname = "\\lockt2.lck";
- int fnum1, fnum2, fnum3;
+ uint16_t fnum1, fnum2, fnum3;
bool correct = True;
if (!torture_open_connection(&cli, 0)) {
printf("starting locktest2\n");
- cli_unlink(cli, fname);
+ cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
cli_setpid(cli, 1);
- fnum1 = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
return False;
}
- fnum2 = cli_open(cli, fname, O_RDWR, DENY_NONE);
- if (fnum2 == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum2))) {
printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli));
return False;
}
cli_setpid(cli, 2);
- fnum3 = cli_open(cli, fname, O_RDWR, DENY_NONE);
- if (fnum3 == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum3))) {
printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli));
return False;
}
printf("lock at 100 failed (%s)\n", cli_errstr(cli));
}
cli_setpid(cli, 2);
- if (cli_unlock(cli, fnum1, 100, 4)) {
+ if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 100, 4))) {
printf("unlock at 100 succeeded! This is a locking bug\n");
correct = False;
}
- if (cli_unlock(cli, fnum1, 0, 4)) {
+ if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 0, 4))) {
printf("unlock1 succeeded! This is a locking bug\n");
correct = False;
} else {
NT_STATUS_RANGE_NOT_LOCKED)) return False;
}
- if (cli_unlock(cli, fnum1, 0, 8)) {
+ if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 0, 8))) {
printf("unlock2 succeeded! This is a locking bug\n");
correct = False;
} else {
cli_setpid(cli, 1);
- if (!cli_close(cli, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli, fnum1))) {
printf("close1 failed (%s)\n", cli_errstr(cli));
return False;
}
- if (!cli_close(cli, fnum2)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli, fnum2))) {
printf("close2 failed (%s)\n", cli_errstr(cli));
return False;
}
- if (!cli_close(cli, fnum3)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli, fnum3))) {
printf("close3 failed (%s)\n", cli_errstr(cli));
return False;
}
{
static struct cli_state *cli1, *cli2;
const char *fname = "\\lockt3.lck";
- int fnum1, fnum2, i;
+ uint16_t fnum1, fnum2;
+ int i;
uint32 offset;
bool correct = True;
printf("starting locktest3\n");
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
- fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
- fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
- if (fnum2 == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2))) {
printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli2));
return False;
}
for (offset=i=0;i<torture_numops;i++) {
NEXT_OFFSET;
- if (!cli_unlock(cli1, fnum1, offset-1, 1)) {
+ if (!NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, offset-1, 1))) {
printf("unlock1 %d failed (%s)\n",
i,
cli_errstr(cli1));
return False;
}
- if (!cli_unlock(cli2, fnum2, offset-2, 1)) {
+ if (!NT_STATUS_IS_OK(cli_unlock(cli2, fnum2, offset-2, 1))) {
printf("unlock2 %d failed (%s)\n",
i,
cli_errstr(cli1));
}
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("close1 failed (%s)\n", cli_errstr(cli1));
return False;
}
- if (!cli_close(cli2, fnum2)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
printf("close2 failed (%s)\n", cli_errstr(cli2));
return False;
}
- if (!cli_unlink(cli1, fname)) {
+ if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
printf("unlink failed (%s)\n", cli_errstr(cli1));
return False;
}
if (!torture_close_connection(cli1)) {
correct = False;
}
-
+
if (!torture_close_connection(cli2)) {
correct = False;
}
{
static struct cli_state *cli1, *cli2;
const char *fname = "\\lockt4.lck";
- int fnum1, fnum2, f;
+ uint16_t fnum1, fnum2, f;
bool ret;
char buf[1000];
bool correct = True;
printf("starting locktest4\n");
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
- fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
+ cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
+ cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
memset(buf, 0, sizeof(buf));
cli_lock(cli1, fnum1, 2, 4, 0, WRITE_LOCK);
EXPECTED(ret, False);
printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
-
+
ret = cli_lock(cli1, fnum1, 10, 4, 0, READ_LOCK) &&
cli_lock(cli1, fnum1, 12, 4, 0, READ_LOCK);
EXPECTED(ret, True);
cli_lock(cli2, fnum2, 22, 4, 0, WRITE_LOCK);
EXPECTED(ret, False);
printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
-
+
ret = cli_lock(cli1, fnum1, 30, 4, 0, READ_LOCK) &&
cli_lock(cli2, fnum2, 32, 4, 0, READ_LOCK);
EXPECTED(ret, True);
printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
-
+
ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 40, 4, 0, WRITE_LOCK)) &&
(cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 42, 4, 0, WRITE_LOCK));
EXPECTED(ret, False);
printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
-
+
ret = (cli_setpid(cli1, 1), cli_lock(cli1, fnum1, 50, 4, 0, READ_LOCK)) &&
(cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 52, 4, 0, READ_LOCK));
EXPECTED(ret, True);
ret = cli_lock(cli1, fnum1, 110, 4, 0, READ_LOCK) &&
cli_lock(cli1, fnum1, 112, 4, 0, READ_LOCK) &&
- cli_unlock(cli1, fnum1, 110, 6);
+ NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 110, 6));
EXPECTED(ret, False);
printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
ret = cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
- cli_unlock(cli1, fnum1, 140, 4) &&
- cli_unlock(cli1, fnum1, 140, 4);
+ NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4)) &&
+ NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4));
EXPECTED(ret, True);
printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
ret = cli_lock(cli1, fnum1, 150, 4, 0, WRITE_LOCK) &&
cli_lock(cli1, fnum1, 150, 4, 0, READ_LOCK) &&
- cli_unlock(cli1, fnum1, 150, 4) &&
+ NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4)) &&
(cli_read(cli2, fnum2, buf, 150, 4) == 4) &&
!(cli_write(cli2, fnum2, 0, buf, 150, 4) == 4) &&
- cli_unlock(cli1, fnum1, 150, 4);
+ NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4));
EXPECTED(ret, True);
printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
ret = cli_lock(cli1, fnum1, 160, 4, 0, READ_LOCK) &&
- cli_unlock(cli1, fnum1, 160, 4) &&
+ NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 160, 4)) &&
(cli_write(cli2, fnum2, 0, buf, 160, 4) == 4) &&
(cli_read(cli2, fnum2, buf, 160, 4) == 4);
EXPECTED(ret, True);
printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
ret = cli_lock(cli1, fnum1, 170, 4, 0, WRITE_LOCK) &&
- cli_unlock(cli1, fnum1, 170, 4) &&
+ NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 170, 4)) &&
(cli_write(cli2, fnum2, 0, buf, 170, 4) == 4) &&
(cli_read(cli2, fnum2, buf, 170, 4) == 4);
EXPECTED(ret, True);
ret = cli_lock(cli1, fnum1, 190, 4, 0, WRITE_LOCK) &&
cli_lock(cli1, fnum1, 190, 4, 0, READ_LOCK) &&
- cli_unlock(cli1, fnum1, 190, 4) &&
+ NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 190, 4)) &&
!(cli_write(cli2, fnum2, 0, buf, 190, 4) == 4) &&
(cli_read(cli2, fnum2, buf, 190, 4) == 4);
EXPECTED(ret, True);
cli_close(cli1, fnum1);
cli_close(cli2, fnum2);
- fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
- f = cli_open(cli1, fname, O_RDWR, DENY_NONE);
+ cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
+ cli_open(cli1, fname, O_RDWR, DENY_NONE, &f);
ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
cli_lock(cli1, f, 0, 1, 0, READ_LOCK) &&
- cli_close(cli1, fnum1) &&
- ((fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE)) != -1) &&
+ NT_STATUS_IS_OK(cli_close(cli1, fnum1)) &&
+ NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1)) &&
cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
cli_close(cli1, f);
cli_close(cli1, fnum1);
fail:
cli_close(cli1, fnum1);
cli_close(cli2, fnum2);
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
torture_close_connection(cli1);
torture_close_connection(cli2);
{
static struct cli_state *cli1, *cli2;
const char *fname = "\\lockt5.lck";
- int fnum1, fnum2, fnum3;
+ uint16_t fnum1, fnum2, fnum3;
bool ret;
char buf[1000];
bool correct = True;
printf("starting locktest5\n");
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
- fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
- fnum3 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
+ cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
+ cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
+ cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum3);
memset(buf, 0, sizeof(buf));
ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
cli_lock(cli1, fnum3, 0, 1, 0, READ_LOCK);
cli_close(cli1, fnum1);
- fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
+ cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
ret = cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
EXPECTED(ret, True);
printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
cli_close(cli1, fnum1);
- fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
+ cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
cli_unlock(cli1, fnum3, 0, 1);
ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
/* Unlock the first process lock, then check this was the WRITE lock that was
removed. */
- ret = cli_unlock(cli1, fnum1, 0, 4) &&
+ ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
EXPECTED(ret, True);
/* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
- ret = cli_unlock(cli1, fnum1, 1, 1) &&
- cli_unlock(cli1, fnum1, 0, 4) &&
- cli_unlock(cli1, fnum1, 0, 4);
+ ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 1, 1)) &&
+ NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
+ NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
EXPECTED(ret, True);
printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot");
/* Ensure the next unlock fails. */
- ret = cli_unlock(cli1, fnum1, 0, 4);
+ ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
EXPECTED(ret, False);
printf("the same process %s count the lock stack\n", !ret?"can":"cannot");
fail:
cli_close(cli1, fnum1);
cli_close(cli2, fnum2);
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
if (!torture_close_connection(cli1)) {
correct = False;
}
}
printf("finished locktest5\n");
-
+
return correct;
}
static struct cli_state *cli;
const char *fname[1] = { "\\lock6.txt" };
int i;
- int fnum;
+ uint16_t fnum;
NTSTATUS status;
if (!torture_open_connection(&cli, 0)) {
for (i=0;i<1;i++) {
printf("Testing %s\n", fname[i]);
- cli_unlink(cli, fname[i]);
+ cli_unlink(cli, fname[i], aSYSTEM | aHIDDEN);
- fnum = cli_open(cli, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
+ cli_open(cli, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE);
cli_close(cli, fnum);
printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
- fnum = cli_open(cli, fname[i], O_RDWR, DENY_NONE);
+ cli_open(cli, fname[i], O_RDWR, DENY_NONE, &fnum);
status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK);
cli_close(cli, fnum);
printf("CANCEL_LOCK gave %s\n", nt_errstr(status));
- cli_unlink(cli, fname[i]);
+ cli_unlink(cli, fname[i], aSYSTEM | aHIDDEN);
}
torture_close_connection(cli);
{
struct cli_state *cli1;
const char *fname = "\\lockt7.lck";
- int fnum1;
+ uint16_t fnum1;
char buf[200];
bool correct = False;
printf("starting locktest7\n");
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
- fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
+ cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
memset(buf, 0, sizeof(buf));
fail:
cli_close(cli1, fnum1);
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
torture_close_connection(cli1);
printf("finished locktest7\n");
return correct;
}
+/*
+ * This demonstrates a problem with our use of GPFS share modes: A file
+ * descriptor sitting in the pending close queue holding a GPFS share mode
+ * blocks opening a file another time. Happens with Word 2007 temp files.
+ * With "posix locking = yes" and "gpfs:sharemodes = yes" enabled, the third
+ * open is denied with NT_STATUS_SHARING_VIOLATION.
+ */
+
+static bool run_locktest8(int dummy)
+{
+ struct cli_state *cli1;
+ const char *fname = "\\lockt8.lck";
+ uint16_t fnum1, fnum2;
+ char buf[200];
+ bool correct = False;
+ NTSTATUS status;
+
+ if (!torture_open_connection(&cli1, 0)) {
+ return False;
+ }
+
+ cli_sockopt(cli1, sockops);
+
+ printf("starting locktest8\n");
+
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
+
+ status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_WRITE,
+ &fnum1);
+ if (!NT_STATUS_IS_OK(status)) {
+ d_fprintf(stderr, "cli_open returned %s\n", cli_errstr(cli1));
+ return false;
+ }
+
+ memset(buf, 0, sizeof(buf));
+
+ status = cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum2);
+ if (!NT_STATUS_IS_OK(status)) {
+ d_fprintf(stderr, "cli_open second time returned %s\n",
+ cli_errstr(cli1));
+ goto fail;
+ }
+
+ if (!cli_lock(cli1, fnum2, 1, 1, 0, READ_LOCK)) {
+ printf("Unable to apply read lock on range 1:1, error was "
+ "%s\n", cli_errstr(cli1));
+ goto fail;
+ }
+
+ status = cli_close(cli1, fnum1);
+ if (!NT_STATUS_IS_OK(status)) {
+ d_fprintf(stderr, "cli_close(fnum1) %s\n", cli_errstr(cli1));
+ goto fail;
+ }
+
+ status = cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
+ if (!NT_STATUS_IS_OK(status)) {
+ d_fprintf(stderr, "cli_open third time returned %s\n",
+ cli_errstr(cli1));
+ goto fail;
+ }
+
+ correct = true;
+
+fail:
+ cli_close(cli1, fnum1);
+ cli_close(cli1, fnum2);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
+ torture_close_connection(cli1);
+
+ printf("finished locktest8\n");
+ return correct;
+}
+
+/*
+ * This test is designed to be run in conjunction with
+ * external NFS or POSIX locks taken in the filesystem.
+ * It checks that the smbd server will block until the
+ * lock is released and then acquire it. JRA.
+ */
+
+static bool got_alarm;
+static int alarm_fd;
+
+static void alarm_handler(int dummy)
+{
+ got_alarm = True;
+}
+
+static void alarm_handler_parent(int dummy)
+{
+ close(alarm_fd);
+}
+
+static void do_local_lock(int read_fd, int write_fd)
+{
+ int fd;
+ char c = '\0';
+ struct flock lock;
+ const char *local_pathname = NULL;
+ int ret;
+
+ local_pathname = talloc_asprintf(talloc_tos(),
+ "%s/lockt9.lck", local_path);
+ if (!local_pathname) {
+ printf("child: alloc fail\n");
+ exit(1);
+ }
+
+ unlink(local_pathname);
+ fd = open(local_pathname, O_RDWR|O_CREAT, 0666);
+ if (fd == -1) {
+ printf("child: open of %s failed %s.\n",
+ local_pathname, strerror(errno));
+ exit(1);
+ }
+
+ /* Now take a fcntl lock. */
+ lock.l_type = F_WRLCK;
+ lock.l_whence = SEEK_SET;
+ lock.l_start = 0;
+ lock.l_len = 4;
+ lock.l_pid = getpid();
+
+ ret = fcntl(fd,F_SETLK,&lock);
+ if (ret == -1) {
+ printf("child: failed to get lock 0:4 on file %s. Error %s\n",
+ local_pathname, strerror(errno));
+ exit(1);
+ } else {
+ printf("child: got lock 0:4 on file %s.\n",
+ local_pathname );
+ fflush(stdout);
+ }
+
+ CatchSignal(SIGALRM, alarm_handler);
+ alarm(5);
+ /* Signal the parent. */
+ if (write(write_fd, &c, 1) != 1) {
+ printf("child: start signal fail %s.\n",
+ strerror(errno));
+ exit(1);
+ }
+ alarm(0);
+
+ alarm(10);
+ /* Wait for the parent to be ready. */
+ if (read(read_fd, &c, 1) != 1) {
+ printf("child: reply signal fail %s.\n",
+ strerror(errno));
+ exit(1);
+ }
+ alarm(0);
+
+ sleep(5);
+ close(fd);
+ printf("child: released lock 0:4 on file %s.\n",
+ local_pathname );
+ fflush(stdout);
+ exit(0);
+}
+
+static bool run_locktest9(int dummy)
+{
+ struct cli_state *cli1;
+ const char *fname = "\\lockt9.lck";
+ uint16_t fnum;
+ bool correct = False;
+ int pipe_in[2], pipe_out[2];
+ pid_t child_pid;
+ char c = '\0';
+ int ret;
+ struct timeval start;
+ double seconds;
+ NTSTATUS status;
+
+ printf("starting locktest9\n");
+
+ if (local_path == NULL) {
+ d_fprintf(stderr, "locktest9 must be given a local path via -l <localpath>\n");
+ return false;
+ }
+
+ if (pipe(pipe_in) == -1 || pipe(pipe_out) == -1) {
+ return false;
+ }
+
+ child_pid = fork();
+ if (child_pid == -1) {
+ return false;
+ }
+
+ if (child_pid == 0) {
+ /* Child. */
+ do_local_lock(pipe_out[0], pipe_in[1]);
+ exit(0);
+ }
+
+ close(pipe_out[0]);
+ close(pipe_in[1]);
+ pipe_out[0] = -1;
+ pipe_in[1] = -1;
+
+ /* Parent. */
+ ret = read(pipe_in[0], &c, 1);
+ if (ret != 1) {
+ d_fprintf(stderr, "failed to read start signal from child. %s\n",
+ strerror(errno));
+ return false;
+ }
+
+ if (!torture_open_connection(&cli1, 0)) {
+ return false;
+ }
+
+ cli_sockopt(cli1, sockops);
+
+ status = cli_open(cli1, fname, O_RDWR, DENY_NONE,
+ &fnum);
+ if (!NT_STATUS_IS_OK(status)) {
+ d_fprintf(stderr, "cli_open returned %s\n", cli_errstr(cli1));
+ return false;
+ }
+
+ /* Ensure the child has the lock. */
+ if (cli_lock(cli1, fnum, 0, 4, 0, WRITE_LOCK)) {
+ d_fprintf(stderr, "Got the lock on range 0:4 - this should not happen !\n");
+ goto fail;
+ } else {
+ d_printf("Child has the lock.\n");
+ }
+
+ /* Tell the child to wait 5 seconds then exit. */
+ ret = write(pipe_out[1], &c, 1);
+ if (ret != 1) {
+ d_fprintf(stderr, "failed to send exit signal to child. %s\n",
+ strerror(errno));
+ goto fail;
+ }
+
+ /* Wait 20 seconds for the lock. */
+ alarm_fd = cli1->fd;
+ CatchSignal(SIGALRM, alarm_handler_parent);
+ alarm(20);
+
+ start = timeval_current();
+
+ if (!cli_lock(cli1, fnum, 0, 4, -1, WRITE_LOCK)) {
+ d_fprintf(stderr, "Unable to apply write lock on range 0:4, error was "
+ "%s\n", cli_errstr(cli1));
+ goto fail_nofd;
+ }
+ alarm(0);
+
+ seconds = timeval_elapsed(&start);
+
+ printf("Parent got the lock after %.2f seconds.\n",
+ seconds);
+
+ status = cli_close(cli1, fnum);
+ if (!NT_STATUS_IS_OK(status)) {
+ d_fprintf(stderr, "cli_close(fnum1) %s\n", cli_errstr(cli1));
+ goto fail;
+ }
+
+ correct = true;
+
+fail:
+ cli_close(cli1, fnum);
+ torture_close_connection(cli1);
+
+fail_nofd:
+
+ printf("finished locktest9\n");
+ return correct;
+}
+
/*
test whether fnums and tids open on one VC are available on another (a major
security hole)
{
struct cli_state *cli1, *cli2;
const char *fname = "\\fdpass.tst";
- int fnum1;
+ uint16_t fnum1;
char buf[1024];
if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
printf("starting fdpasstest\n");
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
- fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
}
cli_close(cli1, fnum1);
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
torture_close_connection(cli1);
torture_close_connection(cli2);
uint16 saved_cnum;
const char *fname = "\\fdsess.tst";
const char *fname1 = "\\fdsess1.tst";
- int fnum1;
- int fnum2;
+ uint16_t fnum1;
+ uint16_t fnum2;
char buf[1024];
bool ret = True;
printf("starting fdsesstest\n");
- cli_unlink(cli, fname);
- cli_unlink(cli, fname1);
+ cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
+ cli_unlink(cli, fname1, aSYSTEM | aHIDDEN);
- fnum1 = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
return False;
}
ret = False;
}
/* Try to open a file with different vuid, samba cnum. */
- fnum2 = cli_open(cli, fname1, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- if (fnum2 != -1) {
+ if (NT_STATUS_IS_OK(cli_open(cli, fname1, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum2))) {
printf("create with different vuid, same cnum succeeded.\n");
cli_close(cli, fnum2);
- cli_unlink(cli, fname1);
+ cli_unlink(cli, fname1, aSYSTEM | aHIDDEN);
} else {
printf("create with different vuid, same cnum failed.\n");
printf("This will cause problems with service clients.\n");
cli->cnum = saved_cnum;
cli_close(cli, fnum1);
- cli_unlink(cli, fname);
+ cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
torture_close_connection(cli);
{
struct cli_state *cli;
const char *fname = "\\unlink.tst";
- int fnum;
+ uint16_t fnum;
bool correct = True;
if (!torture_open_connection(&cli, 0)) {
printf("starting unlink test\n");
- cli_unlink(cli, fname);
+ cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
cli_setpid(cli, 1);
- fnum = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- if (fnum == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
return False;
}
- if (cli_unlink(cli, fname)) {
+ if (NT_STATUS_IS_OK(cli_unlink(cli, fname, aSYSTEM | aHIDDEN))) {
printf("error: server allowed unlink on an open file\n");
correct = False;
} else {
}
cli_close(cli, fnum);
- cli_unlink(cli, fname);
+ cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
if (!torture_close_connection(cli)) {
correct = False;
}
printf("unlink test finished\n");
-
+
return correct;
}
struct cli_state *cli;
const char *ftemplate = "\\maxfid.%d.%d";
fstring fname;
- int fnums[0x11000], i;
+ uint16_t fnums[0x11000];
+ int i;
int retries=4;
bool correct = True;
for (i=0; i<0x11000; i++) {
slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
- if ((fnums[i] = cli_open(cli, fname,
- O_RDWR|O_CREAT|O_TRUNC, DENY_NONE)) ==
- -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli, fname,
+ O_RDWR|O_CREAT|O_TRUNC, DENY_NONE, &fnums[i]))) {
printf("open of %s failed (%s)\n",
fname, cli_errstr(cli));
printf("maximum fnum is %d\n", i);
for (;i>=0;i--) {
slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
cli_close(cli, fnums[i]);
- if (!cli_unlink(cli, fname)) {
+ if (!NT_STATUS_IS_OK(cli_unlink(cli, fname, aSYSTEM | aHIDDEN))) {
printf("unlink of %s failed (%s)\n",
fname, cli_errstr(cli));
correct = False;
param_len = (sys_random() % 64);
rand_buf(param, param_len);
-
+
SSVAL(param,0,api);
cli_api(cli,
static bool run_attrtest(int dummy)
{
struct cli_state *cli;
- int fnum;
+ uint16_t fnum;
time_t t, t2;
const char *fname = "\\attrib123456789.tst";
bool correct = True;
return False;
}
- cli_unlink(cli, fname);
- fnum = cli_open(cli, fname,
- O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
+ cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
+ cli_open(cli, fname,
+ O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
cli_close(cli, fnum);
- if (!cli_getatr(cli, fname, NULL, NULL, &t)) {
+ if (!NT_STATUS_IS_OK(cli_getatr(cli, fname, NULL, NULL, &t))) {
printf("getatr failed (%s)\n", cli_errstr(cli));
correct = False;
}
t2 = t-60*60*24; /* 1 day ago */
- if (!cli_setatr(cli, fname, 0, t2)) {
+ if (!NT_STATUS_IS_OK(cli_setatr(cli, fname, 0, t2))) {
printf("setatr failed (%s)\n", cli_errstr(cli));
correct = True;
}
- if (!cli_getatr(cli, fname, NULL, NULL, &t)) {
+ if (!NT_STATUS_IS_OK(cli_getatr(cli, fname, NULL, NULL, &t))) {
printf("getatr failed (%s)\n", cli_errstr(cli));
correct = True;
}
correct = True;
}
- cli_unlink(cli, fname);
+ cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
if (!torture_close_connection(cli)) {
correct = False;
static bool run_trans2test(int dummy)
{
struct cli_state *cli;
- int fnum;
+ uint16_t fnum;
SMB_OFF_T size;
time_t c_time, a_time, m_time;
struct timespec c_time_ts, a_time_ts, m_time_ts, w_time_ts, m_time2_ts;
const char *fname2 = "\\trans2\\trans2.tst";
char pname[1024];
bool correct = True;
+ NTSTATUS status;
+ uint32_t fs_attr;
printf("starting trans2 test\n");
return False;
}
- cli_unlink(cli, fname);
- fnum = cli_open(cli, fname,
- O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
+ status = cli_get_fs_attr_info(cli, &fs_attr);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("ERROR: cli_get_fs_attr_info returned %s\n",
+ nt_errstr(status));
+ correct = false;
+ }
+
+ cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
+ cli_open(cli, fname,
+ O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
if (!cli_qfileinfo(cli, fnum, NULL, &size, &c_time_ts, &a_time_ts, &w_time_ts,
&m_time_ts, NULL)) {
printf("ERROR: qfileinfo failed (%s)\n", cli_errstr(cli));
sleep(2);
- cli_unlink(cli, fname);
- fnum = cli_open(cli, fname,
- O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
- if (fnum == -1) {
+ cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
+ if (!NT_STATUS_IS_OK(cli_open(cli, fname,
+ O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum))) {
printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
return False;
}
}
- cli_unlink(cli, fname);
- fnum = cli_open(cli, fname,
- O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
+ cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
+ cli_open(cli, fname,
+ O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
cli_close(cli, fnum);
if (!cli_qpathinfo2(cli, fname, &c_time_ts, &a_time_ts, &w_time_ts,
&m_time_ts, &size, NULL, NULL)) {
}
}
- cli_unlink(cli, fname);
+ cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
/* check if the server updates the directory modification time
when creating a new file */
- if (!cli_mkdir(cli, dname)) {
+ if (!NT_STATUS_IS_OK(cli_mkdir(cli, dname))) {
printf("ERROR: mkdir failed (%s)\n", cli_errstr(cli));
correct = False;
}
correct = False;
}
- fnum = cli_open(cli, fname2,
- O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
+ cli_open(cli, fname2,
+ O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
cli_write(cli, fnum, 0, (char *)&fnum, 0, sizeof(fnum));
cli_close(cli, fnum);
if (!cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts, &w_time_ts,
correct = False;
}
}
- cli_unlink(cli, fname2);
+ cli_unlink(cli, fname2, aSYSTEM | aHIDDEN);
cli_rmdir(cli, dname);
if (!torture_close_connection(cli)) {
static bool run_w2ktest(int dummy)
{
struct cli_state *cli;
- int fnum;
+ uint16_t fnum;
const char *fname = "\\w2ktest\\w2k.tst";
int level;
bool correct = True;
return False;
}
- fnum = cli_open(cli, fname,
- O_RDWR | O_CREAT , DENY_NONE);
+ cli_open(cli, fname,
+ O_RDWR | O_CREAT , DENY_NONE, &fnum);
for (level = 1004; level < 1040; level++) {
new_trans(cli, fnum, level);
}
printf("w2k test finished\n");
-
+
return correct;
}
{
struct cli_state *cli1;
const char *fname = "\\lockt1.lck";
- int fnum1;
+ uint16_t fnum1;
bool correct = True;
printf("starting oplock test 1\n");
return False;
}
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
cli_sockopt(cli1, sockops);
cli1->use_oplocks = True;
- fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
cli1->use_oplocks = False;
- cli_unlink(cli1, fname);
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("close2 failed (%s)\n", cli_errstr(cli1));
return False;
}
- if (!cli_unlink(cli1, fname)) {
+ if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
printf("unlink failed (%s)\n", cli_errstr(cli1));
return False;
}
{
struct cli_state *cli1, *cli2;
const char *fname = "\\lockt2.lck";
- int fnum1, fnum2;
+ uint16_t fnum1, fnum2;
int saved_use_oplocks = use_oplocks;
char buf[4];
bool correct = True;
cli2->use_oplocks = True;
cli2->use_level_II_oplocks = True;
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
cli_sockopt(cli1, sockops);
cli_sockopt(cli2, sockops);
- fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
if (fork() == 0) {
/* Child code */
- fnum2 = cli_open(cli2, fname, O_RDWR, DENY_NONE);
- if (fnum2 == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2))) {
printf("second open of %s failed (%s)\n", fname, cli_errstr(cli1));
*shared_correct = False;
exit(0);
sleep(2);
- if (!cli_close(cli2, fnum2)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
printf("close2 failed (%s)\n", cli_errstr(cli1));
*shared_correct = False;
}
}
#endif
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("close1 failed (%s)\n", cli_errstr(cli1));
correct = False;
}
sleep(4);
- if (!cli_unlink(cli1, fname)) {
+ if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, aSYSTEM | aHIDDEN))) {
printf("unlink failed (%s)\n", cli_errstr(cli1));
correct = False;
}
}
/* handler for oplock 3 tests */
-static bool oplock3_handler(struct cli_state *cli, int fnum, unsigned char level)
+static NTSTATUS oplock3_handler(struct cli_state *cli, uint16_t fnum, unsigned char level)
{
printf("got oplock break fnum=%d level=%d\n",
fnum, level);
{
struct cli_state *cli;
const char *fname = "\\oplockt3.dat";
- int fnum;
+ uint16_t fnum;
char buf[4] = "abcd";
bool correct = True;
volatile bool *shared_correct;
}
sleep(2);
/* try to trigger a oplock break in parent */
- fnum = cli_open(cli, fname, O_RDWR, DENY_NONE);
+ cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum);
cli_write(cli, fnum, 0, buf, 0, 4);
exit(0);
}
return False;
}
cli_oplock_handler(cli, oplock3_handler);
- fnum = cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE);
+ cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum);
cli_write(cli, fnum, 0, buf, 0, 4);
cli_close(cli, fnum);
- fnum = cli_open(cli, fname, O_RDWR, DENY_NONE);
+ cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum);
cli->timeout = 20000;
cli_receive_smb(cli);
printf("finished oplock test 3\n");
struct cli_state *cli1 = NULL;
struct cli_state *cli2 = NULL;
const char *fname = "\\delete.file";
- int fnum1 = -1;
- int fnum2 = -1;
+ uint16_t fnum1 = (uint16_t)-1;
+ uint16_t fnum2 = (uint16_t)-1;
bool correct = True;
-
+
printf("starting delete test\n");
-
+
if (!torture_open_connection(&cli1, 0)) {
return False;
}
-
+
cli_sockopt(cli1, sockops);
/* Test 1 - this should delete the file on close. */
-
+
cli_setatr(cli1, fname, 0, 0);
- cli_unlink(cli1, fname);
-
- fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
+
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
0, FILE_OVERWRITE_IF,
- FILE_DELETE_ON_CLOSE, 0);
-
- if (fnum1 == -1) {
+ FILE_DELETE_ON_CLOSE, 0, &fnum1))) {
printf("[1] open of %s failed (%s)\n", fname, cli_errstr(cli1));
correct = False;
goto fail;
}
#endif
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("[1] close failed (%s)\n", cli_errstr(cli1));
correct = False;
goto fail;
}
- fnum1 = cli_open(cli1, fname, O_RDWR, DENY_NONE);
- if (fnum1 != -1) {
+ if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1))) {
printf("[1] open of %s succeeded (should fail)\n", fname);
correct = False;
goto fail;
}
-
+
printf("first delete on close test succeeded.\n");
-
+
/* Test 2 - this should delete the file on close. */
-
+
cli_setatr(cli1, fname, 0, 0);
- cli_unlink(cli1, fname);
-
- fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_ALL_ACCESS,
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
+
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS,
FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE,
- FILE_OVERWRITE_IF, 0, 0);
-
- if (fnum1 == -1) {
+ FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("[2] open of %s failed (%s)\n", fname, cli_errstr(cli1));
correct = False;
goto fail;
}
-
- if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
+
+ if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
printf("[2] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
correct = False;
goto fail;
}
-
- if (!cli_close(cli1, fnum1)) {
+
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("[2] close failed (%s)\n", cli_errstr(cli1));
correct = False;
goto fail;
}
-
- fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
- if (fnum1 != -1) {
+
+ if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
printf("[2] open of %s succeeded should have been deleted on close !\n", fname);
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("[2] close failed (%s)\n", cli_errstr(cli1));
correct = False;
goto fail;
}
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
} else
printf("second delete on close test succeeded.\n");
-
+
/* Test 3 - ... */
cli_setatr(cli1, fname, 0, 0);
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
- fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
-
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("[3] open - 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
correct = False;
goto fail;
/* This should fail with a sharing violation - open for delete is only compatible
with SHARE_DELETE. */
- fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0, 0);
-
- if (fnum2 != -1) {
+ if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0, 0, &fnum2))) {
printf("[3] open - 2 of %s succeeded - should have failed.\n", fname);
correct = False;
goto fail;
/* This should succeed. */
- fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0);
-
- if (fnum2 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0, &fnum2))) {
printf("[3] open - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
correct = False;
goto fail;
}
- if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
+ if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
printf("[3] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
correct = False;
goto fail;
}
-
- if (!cli_close(cli1, fnum1)) {
+
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("[3] close 1 failed (%s)\n", cli_errstr(cli1));
correct = False;
goto fail;
}
-
- if (!cli_close(cli1, fnum2)) {
+
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
printf("[3] close 2 failed (%s)\n", cli_errstr(cli1));
correct = False;
goto fail;
}
-
+
/* This should fail - file should no longer be there. */
- fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
- if (fnum1 != -1) {
+ if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
printf("[3] open of %s succeeded should have been deleted on close !\n", fname);
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("[3] close failed (%s)\n", cli_errstr(cli1));
}
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
correct = False;
goto fail;
} else
/* Test 4 ... */
cli_setatr(cli1, fname, 0, 0);
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
- fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
- FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
-
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
+ FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("[4] open of %s failed (%s)\n", fname, cli_errstr(cli1));
correct = False;
goto fail;
}
/* This should succeed. */
- fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS,
- FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0);
- if (fnum2 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
+ FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 0, 0, &fnum2))) {
printf("[4] open - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
correct = False;
goto fail;
}
-
- if (!cli_close(cli1, fnum2)) {
+
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
printf("[4] close - 1 failed (%s)\n", cli_errstr(cli1));
correct = False;
goto fail;
}
-
- if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
+
+ if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
printf("[4] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
correct = False;
goto fail;
}
-
+
/* This should fail - no more opens once delete on close set. */
- fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS,
+ if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS,
FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
- FILE_OPEN, 0, 0);
- if (fnum2 != -1) {
+ FILE_OPEN, 0, 0, &fnum2))) {
printf("[4] open - 3 of %s succeeded ! Should have failed.\n", fname );
correct = False;
goto fail;
} else
printf("fourth delete on close test succeeded.\n");
-
- if (!cli_close(cli1, fnum1)) {
+
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("[4] close - 2 failed (%s)\n", cli_errstr(cli1));
correct = False;
goto fail;
}
-
+
/* Test 5 ... */
cli_setatr(cli1, fname, 0, 0);
- cli_unlink(cli1, fname);
-
- fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT, DENY_NONE);
- if (fnum1 == -1) {
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
+
+ if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum1))) {
printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
correct = False;
goto fail;
/* This should fail - only allowed on NT opens with DELETE access. */
- if (cli_nt_delete_on_close(cli1, fnum1, True)) {
+ if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n");
correct = False;
goto fail;
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("[5] close - 2 failed (%s)\n", cli_errstr(cli1));
correct = False;
goto fail;
}
-
+
printf("fifth delete on close test succeeded.\n");
-
+
/* Test 6 ... */
cli_setatr(cli1, fname, 0, 0);
- cli_unlink(cli1, fname);
-
- fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
+
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
- FILE_OVERWRITE_IF, 0, 0);
-
- if (fnum1 == -1) {
+ FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("[6] open of %s failed (%s)\n", fname, cli_errstr(cli1));
correct = False;
goto fail;
}
-
+
/* This should fail - only allowed on NT opens with DELETE access. */
-
- if (cli_nt_delete_on_close(cli1, fnum1, True)) {
+
+ if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n");
correct = False;
goto fail;
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("[6] close - 2 failed (%s)\n", cli_errstr(cli1));
correct = False;
goto fail;
}
printf("sixth delete on close test succeeded.\n");
-
+
/* Test 7 ... */
cli_setatr(cli1, fname, 0, 0);
- cli_unlink(cli1, fname);
-
- fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
- FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, 0, 0);
-
- if (fnum1 == -1) {
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
+
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
+ FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("[7] open of %s failed (%s)\n", fname, cli_errstr(cli1));
correct = False;
goto fail;
}
- if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
+ if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
printf("[7] setting delete_on_close on file failed !\n");
correct = False;
goto fail;
}
-
- if (!cli_nt_delete_on_close(cli1, fnum1, False)) {
+
+ if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, false))) {
printf("[7] unsetting delete_on_close on file failed !\n");
correct = False;
goto fail;
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
correct = False;
goto fail;
}
-
+
/* This next open should succeed - we reset the flag. */
-
- fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
- if (fnum1 == -1) {
+
+ if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
correct = False;
goto fail;
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
correct = False;
goto fail;
}
printf("seventh delete on close test succeeded.\n");
-
+
/* Test 7 ... */
cli_setatr(cli1, fname, 0, 0);
- cli_unlink(cli1, fname);
-
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
+
if (!torture_open_connection(&cli2, 1)) {
printf("[8] failed to open second connection.\n");
correct = False;
}
cli_sockopt(cli1, sockops);
-
- fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
+
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
- FILE_OVERWRITE_IF, 0, 0);
-
- if (fnum1 == -1) {
+ FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("[8] open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
correct = False;
goto fail;
}
- fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
- FILE_OPEN, 0, 0);
-
- if (fnum2 == -1) {
+ FILE_OPEN, 0, 0, &fnum2))) {
printf("[8] open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
correct = False;
goto fail;
}
- if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
+ if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
printf("[8] setting delete_on_close on file failed !\n");
correct = False;
goto fail;
}
-
- if (!cli_close(cli1, fnum1)) {
+
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("[8] close - 1 failed (%s)\n", cli_errstr(cli1));
correct = False;
goto fail;
}
- if (!cli_close(cli2, fnum2)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
printf("[8] close - 2 failed (%s)\n", cli_errstr(cli2));
correct = False;
goto fail;
}
/* This should fail.. */
- fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
- if (fnum1 != -1) {
+ if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
printf("[8] open of %s succeeded should have been deleted on close !\n", fname);
goto fail;
correct = False;
printf("eighth delete on close test succeeded.\n");
/* This should fail - we need to set DELETE_ACCESS. */
- fnum1 = cli_nt_create_full(cli1, fname, 0,FILE_READ_DATA|FILE_WRITE_DATA,
- FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0);
-
- if (fnum1 != -1) {
+ if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0,FILE_READ_DATA|FILE_WRITE_DATA,
+ FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0, &fnum1))) {
printf("[9] open of %s succeeded should have failed!\n", fname);
correct = False;
goto fail;
printf("ninth delete on close test succeeded.\n");
- fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
- FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
+ FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, 0, &fnum1))) {
printf("[10] open of %s failed (%s)\n", fname, cli_errstr(cli1));
correct = False;
goto fail;
}
/* This should delete the file. */
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("[10] close failed (%s)\n", cli_errstr(cli1));
correct = False;
goto fail;
}
/* This should fail.. */
- fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_NONE);
- if (fnum1 != -1) {
+ if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
printf("[10] open of %s succeeded should have been deleted on close !\n", fname);
goto fail;
correct = False;
printf("tenth delete on close test succeeded.\n");
cli_setatr(cli1, fname, 0, 0);
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
/* What error do we get when attempting to open a read-only file with
delete access ? */
/* Create a readonly file. */
- fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
- FILE_ATTRIBUTE_READONLY, FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
+ FILE_ATTRIBUTE_READONLY, FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("[11] open of %s failed (%s)\n", fname, cli_errstr(cli1));
correct = False;
goto fail;
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("[11] close failed (%s)\n", cli_errstr(cli1));
correct = False;
goto fail;
}
/* Now try open for delete access. */
- fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_ATTRIBUTES|DELETE_ACCESS,
+ if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES|DELETE_ACCESS,
0, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
- FILE_OVERWRITE_IF, 0, 0);
-
- if (fnum1 != -1) {
+ FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("[11] open of %s succeeded should have been denied with ACCESS_DENIED!\n", fname);
cli_close(cli1, fnum1);
goto fail;
printf("eleventh delete on close test succeeded.\n");
}
}
-
+
printf("finished delete test\n");
fail:
/* FIXME: This will crash if we aborted before cli2 got
* intialized, because these functions don't handle
* uninitialized connections. */
-
- if (fnum1 != -1) cli_close(cli1, fnum1);
- if (fnum2 != -1) cli_close(cli1, fnum2);
+
+ if (fnum1 != (uint16_t)-1) cli_close(cli1, fnum1);
+ if (fnum2 != (uint16_t)-1) cli_close(cli1, fnum2);
cli_setatr(cli1, fname, 0, 0);
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
if (cli1 && !torture_close_connection(cli1)) {
correct = False;
*/
static bool run_properties(int dummy)
{
- static struct cli_state *cli;
+ struct cli_state *cli;
bool correct = True;
-
+
printf("starting properties test\n");
-
+
ZERO_STRUCT(cli);
if (!torture_open_connection(&cli, 0)) {
return False;
}
-
+
cli_sockopt(cli, sockops);
d_printf("Capabilities 0x%08x\n", cli->capabilities);
static struct cli_state *cli1;
const char *fname = "\\test.txt";
bool correct = True;
- int fnum1, fnum2;
+ uint16_t fnum1, fnum2;
printf("starting xcopy test\n");
-
+
if (!torture_open_connection(&cli1, 0)) {
return False;
}
-
- fnum1 = cli_nt_create_full(cli1, fname, 0,
+
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0,
FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
FILE_SHARE_NONE, FILE_OVERWRITE_IF,
- 0x4044, 0);
-
- if (fnum1 == -1) {
+ 0x4044, 0, &fnum1))) {
printf("First open failed - %s\n", cli_errstr(cli1));
return False;
}
- fnum2 = cli_nt_create_full(cli1, fname, 0,
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0,
SECOND_DESIRED_ACCESS, 0,
FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN,
- 0x200000, 0);
- if (fnum2 == -1) {
+ 0x200000, 0, &fnum2))) {
printf("second open failed - %s\n", cli_errstr(cli1));
return False;
}
-
+
if (!torture_close_connection(cli1)) {
correct = False;
}
-
+
return correct;
}
const char *fname = "\\test.txt";
const char *fname1 = "\\test1.txt";
bool correct = True;
- int fnum1;
+ uint16_t fnum1;
+ NTSTATUS status;
printf("starting rename test\n");
-
+
if (!torture_open_connection(&cli1, 0)) {
return False;
}
-
- cli_unlink(cli1, fname);
- cli_unlink(cli1, fname1);
- fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_READ, FILE_OVERWRITE_IF, 0, 0);
- if (fnum1 == -1) {
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
+ cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_READ, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("First open failed - %s\n", cli_errstr(cli1));
return False;
}
- if (!cli_rename(cli1, fname, fname1)) {
+ if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
printf("First rename failed (SHARE_READ) (this is correct) - %s\n", cli_errstr(cli1));
} else {
printf("First rename succeeded (SHARE_READ) - this should have failed !\n");
correct = False;
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("close - 1 failed (%s)\n", cli_errstr(cli1));
return False;
}
- cli_unlink(cli1, fname);
- cli_unlink(cli1, fname1);
- fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
+ cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
+ status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
#if 0
- FILE_SHARE_DELETE|FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
+ FILE_SHARE_DELETE|FILE_SHARE_NONE,
#else
- FILE_SHARE_DELETE|FILE_SHARE_READ, FILE_OVERWRITE_IF, 0, 0);
+ FILE_SHARE_DELETE|FILE_SHARE_READ,
#endif
-
- if (fnum1 == -1) {
+ FILE_OVERWRITE_IF, 0, 0, &fnum1);
+ if (!NT_STATUS_IS_OK(status)) {
printf("Second open failed - %s\n", cli_errstr(cli1));
return False;
}
- if (!cli_rename(cli1, fname, fname1)) {
+ if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
printf("Second rename failed (SHARE_DELETE | SHARE_READ) - this should have succeeded - %s\n", cli_errstr(cli1));
correct = False;
} else {
printf("Second rename succeeded (SHARE_DELETE | SHARE_READ)\n");
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("close - 2 failed (%s)\n", cli_errstr(cli1));
return False;
}
- cli_unlink(cli1, fname);
- cli_unlink(cli1, fname1);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
+ cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
- fnum1 = cli_nt_create_full(cli1, fname, 0, READ_CONTROL_ACCESS, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
-
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, READ_CONTROL_ACCESS, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("Third open failed - %s\n", cli_errstr(cli1));
return False;
}
#if 0
{
- int fnum2;
-
- fnum2 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
+ uint16_t fnum2;
- if (fnum2 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum2))) {
printf("Fourth open failed - %s\n", cli_errstr(cli1));
return False;
}
- if (!cli_nt_delete_on_close(cli1, fnum2, True)) {
+ if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum2, true))) {
printf("[8] setting delete_on_close on file failed !\n");
return False;
}
-
- if (!cli_close(cli1, fnum2)) {
+
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
printf("close - 4 failed (%s)\n", cli_errstr(cli1));
return False;
}
}
#endif
- if (!cli_rename(cli1, fname, fname1)) {
+ if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
printf("Third rename failed (SHARE_NONE) - this should have succeeded - %s\n", cli_errstr(cli1));
correct = False;
} else {
printf("Third rename succeeded (SHARE_NONE)\n");
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("close - 3 failed (%s)\n", cli_errstr(cli1));
return False;
}
- cli_unlink(cli1, fname);
- cli_unlink(cli1, fname1);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
+ cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
/*----*/
- fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
-
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("Fourth open failed - %s\n", cli_errstr(cli1));
return False;
}
- if (!cli_rename(cli1, fname, fname1)) {
+ if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
printf("Fourth rename failed (SHARE_READ | SHARE_WRITE) (this is correct) - %s\n", cli_errstr(cli1));
} else {
printf("Fourth rename succeeded (SHARE_READ | SHARE_WRITE) - this should have failed !\n");
correct = False;
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("close - 4 failed (%s)\n", cli_errstr(cli1));
return False;
}
- cli_unlink(cli1, fname);
- cli_unlink(cli1, fname1);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
+ cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
/*--*/
- fnum1 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0);
-
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("Fifth open failed - %s\n", cli_errstr(cli1));
return False;
}
- if (!cli_rename(cli1, fname, fname1)) {
+ if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have succeeded - %s ! \n",
cli_errstr(cli1));
correct = False;
* Now check if the first name still exists ...
*/
- /*fnum2 = cli_nt_create_full(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0);
-
- if (fnum2 == -1) {
+ /* if (!NT_STATUS_OP(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0, &fnum2))) {
printf("Opening original file after rename of open file fails: %s\n",
cli_errstr(cli1));
}
/*--*/
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("close - 5 failed (%s)\n", cli_errstr(cli1));
return False;
}
- cli_unlink(cli1, fname);
- cli_unlink(cli1, fname1);
-
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
+ cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
+
if (!torture_close_connection(cli1)) {
correct = False;
}
-
+
return correct;
}
{
struct cli_state *cli1;
const char *pipe_name = "\\SPOOLSS";
- int fnum;
+ uint16_t fnum;
int num_pipes = 0;
printf("starting pipenumber test\n");
cli_sockopt(cli1, sockops);
while(1) {
- fnum = cli_nt_create_full(cli1, pipe_name, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN_IF, 0, 0);
-
- if (fnum == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, pipe_name, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN_IF, 0, 0, &fnum))) {
printf("Open of pipe %s failed with error (%s)\n", pipe_name, cli_errstr(cli1));
break;
}
static struct cli_state *cli1;
static struct cli_state *cli2;
const char *fname = "\\readonly.file";
- int fnum1, fnum2;
+ uint16_t fnum1, fnum2;
char buf[20];
SMB_OFF_T fsize;
bool correct = True;
char *tmp_path;
printf("starting open test\n");
-
+
if (!torture_open_connection(&cli1, 0)) {
return False;
}
-
+
cli_setatr(cli1, fname, 0, 0);
- cli_unlink(cli1, fname);
-
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
+
cli_sockopt(cli1, sockops);
-
- fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- if (fnum1 == -1) {
+
+ if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("close2 failed (%s)\n", cli_errstr(cli1));
return False;
}
-
- if (!cli_setatr(cli1, fname, aRONLY, 0)) {
+
+ if (!NT_STATUS_IS_OK(cli_setatr(cli1, fname, aRONLY, 0))) {
printf("cli_setatr failed (%s)\n", cli_errstr(cli1));
return False;
}
-
- fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_WRITE);
- if (fnum1 == -1) {
+
+ if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1))) {
printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
-
+
/* This will fail - but the error should be ERRnoaccess, not ERRbadshare. */
- fnum2 = cli_open(cli1, fname, O_RDWR, DENY_ALL);
-
+ cli_open(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
+
if (check_error(__LINE__, cli1, ERRDOS, ERRnoaccess,
NT_STATUS_ACCESS_DENIED)) {
printf("correct error code ERRDOS/ERRnoaccess returned\n");
}
-
+
printf("finished open test 1\n");
-
+
cli_close(cli1, fnum1);
-
+
/* Now try not readonly and ensure ERRbadshare is returned. */
-
+
cli_setatr(cli1, fname, 0, 0);
-
- fnum1 = cli_open(cli1, fname, O_RDONLY, DENY_WRITE);
- if (fnum1 == -1) {
+
+ if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1))) {
printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
-
+
/* This will fail - but the error should be ERRshare. */
- fnum2 = cli_open(cli1, fname, O_RDWR, DENY_ALL);
-
+ cli_open(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
+
if (check_error(__LINE__, cli1, ERRDOS, ERRbadshare,
NT_STATUS_SHARING_VIOLATION)) {
printf("correct error code ERRDOS/ERRbadshare returned\n");
}
-
- if (!cli_close(cli1, fnum1)) {
+
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("close2 failed (%s)\n", cli_errstr(cli1));
return False;
}
-
- cli_unlink(cli1, fname);
-
+
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
+
printf("finished open test 2\n");
-
+
/* Test truncate open disposition on file opened for read. */
-
- fnum1 = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- if (fnum1 == -1) {
+
+ if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
printf("(3) open (1) of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
-
+
/* write 20 bytes. */
-
+
memset(buf, '\0', 20);
if (cli_write(cli1, fnum1, 0, buf, 0, 20) != 20) {
correct = False;
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("(3) close1 failed (%s)\n", cli_errstr(cli1));
return False;
}
-
+
/* Ensure size == 20. */
- if (!cli_getatr(cli1, fname, NULL, &fsize, NULL)) {
+ if (!NT_STATUS_IS_OK(cli_getatr(cli1, fname, NULL, &fsize, NULL))) {
printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
return False;
}
-
+
if (fsize != 20) {
printf("(3) file size != 20\n");
return False;
}
/* Now test if we can truncate a file opened for readonly. */
-
- fnum1 = cli_open(cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE);
- if (fnum1 == -1) {
+
+ if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE, &fnum1))) {
printf("(3) open (2) of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
-
- if (!cli_close(cli1, fnum1)) {
+
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("close2 failed (%s)\n", cli_errstr(cli1));
return False;
}
/* Ensure size == 0. */
- if (!cli_getatr(cli1, fname, NULL, &fsize, NULL)) {
+ if (!NT_STATUS_IS_OK(cli_getatr(cli1, fname, NULL, &fsize, NULL))) {
printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
return False;
}
return False;
}
printf("finished open test 3\n");
-
- cli_unlink(cli1, fname);
+
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
printf("testing ctemp\n");
- fnum1 = cli_ctemp(cli1, "\\", &tmp_path);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ctemp(cli1, talloc_tos(), "\\", &fnum1, &tmp_path))) {
printf("ctemp failed (%s)\n", cli_errstr(cli1));
return False;
}
printf("ctemp gave path %s\n", tmp_path);
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("close of temp failed (%s)\n", cli_errstr(cli1));
}
- if (!cli_unlink(cli1, tmp_path)) {
+ if (!NT_STATUS_IS_OK(cli_unlink(cli1, tmp_path, aSYSTEM | aHIDDEN))) {
printf("unlink of temp failed (%s)\n", cli_errstr(cli1));
}
-
+
/* Test the non-io opens... */
if (!torture_open_connection(&cli2, 1)) {
return False;
}
-
+
cli_setatr(cli2, fname, 0, 0);
- cli_unlink(cli2, fname);
-
+ cli_unlink(cli2, fname, aSYSTEM | aHIDDEN);
+
cli_sockopt(cli2, sockops);
printf("TEST #1 testing 2 non-io opens (no delete)\n");
-
- fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("test 1 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
- fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
-
- if (fnum2 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
printf("test 1 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
return False;
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("test 1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
- if (!cli_close(cli2, fnum2)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
printf("test 1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
return False;
}
printf("non-io open test #1 passed.\n");
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
printf("TEST #2 testing 2 non-io opens (first with delete)\n");
-
- fnum1 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("test 2 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
- fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
-
- if (fnum2 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
printf("test 2 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
return False;
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("test 1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
- if (!cli_close(cli2, fnum2)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
printf("test 1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
printf("non-io open test #2 passed.\n");
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
printf("TEST #3 testing 2 non-io opens (second with delete)\n");
-
- fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("test 3 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
- fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
-
- if (fnum2 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
printf("test 3 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
return False;
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("test 3 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
- if (!cli_close(cli2, fnum2)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
printf("test 3 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
return False;
}
printf("non-io open test #3 passed.\n");
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
printf("TEST #4 testing 2 non-io opens (both with delete)\n");
-
- fnum1 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("test 4 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
- fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0);
-
- if (fnum2 != -1) {
+ if (NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
printf("test 4 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
return False;
}
printf("test 3 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("test 4 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
printf("non-io open test #4 passed.\n");
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
printf("TEST #5 testing 2 non-io opens (both with delete - both with file share delete)\n");
-
- fnum1 = cli_nt_create_full(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("test 5 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
- fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_DELETE, FILE_OPEN_IF, 0, 0);
-
- if (fnum2 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_DELETE, FILE_OPEN_IF, 0, 0, &fnum2))) {
printf("test 5 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
return False;
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("test 5 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
- if (!cli_close(cli2, fnum2)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
printf("test 5 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
return False;
}
printf("non-io open test #5 passed.\n");
printf("TEST #6 testing 1 non-io open, one io open\n");
-
- cli_unlink(cli1, fname);
- fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("test 6 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
- fnum2 = cli_nt_create_full(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_READ, FILE_OPEN_IF, 0, 0);
-
- if (fnum2 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_READ, FILE_OPEN_IF, 0, 0, &fnum2))) {
printf("test 6 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
return False;
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("test 6 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
- if (!cli_close(cli2, fnum2)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
printf("test 6 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
return False;
}
printf("TEST #7 testing 1 non-io open, one io open with delete\n");
- cli_unlink(cli1, fname);
-
- fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("test 7 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
- fnum2 = cli_nt_create_full(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
- FILE_SHARE_READ|FILE_SHARE_DELETE, FILE_OPEN_IF, 0, 0);
-
- if (fnum2 != -1) {
+ if (NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_READ|FILE_SHARE_DELETE, FILE_OPEN_IF, 0, 0, &fnum2))) {
printf("test 7 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
return False;
}
printf("test 7 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("test 7 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
return False;
}
printf("non-io open test #7 passed.\n");
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
if (!torture_close_connection(cli1)) {
correct = False;
if (!torture_close_connection(cli2)) {
correct = False;
}
-
+
return correct;
}
static bool run_simple_posix_open_test(int dummy)
{
static struct cli_state *cli1;
- const char *fname = "\\posix:file";
- const char *dname = "\\posix:dir";
+ const char *fname = "posix:file";
+ const char *hname = "posix:hlink";
+ const char *sname = "posix:symlink";
+ const char *dname = "posix:dir";
+ char buf[10];
+ char namebuf[11];
uint16 major, minor;
uint32 caplow, caphigh;
- int fnum1 = -1;
+ uint16_t fnum1 = (uint16_t)-1;
+ SMB_STRUCT_STAT sbuf;
bool correct = false;
+ NTSTATUS status;
printf("Starting simple POSIX open test\n");
return false;
}
- if (!cli_unix_extensions_version(cli1, &major,
- &minor, &caplow, &caphigh)) {
- printf("Server didn't return UNIX CIFS extensions.\n");
+ status = cli_unix_extensions_version(cli1, &major, &minor, &caplow,
+ &caphigh);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("Server didn't return UNIX CIFS extensions: %s\n",
+ nt_errstr(status));
return false;
}
- if (!cli_set_unix_extensions_capabilities(cli1,
- major, minor, caplow, caphigh)) {
- printf("Server doesn't support setting UNIX CIFS extensions.\n");
+ status = cli_set_unix_extensions_capabilities(cli1, major, minor,
+ caplow, caphigh);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("Server doesn't support setting UNIX CIFS extensions: "
+ "%s.\n", nt_errstr(status));
return false;
}
cli_posix_unlink(cli1, fname);
cli_setatr(cli1, dname, 0, 0);
cli_posix_rmdir(cli1, dname);
+ cli_setatr(cli1, hname, 0, 0);
+ cli_posix_unlink(cli1, hname);
+ cli_setatr(cli1, sname, 0, 0);
+ cli_posix_unlink(cli1, sname);
/* Create a directory. */
- if (cli_posix_mkdir(cli1, dname, 0777) == -1) {
- printf("Server doesn't support setting UNIX CIFS extensions.\n");
+ if (!NT_STATUS_IS_OK(cli_posix_mkdir(cli1, dname, 0777))) {
+ printf("POSIX mkdir of %s failed (%s)\n", dname, cli_errstr(cli1));
goto out;
}
- fnum1 = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, 0600);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, 0600, &fnum1))) {
printf("POSIX create of %s failed (%s)\n", fname, cli_errstr(cli1));
goto out;
}
- if (!cli_close(cli1, fnum1)) {
+ /* Test ftruncate - set file size. */
+ if (!NT_STATUS_IS_OK(cli_ftruncate(cli1, fnum1, 1000))) {
+ printf("ftruncate failed (%s)\n", cli_errstr(cli1));
+ goto out;
+ }
+
+ /* Ensure st_size == 1000 */
+ if (!NT_STATUS_IS_OK(cli_posix_stat(cli1, fname, &sbuf))) {
+ printf("stat failed (%s)\n", cli_errstr(cli1));
+ goto out;
+ }
+
+ if (sbuf.st_ex_size != 1000) {
+ printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf.st_ex_size);
+ goto out;
+ }
+
+ /* Test ftruncate - set file size back to zero. */
+ if (!NT_STATUS_IS_OK(cli_ftruncate(cli1, fnum1, 0))) {
+ printf("ftruncate failed (%s)\n", cli_errstr(cli1));
+ goto out;
+ }
+
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("close failed (%s)\n", cli_errstr(cli1));
goto out;
}
/* Now open the file again for read only. */
- fnum1 = cli_posix_open(cli1, fname, O_RDONLY, 0);
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1))) {
printf("POSIX open of %s failed (%s)\n", fname, cli_errstr(cli1));
goto out;
}
/* Now unlink while open. */
- if (!cli_posix_unlink(cli1, fname)) {
+ if (!NT_STATUS_IS_OK(cli_posix_unlink(cli1, fname))) {
printf("POSIX unlink of %s failed (%s)\n", fname, cli_errstr(cli1));
goto out;
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("close(2) failed (%s)\n", cli_errstr(cli1));
goto out;
}
/* Ensure the file has gone. */
- fnum1 = cli_posix_open(cli1, fname, O_RDONLY, 0);
- if (fnum1 != -1) {
+ if (NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1))) {
printf("POSIX open of %s succeeded, should have been deleted.\n", fname);
goto out;
}
- if (!cli_posix_rmdir(cli1, dname)) {
+ /* What happens when we try and POSIX open a directory ? */
+ if (NT_STATUS_IS_OK(cli_posix_open(cli1, dname, O_RDONLY, 0, &fnum1))) {
+ printf("POSIX open of directory %s succeeded, should have failed.\n", fname);
+ goto out;
+ } else {
+ if (!check_error(__LINE__, cli1, ERRDOS, EISDIR,
+ NT_STATUS_FILE_IS_A_DIRECTORY)) {
+ goto out;
+ }
+ }
+
+ /* Create the file. */
+ if (!NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, 0600, &fnum1))) {
+ printf("POSIX create of %s failed (%s)\n", fname, cli_errstr(cli1));
+ goto out;
+ }
+
+ /* Write some data into it. */
+ if (cli_write(cli1, fnum1, 0, "TEST DATA\n", 0, 10) != 10) {
+ printf("cli_write failed: %s\n", cli_errstr(cli1));
+ goto out;
+ }
+
+ cli_close(cli1, fnum1);
+
+ /* Now create a hardlink. */
+ if (!NT_STATUS_IS_OK(cli_posix_hardlink(cli1, fname, hname))) {
+ printf("POSIX hardlink of %s failed (%s)\n", hname, cli_errstr(cli1));
+ goto out;
+ }
+
+ /* Now create a symlink. */
+ if (!NT_STATUS_IS_OK(cli_posix_symlink(cli1, fname, sname))) {
+ printf("POSIX symlink of %s failed (%s)\n", sname, cli_errstr(cli1));
+ goto out;
+ }
+
+ /* Open the hardlink for read. */
+ if (!NT_STATUS_IS_OK(cli_posix_open(cli1, hname, O_RDONLY, 0, &fnum1))) {
+ printf("POSIX open of %s failed (%s)\n", hname, cli_errstr(cli1));
+ goto out;
+ }
+
+ if (cli_read(cli1, fnum1, buf, 0, 10) != 10) {
+ printf("POSIX read of %s failed (%s)\n", hname, cli_errstr(cli1));
+ goto out;
+ }
+
+ if (memcmp(buf, "TEST DATA\n", 10)) {
+ printf("invalid data read from hardlink\n");
+ goto out;
+ }
+
+ /* Do a POSIX lock/unlock. */
+ if (!NT_STATUS_IS_OK(cli_posix_lock(cli1, fnum1, 0, 100, true, READ_LOCK))) {
+ printf("POSIX lock failed %s\n", cli_errstr(cli1));
+ goto out;
+ }
+
+ /* Punch a hole in the locked area. */
+ if (!NT_STATUS_IS_OK(cli_posix_unlock(cli1, fnum1, 10, 80))) {
+ printf("POSIX unlock failed %s\n", cli_errstr(cli1));
+ goto out;
+ }
+
+ cli_close(cli1, fnum1);
+
+ /* Open the symlink for read - this should fail. A POSIX
+ client should not be doing opens on a symlink. */
+ if (NT_STATUS_IS_OK(cli_posix_open(cli1, sname, O_RDONLY, 0, &fnum1))) {
+ printf("POSIX open of %s succeeded (should have failed)\n", sname);
+ goto out;
+ } else {
+ if (!check_error(__LINE__, cli1, ERRDOS, ERRbadpath,
+ NT_STATUS_OBJECT_PATH_NOT_FOUND)) {
+ printf("POSIX open of %s should have failed "
+ "with NT_STATUS_OBJECT_PATH_NOT_FOUND, "
+ "failed with %s instead.\n",
+ sname, cli_errstr(cli1));
+ goto out;
+ }
+ }
+
+ if (!NT_STATUS_IS_OK(cli_posix_readlink(cli1, sname, namebuf, sizeof(namebuf)))) {
+ printf("POSIX readlink on %s failed (%s)\n", sname, cli_errstr(cli1));
+ goto out;
+ }
+
+ if (strcmp(namebuf, fname) != 0) {
+ printf("POSIX readlink on %s failed to match name %s (read %s)\n",
+ sname, fname, namebuf);
+ goto out;
+ }
+
+ if (!NT_STATUS_IS_OK(cli_posix_rmdir(cli1, dname))) {
printf("POSIX rmdir failed (%s)\n", cli_errstr(cli1));
goto out;
}
out:
- if (fnum1 != -1) {
+ if (fnum1 != (uint16_t)-1) {
cli_close(cli1, fnum1);
- fnum1 = -1;
+ fnum1 = (uint16_t)-1;
}
+ cli_setatr(cli1, sname, 0, 0);
+ cli_posix_unlink(cli1, sname);
+ cli_setatr(cli1, hname, 0, 0);
+ cli_posix_unlink(cli1, hname);
cli_setatr(cli1, fname, 0, 0);
cli_posix_unlink(cli1, fname);
cli_setatr(cli1, dname, 0, 0);
{
static struct cli_state *cli1;
const char *fname = "\\openattr.file";
- int fnum1;
+ uint16_t fnum1;
bool correct = True;
uint16 attr;
unsigned int i, j, k, l;
printf("starting open attr test\n");
-
+
if (!torture_open_connection(&cli1, 0)) {
return False;
}
-
+
cli_sockopt(cli1, sockops);
for (k = 0, i = 0; i < sizeof(open_attrs_table)/sizeof(uint32); i++) {
cli_setatr(cli1, fname, 0, 0);
- cli_unlink(cli1, fname);
- fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_WRITE_DATA, open_attrs_table[i],
- FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0);
-
- if (fnum1 == -1) {
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA, open_attrs_table[i],
+ FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
printf("open %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
return False;
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("close %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
return False;
}
for (j = 0; j < sizeof(open_attrs_table)/sizeof(uint32); j++) {
- fnum1 = cli_nt_create_full(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA, open_attrs_table[j],
- FILE_SHARE_NONE, FILE_OVERWRITE, 0, 0);
-
- if (fnum1 == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA, open_attrs_table[j],
+ FILE_SHARE_NONE, FILE_OVERWRITE, 0, 0, &fnum1))) {
for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) {
if (attr_results[l].num == k) {
printf("[%d] trunc open 0x%x -> 0x%x of %s failed - should have succeeded !(0x%x:%s)\n",
continue;
}
- if (!cli_close(cli1, fnum1)) {
+ if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
printf("close %d (2) of %s failed (%s)\n", j, fname, cli_errstr(cli1));
return False;
}
- if (!cli_getatr(cli1, fname, &attr, NULL, NULL)) {
+ if (!NT_STATUS_IS_OK(cli_getatr(cli1, fname, &attr, NULL, NULL))) {
printf("getatr(2) failed (%s)\n", cli_errstr(cli1));
return False;
}
}
cli_setatr(cli1, fname, 0, 0);
- cli_unlink(cli1, fname);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
printf("open attr test %s.\n", correct ? "passed" : "failed");
static void list_fn(const char *mnt, file_info *finfo, const char *name, void *state)
{
-
+
}
/*
{
int i;
static struct cli_state *cli;
- int fnum;
- double t1;
+ uint16_t fnum;
+ struct timeval core_start;
bool correct = True;
printf("starting directory test\n");
for (i=0;i<torture_numops;i++) {
fstring fname;
slprintf(fname, sizeof(fname), "\\%x", (int)random());
- fnum = cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE);
- if (fnum == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum))) {
fprintf(stderr,"Failed to open %s\n", fname);
return False;
}
cli_close(cli, fnum);
}
- t1 = end_timer();
+ core_start = timeval_current();
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));
- printf("dirtest core %g seconds\n", end_timer() - t1);
+ printf("dirtest core %g seconds\n", timeval_elapsed(&core_start));
srandom(0);
for (i=0;i<torture_numops;i++) {
fstring fname;
slprintf(fname, sizeof(fname), "\\%x", (int)random());
- cli_unlink(cli, fname);
+ cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
}
if (!torture_close_connection(cli)) {
return;
if (finfo->mode & aDIR) {
- if (!cli_rmdir(pcli, fname))
+ if (!NT_STATUS_IS_OK(cli_rmdir(pcli, fname)))
printf("del_fn: failed to rmdir %s\n,", fname );
} else {
- if (!cli_unlink(pcli, fname))
+ if (!NT_STATUS_IS_OK(cli_unlink(pcli, fname, aSYSTEM | aHIDDEN)))
printf("del_fn: failed to unlink %s\n,", fname );
}
}
bool torture_ioctl_test(int dummy)
{
static struct cli_state *cli;
- uint16 device, function;
- int fnum;
+ uint16_t device, function;
+ uint16_t fnum;
const char *fname = "\\ioctl.dat";
DATA_BLOB blob;
NTSTATUS status;
printf("starting ioctl test\n");
- cli_unlink(cli, fname);
+ cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
- fnum = cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- if (fnum == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
return False;
}
bool torture_chkpath_test(int dummy)
{
static struct cli_state *cli;
- int fnum;
+ uint16_t fnum;
bool ret;
if (!torture_open_connection(&cli, 0)) {
/* cleanup from an old run */
cli_rmdir(cli, "\\chkpath.dir\\dir2");
- cli_unlink(cli, "\\chkpath.dir\\*");
+ cli_unlink(cli, "\\chkpath.dir\\*", aSYSTEM | aHIDDEN);
cli_rmdir(cli, "\\chkpath.dir");
- if (!cli_mkdir(cli, "\\chkpath.dir")) {
+ if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\chkpath.dir"))) {
printf("mkdir1 failed : %s\n", cli_errstr(cli));
return False;
}
- if (!cli_mkdir(cli, "\\chkpath.dir\\dir2")) {
+ if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\chkpath.dir\\dir2"))) {
printf("mkdir2 failed : %s\n", cli_errstr(cli));
return False;
}
- fnum = cli_open(cli, "\\chkpath.dir\\foo.txt", O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- if (fnum == -1) {
+ if (!NT_STATUS_IS_OK(cli_open(cli, "\\chkpath.dir\\foo.txt", O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
printf("open1 failed (%s)\n", cli_errstr(cli));
return False;
}
cli_close(cli, fnum);
- if (!cli_chkpath(cli, "\\chkpath.dir")) {
+ if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir"))) {
printf("chkpath1 failed: %s\n", cli_errstr(cli));
ret = False;
}
- if (!cli_chkpath(cli, "\\chkpath.dir\\dir2")) {
+ if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\dir2"))) {
printf("chkpath2 failed: %s\n", cli_errstr(cli));
ret = False;
}
- if (!cli_chkpath(cli, "\\chkpath.dir\\foo.txt")) {
+ if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\foo.txt"))) {
ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
NT_STATUS_NOT_A_DIRECTORY);
} else {
ret = False;
}
- if (!cli_chkpath(cli, "\\chkpath.dir\\bar.txt")) {
+ if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\bar.txt"))) {
ret = check_error(__LINE__, cli, ERRDOS, ERRbadfile,
NT_STATUS_OBJECT_NAME_NOT_FOUND);
} else {
ret = False;
}
- if (!cli_chkpath(cli, "\\chkpath.dir\\dirxx\\bar.txt")) {
+ if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\dirxx\\bar.txt"))) {
ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath,
NT_STATUS_OBJECT_PATH_NOT_FOUND);
} else {
}
cli_rmdir(cli, "\\chkpath.dir\\dir2");
- cli_unlink(cli, "\\chkpath.dir\\*");
+ cli_unlink(cli, "\\chkpath.dir\\*", aSYSTEM | aHIDDEN);
cli_rmdir(cli, "\\chkpath.dir");
if (!torture_close_connection(cli)) {
static struct cli_state *cli;
const char *fname = "\\eatest.txt";
bool correct = True;
- int fnum, i;
+ uint16_t fnum;
+ int i;
size_t num_eas;
struct ea_struct *ea_list = NULL;
TALLOC_CTX *mem_ctx = talloc_init("eatest");
printf("starting eatest\n");
-
+
if (!torture_open_connection(&cli, 0)) {
talloc_destroy(mem_ctx);
return False;
}
-
- cli_unlink(cli, fname);
- fnum = cli_nt_create_full(cli, fname, 0,
+
+ cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli, fname, 0,
FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
FILE_SHARE_NONE, FILE_OVERWRITE_IF,
- 0x4044, 0);
-
- if (fnum == -1) {
+ 0x4044, 0, &fnum))) {
printf("open failed - %s\n", cli_errstr(cli));
talloc_destroy(mem_ctx);
return False;
return False;
}
}
-
+
cli_close(cli, fnum);
for (i = 0; i < 10; i++) {
fstring ea_name, ea_val;
return False;
}
}
-
+
if (!cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list)) {
printf("ea_get list failed - %s\n", cli_errstr(cli));
correct = False;
if (!torture_close_connection(cli)) {
correct = False;
}
-
+
return correct;
}
{
int i;
static struct cli_state *cli;
- int fnum, num_seen;
+ uint16_t fnum;
+ int num_seen;
bool correct = True;
printf("starting directory test\n");
for (i=0;i<1000;i++) {
fstring fname;
slprintf(fname, sizeof(fname), "\\LISTDIR\\f%d", i);
- fnum = cli_nt_create_full(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
- FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0);
- if (fnum == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
+ FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum))) {
fprintf(stderr,"Failed to open %s\n", fname);
return False;
}
for (i=0;i<1000;i++) {
fstring fname;
slprintf(fname, sizeof(fname), "\\LISTDIR\\d%d", i);
- if (!cli_mkdir(cli, fname)) {
+ if (!NT_STATUS_IS_OK(cli_mkdir(cli, fname))) {
fprintf(stderr,"Failed to open %s\n", fname);
return False;
}
}
static bool run_error_map_extract(int dummy) {
-
+
static struct cli_state *c_dos;
static struct cli_state *c_nt;
NTSTATUS status;
workgroup))) {
printf("/** Session setup succeeded. This shouldn't happen...*/\n");
}
-
+
flgs2 = SVAL(c_nt->inbuf,smb_flg2);
-
+
/* Case #1: 32-bit NT errors */
if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
nt_status = NT_STATUS(IVAL(c_nt->inbuf,smb_rcls));
printf("/** Session setup succeeded. This shouldn't happen...*/\n");
}
flgs2 = SVAL(c_dos->inbuf,smb_flg2), errnum;
-
+
/* Case #1: 32-bit NT errors */
if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
printf("/** NT error on DOS connection! (%s) */\n",
get_nt_error_c_code(NT_STATUS(error)),
get_nt_error_c_code(nt_status));
}
-
+
printf("\t{%s,\t%s,\t%s},\n",
smb_dos_err_class(errclass),
smb_dos_err_name(errclass, errnum),
{
static struct cli_state *c;
const char *fname = "\\file.dat";
- int fnum;
+ uint16_t fnum;
NTSTATUS status;
int i;
return false;
}
- fnum = cli_nt_create_full(
- c, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
- FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
- FILE_DELETE_ON_CLOSE, 0);
- if (fnum == -1) {
+ if (!NT_STATUS_IS_OK(cli_ntcreate(
+ c, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
+ FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
+ FILE_DELETE_ON_CLOSE, 0, &fnum))) {
d_printf("open %s failed: %s\n", fname, cli_errstr(c));
return false;
}
return result;
}
-static void chain1_open_completion(struct async_req *req)
+static void chain1_open_completion(struct tevent_req *req)
{
- int fnum;
+ uint16_t fnum;
NTSTATUS status;
-
status = cli_open_recv(req, &fnum);
TALLOC_FREE(req);
NT_STATUS_IS_OK(status) ? fnum : -1);
}
-static void chain1_read_completion(struct async_req *req)
-{
- NTSTATUS status;
- ssize_t received;
- uint8_t *rcvbuf;
-
- status = cli_read_andx_recv(req, &received, &rcvbuf);
- if (!NT_STATUS_IS_OK(status)) {
- TALLOC_FREE(req);
- d_printf("cli_read_andx_recv returned %s\n",
- nt_errstr(status));
- return;
- }
-
- d_printf("got %d bytes: %.*s\n", (int)received, (int)received,
- (char *)rcvbuf);
- TALLOC_FREE(req);
-}
-
-static void chain1_write_completion(struct async_req *req)
+static void chain1_write_completion(struct tevent_req *req)
{
- NTSTATUS status;
size_t written;
-
+ NTSTATUS status;
status = cli_write_andx_recv(req, &written);
- if (!NT_STATUS_IS_OK(status)) {
- TALLOC_FREE(req);
- d_printf("cli_write_andx_recv returned %s\n",
- nt_errstr(status));
- return;
- }
-
- d_printf("wrote %d bytes\n", (int)written);
TALLOC_FREE(req);
+
+ d_printf("cli_write_andx_recv returned %s: %d\n",
+ nt_errstr(status),
+ NT_STATUS_IS_OK(status) ? (int)written : -1);
}
-static void chain1_close_completion(struct async_req *req)
+static void chain1_close_completion(struct tevent_req *req)
{
NTSTATUS status;
+ bool *done = (bool *)tevent_req_callback_data_void(req);
status = cli_close_recv(req);
- *((bool *)(req->async.priv)) = true;
+ *done = true;
TALLOC_FREE(req);
{
struct cli_state *cli1;
struct event_context *evt = event_context_init(NULL);
- struct async_req *reqs[4];
+ struct tevent_req *reqs[3], *smbreqs[3];
bool done = false;
- const char *text = "hallo";
+ const char *str = "foobar";
+ NTSTATUS status;
printf("starting chain1 test\n");
if (!torture_open_connection(&cli1, 0)) {
cli_sockopt(cli1, sockops);
- cli_chain_cork(cli1, evt, 0);
- reqs[0] = cli_open_send(talloc_tos(), evt, cli1, "\\test",
- O_CREAT|O_RDWR, 0);
- reqs[0]->async.fn = chain1_open_completion;
- reqs[1] = cli_write_andx_send(talloc_tos(), evt, cli1, 0, 0,
- (uint8_t *)text, 0, strlen(text));
- reqs[1]->async.fn = chain1_write_completion;
- reqs[2] = cli_read_andx_send(talloc_tos(), evt, cli1, 0, 1, 10);
- reqs[2]->async.fn = chain1_read_completion;
- reqs[3] = cli_close_send(talloc_tos(), evt, cli1, 0);
- reqs[3]->async.fn = chain1_close_completion;
- reqs[3]->async.priv = (void *)&done;
- cli_chain_uncork(cli1);
+ reqs[0] = cli_open_create(talloc_tos(), evt, cli1, "\\test",
+ O_CREAT|O_RDWR, 0, &smbreqs[0]);
+ if (reqs[0] == NULL) return false;
+ tevent_req_set_callback(reqs[0], chain1_open_completion, NULL);
+
+
+ reqs[1] = cli_write_andx_create(talloc_tos(), evt, cli1, 0, 0,
+ (uint8_t *)str, 0, strlen(str)+1,
+ smbreqs, 1, &smbreqs[1]);
+ if (reqs[1] == NULL) return false;
+ tevent_req_set_callback(reqs[1], chain1_write_completion, NULL);
+
+ reqs[2] = cli_close_create(talloc_tos(), evt, cli1, 0, &smbreqs[2]);
+ if (reqs[2] == NULL) return false;
+ tevent_req_set_callback(reqs[2], chain1_close_completion, &done);
+
+ status = cli_smb_chain_send(smbreqs, ARRAY_SIZE(smbreqs));
+ if (!NT_STATUS_IS_OK(status)) {
+ return false;
+ }
while (!done) {
event_loop_once(evt);
return True;
}
-static size_t null_source(uint8_t *buf, size_t n, void *priv)
+static void chain2_sesssetup_completion(struct tevent_req *req)
{
- size_t *to_pull = (size_t *)priv;
- size_t thistime = *to_pull;
-
- thistime = MIN(thistime, n);
- if (thistime == 0) {
- return 0;
- }
+ NTSTATUS status;
+ status = cli_session_setup_guest_recv(req);
+ d_printf("sesssetup returned %s\n", nt_errstr(status));
+}
- memset(buf, 0, thistime);
- *to_pull -= thistime;
- return thistime;
+static void chain2_tcon_completion(struct tevent_req *req)
+{
+ bool *done = (bool *)tevent_req_callback_data_void(req);
+ NTSTATUS status;
+ status = cli_tcon_andx_recv(req);
+ d_printf("tcon_and_x returned %s\n", nt_errstr(status));
+ *done = true;
}
-static bool run_windows_write(int dummy)
+static bool run_chain2(int dummy)
{
struct cli_state *cli1;
- int fnum;
- int i;
- bool ret = false;
- const char *fname = "\\writetest.txt";
- double seconds;
- double kbytes;
-
- printf("starting windows_write test\n");
- if (!torture_open_connection(&cli1, 0)) {
- return False;
- }
+ struct event_context *evt = event_context_init(NULL);
+ struct tevent_req *reqs[2], *smbreqs[2];
+ bool done = false;
+ NTSTATUS status;
- fnum = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- if (fnum == -1) {
- printf("open failed (%s)\n", cli_errstr(cli1));
+ printf("starting chain2 test\n");
+ status = cli_start_connection(&cli1, global_myname(), host, NULL,
+ port_to_use, Undefined, 0, NULL);
+ if (!NT_STATUS_IS_OK(status)) {
return False;
}
cli_sockopt(cli1, sockops);
- start_timer();
-
- for (i=0; i<torture_numops; i++) {
- char c = 0;
- off_t start = i * torture_blocksize;
- NTSTATUS status;
- size_t to_pull = torture_blocksize - 1;
+ reqs[0] = cli_session_setup_guest_create(talloc_tos(), evt, cli1,
+ &smbreqs[0]);
+ if (reqs[0] == NULL) return false;
+ tevent_req_set_callback(reqs[0], chain2_sesssetup_completion, NULL);
- if (cli_write(cli1, fnum, 0, &c,
- start + torture_blocksize - 1, 1) != 1) {
- printf("cli_write failed: %s\n", cli_errstr(cli1));
- goto fail;
- }
+ reqs[1] = cli_tcon_andx_create(talloc_tos(), evt, cli1, "IPC$",
+ "?????", NULL, 0, &smbreqs[1]);
+ if (reqs[1] == NULL) return false;
+ tevent_req_set_callback(reqs[1], chain2_tcon_completion, &done);
- status = cli_push(cli1, fnum, 0, i * torture_blocksize, torture_blocksize,
- null_source, &to_pull);
- if (!NT_STATUS_IS_OK(status)) {
- printf("cli_push returned: %s\n", nt_errstr(status));
- goto fail;
- }
+ status = cli_smb_chain_send(smbreqs, ARRAY_SIZE(smbreqs));
+ if (!NT_STATUS_IS_OK(status)) {
+ return false;
}
- seconds = end_timer();
- kbytes = (double)torture_blocksize * torture_numops;
- kbytes /= 1024;
-
- printf("Wrote %d kbytes in %.2f seconds: %d kb/sec\n", (int)kbytes,
- (double)seconds, (int)(kbytes/seconds));
+ while (!done) {
+ event_loop_once(evt);
+ }
- ret = true;
- fail:
- cli_close(cli1, fnum);
- cli_unlink(cli1, fname);
torture_close_connection(cli1);
- return ret;
+ return True;
}
-static bool run_cli_echo(int dummy)
-{
+
+struct torture_createdel_state {
+ struct tevent_context *ev;
struct cli_state *cli;
- struct event_context *ev = event_context_init(NULL);
- struct async_req *req;
- NTSTATUS status;
+};
- printf("starting chain1 test\n");
- if (!torture_open_connection(&cli, 0)) {
- return false;
- }
- cli_sockopt(cli, sockops);
+static void torture_createdel_created(struct tevent_req *subreq);
+static void torture_createdel_closed(struct tevent_req *subreq);
- req = cli_echo_send(ev, ev, cli, 5, data_blob_const("hello", 5));
+static struct tevent_req *torture_createdel_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct cli_state *cli,
+ const char *name)
+{
+ struct tevent_req *req, *subreq;
+ struct torture_createdel_state *state;
+
+ req = tevent_req_create(mem_ctx, &state,
+ struct torture_createdel_state);
if (req == NULL) {
- d_printf("cli_echo_send failed\n");
- return false;
+ return NULL;
}
+ state->ev = ev;
+ state->cli = cli;
- while (req->state < ASYNC_REQ_DONE) {
- event_loop_once(ev);
+ subreq = cli_ntcreate_send(
+ state, ev, cli, name, 0,
+ FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
+ FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
+ FILE_OPEN_IF, FILE_DELETE_ON_CLOSE, 0);
+
+ if (tevent_req_nomem(subreq, req)) {
+ return tevent_req_post(req, ev);
}
+ tevent_req_set_callback(subreq, torture_createdel_created, req);
+ return req;
+}
- status = cli_echo_recv(req);
- d_printf("cli_echo returned %s\n", nt_errstr(status));
+static void torture_createdel_created(struct tevent_req *subreq)
+{
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
+ struct torture_createdel_state *state = tevent_req_data(
+ req, struct torture_createdel_state);
+ NTSTATUS status;
+ uint16_t fnum;
- TALLOC_FREE(req);
+ status = cli_ntcreate_recv(subreq, &fnum);
+ TALLOC_FREE(subreq);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(10, ("cli_ntcreate_recv returned %s\n",
+ nt_errstr(status)));
+ tevent_req_nterror(req, status);
+ return;
+ }
- torture_close_connection(cli);
- return NT_STATUS_IS_OK(status);
+ subreq = cli_close_send(state, state->ev, state->cli, fnum);
+ if (tevent_req_nomem(subreq, req)) {
+ return;
+ }
+ tevent_req_set_callback(subreq, torture_createdel_closed, req);
}
-static bool run_local_substitute(int dummy)
+static void torture_createdel_closed(struct tevent_req *subreq)
+{
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
+ NTSTATUS status;
+
+ status = cli_close_recv(subreq);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(10, ("cli_close_recv returned %s\n", nt_errstr(status)));
+ tevent_req_nterror(req, status);
+ return;
+ }
+ tevent_req_done(req);
+}
+
+static NTSTATUS torture_createdel_recv(struct tevent_req *req)
+{
+ return tevent_req_simple_recv_ntstatus(req);
+}
+
+struct torture_createdels_state {
+ struct tevent_context *ev;
+ struct cli_state *cli;
+ const char *base_name;
+ int sent;
+ int received;
+ int num_files;
+ struct tevent_req **reqs;
+};
+
+static void torture_createdels_done(struct tevent_req *subreq);
+
+static struct tevent_req *torture_createdels_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct cli_state *cli,
+ const char *base_name,
+ int num_parallel,
+ int num_files)
+{
+ struct tevent_req *req;
+ struct torture_createdels_state *state;
+ int i;
+
+ req = tevent_req_create(mem_ctx, &state,
+ struct torture_createdels_state);
+ if (req == NULL) {
+ return NULL;
+ }
+ state->ev = ev;
+ state->cli = cli;
+ state->base_name = talloc_strdup(state, base_name);
+ if (tevent_req_nomem(state->base_name, req)) {
+ return tevent_req_post(req, ev);
+ }
+ state->num_files = MAX(num_parallel, num_files);
+ state->sent = 0;
+ state->received = 0;
+
+ state->reqs = talloc_array(state, struct tevent_req *, num_parallel);
+ if (tevent_req_nomem(state->reqs, req)) {
+ return tevent_req_post(req, ev);
+ }
+
+ for (i=0; i<num_parallel; i++) {
+ char *name;
+
+ name = talloc_asprintf(state, "%s%8.8d", state->base_name,
+ state->sent);
+ if (tevent_req_nomem(name, req)) {
+ return tevent_req_post(req, ev);
+ }
+ state->reqs[i] = torture_createdel_send(
+ state->reqs, state->ev, state->cli, name);
+ if (tevent_req_nomem(state->reqs[i], req)) {
+ return tevent_req_post(req, ev);
+ }
+ name = talloc_move(state->reqs[i], &name);
+ tevent_req_set_callback(state->reqs[i],
+ torture_createdels_done, req);
+ state->sent += 1;
+ }
+ return req;
+}
+
+static void torture_createdels_done(struct tevent_req *subreq)
+{
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
+ struct torture_createdels_state *state = tevent_req_data(
+ req, struct torture_createdels_state);
+ size_t num_parallel = talloc_array_length(state->reqs);
+ NTSTATUS status;
+ char *name;
+ int i;
+
+ status = torture_createdel_recv(subreq);
+ if (!NT_STATUS_IS_OK(status)){
+ DEBUG(10, ("torture_createdel_recv returned %s\n",
+ nt_errstr(status)));
+ TALLOC_FREE(subreq);
+ tevent_req_nterror(req, status);
+ return;
+ }
+
+ for (i=0; i<num_parallel; i++) {
+ if (subreq == state->reqs[i]) {
+ break;
+ }
+ }
+ if (i == num_parallel) {
+ DEBUG(10, ("received something we did not send\n"));
+ tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
+ return;
+ }
+ TALLOC_FREE(state->reqs[i]);
+
+ if (state->sent >= state->num_files) {
+ tevent_req_done(req);
+ return;
+ }
+
+ name = talloc_asprintf(state, "%s%8.8d", state->base_name,
+ state->sent);
+ if (tevent_req_nomem(name, req)) {
+ return;
+ }
+ state->reqs[i] = torture_createdel_send(state->reqs, state->ev,
+ state->cli, name);
+ if (tevent_req_nomem(state->reqs[i], req)) {
+ return;
+ }
+ name = talloc_move(state->reqs[i], &name);
+ tevent_req_set_callback(state->reqs[i], torture_createdels_done, req);
+ state->sent += 1;
+}
+
+static NTSTATUS torture_createdels_recv(struct tevent_req *req)
+{
+ return tevent_req_simple_recv_ntstatus(req);
+}
+
+struct swallow_notify_state {
+ struct tevent_context *ev;
+ struct cli_state *cli;
+ uint16_t fnum;
+ uint32_t completion_filter;
+ bool recursive;
+ bool (*fn)(uint32_t action, const char *name, void *priv);
+ void *priv;
+};
+
+static void swallow_notify_done(struct tevent_req *subreq);
+
+static struct tevent_req *swallow_notify_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct cli_state *cli,
+ uint16_t fnum,
+ uint32_t completion_filter,
+ bool recursive,
+ bool (*fn)(uint32_t action,
+ const char *name,
+ void *priv),
+ void *priv)
+{
+ struct tevent_req *req, *subreq;
+ struct swallow_notify_state *state;
+
+ req = tevent_req_create(mem_ctx, &state,
+ struct swallow_notify_state);
+ if (req == NULL) {
+ return NULL;
+ }
+ state->ev = ev;
+ state->cli = cli;
+ state->fnum = fnum;
+ state->completion_filter = completion_filter;
+ state->recursive = recursive;
+ state->fn = fn;
+ state->priv = priv;
+
+ subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
+ 0xffff, state->completion_filter,
+ state->recursive);
+ if (tevent_req_nomem(subreq, req)) {
+ return tevent_req_post(req, ev);
+ }
+ tevent_req_set_callback(subreq, swallow_notify_done, req);
+ return req;
+}
+
+static void swallow_notify_done(struct tevent_req *subreq)
+{
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
+ struct swallow_notify_state *state = tevent_req_data(
+ req, struct swallow_notify_state);
+ NTSTATUS status;
+ uint32_t i, num_changes;
+ struct notify_change *changes;
+
+ status = cli_notify_recv(subreq, state, &num_changes, &changes);
+ TALLOC_FREE(subreq);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(10, ("cli_notify_recv returned %s\n",
+ nt_errstr(status)));
+ tevent_req_nterror(req, status);
+ return;
+ }
+
+ for (i=0; i<num_changes; i++) {
+ state->fn(changes[i].action, changes[i].name, state->priv);
+ }
+ TALLOC_FREE(changes);
+
+ subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
+ 0xffff, state->completion_filter,
+ state->recursive);
+ if (tevent_req_nomem(subreq, req)) {
+ return;
+ }
+ tevent_req_set_callback(subreq, swallow_notify_done, req);
+}
+
+static bool print_notifies(uint32_t action, const char *name, void *priv)
+{
+ if (DEBUGLEVEL > 5) {
+ d_printf("%d %s\n", (int)action, name);
+ }
+ return true;
+}
+
+static void notify_bench_done(struct tevent_req *req)
+{
+ int *num_finished = (int *)tevent_req_callback_data_void(req);
+ *num_finished += 1;
+}
+
+static bool run_notify_bench(int dummy)
+{
+ const char *dname = "\\notify-bench";
+ struct tevent_context *ev;
+ NTSTATUS status;
+ uint16_t dnum;
+ struct tevent_req *req1, *req2;
+ int i, num_unc_names;
+ int num_finished = 0;
+
+ printf("starting notify-bench test\n");
+
+ if (use_multishare_conn) {
+ char **unc_list;
+ unc_list = file_lines_load(multishare_conn_fname,
+ &num_unc_names, 0, NULL);
+ if (!unc_list || num_unc_names <= 0) {
+ d_printf("Failed to load unc names list from '%s'\n",
+ multishare_conn_fname);
+ return false;
+ }
+ TALLOC_FREE(unc_list);
+ } else {
+ num_unc_names = 1;
+ }
+
+ ev = tevent_context_init(talloc_tos());
+ if (ev == NULL) {
+ d_printf("tevent_context_init failed\n");
+ return false;
+ }
+
+ for (i=0; i<num_unc_names; i++) {
+ struct cli_state *cli;
+ char *base_fname;
+
+ base_fname = talloc_asprintf(talloc_tos(), "%s\\file%3.3d.",
+ dname, i);
+ if (base_fname == NULL) {
+ return false;
+ }
+
+ if (!torture_open_connection(&cli, i)) {
+ return false;
+ }
+
+ status = cli_ntcreate(cli, dname, 0,
+ MAXIMUM_ALLOWED_ACCESS,
+ 0, FILE_SHARE_READ|FILE_SHARE_WRITE|
+ FILE_SHARE_DELETE,
+ FILE_OPEN_IF, FILE_DIRECTORY_FILE, 0,
+ &dnum);
+
+ if (!NT_STATUS_IS_OK(status)) {
+ d_printf("Could not create %s: %s\n", dname,
+ nt_errstr(status));
+ return false;
+ }
+
+ req1 = swallow_notify_send(talloc_tos(), ev, cli, dnum,
+ FILE_NOTIFY_CHANGE_FILE_NAME |
+ FILE_NOTIFY_CHANGE_DIR_NAME |
+ FILE_NOTIFY_CHANGE_ATTRIBUTES |
+ FILE_NOTIFY_CHANGE_LAST_WRITE,
+ false, print_notifies, NULL);
+ if (req1 == NULL) {
+ d_printf("Could not create notify request\n");
+ return false;
+ }
+
+ req2 = torture_createdels_send(talloc_tos(), ev, cli,
+ base_fname, 10, torture_numops);
+ if (req2 == NULL) {
+ d_printf("Could not create createdels request\n");
+ return false;
+ }
+ TALLOC_FREE(base_fname);
+
+ tevent_req_set_callback(req2, notify_bench_done,
+ &num_finished);
+ }
+
+ while (num_finished < num_unc_names) {
+ int ret;
+ ret = tevent_loop_once(ev);
+ if (ret != 0) {
+ d_printf("tevent_loop_once failed\n");
+ return false;
+ }
+ }
+
+ if (!tevent_req_poll(req2, ev)) {
+ d_printf("tevent_req_poll failed\n");
+ }
+
+ status = torture_createdels_recv(req2);
+ d_printf("torture_createdels_recv returned %s\n", nt_errstr(status));
+
+ return true;
+}
+
+static bool run_mangle1(int dummy)
+{
+ struct cli_state *cli;
+ const char *fname = "this_is_a_long_fname_to_be_mangled.txt";
+ uint16_t fnum;
+ fstring alt_name;
+ NTSTATUS status;
+ time_t change_time, access_time, write_time;
+ SMB_OFF_T size;
+ uint16_t mode;
+
+ printf("starting mangle1 test\n");
+ if (!torture_open_connection(&cli, 0)) {
+ return False;
+ }
+
+ cli_sockopt(cli, sockops);
+
+ if (!NT_STATUS_IS_OK(cli_ntcreate(
+ cli, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
+ FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, 0, 0, &fnum))) {
+ d_printf("open %s failed: %s\n", fname, cli_errstr(cli));
+ return false;
+ }
+ cli_close(cli, fnum);
+
+ status = cli_qpathinfo_alt_name(cli, fname, alt_name);
+ if (!NT_STATUS_IS_OK(status)) {
+ d_printf("cli_qpathinfo_alt_name failed: %s\n",
+ nt_errstr(status));
+ return false;
+ }
+ d_printf("alt_name: %s\n", alt_name);
+
+ if (!NT_STATUS_IS_OK(cli_open(cli, alt_name, O_RDONLY, DENY_NONE, &fnum))) {
+ d_printf("cli_open(%s) failed: %s\n", alt_name,
+ cli_errstr(cli));
+ return false;
+ }
+ cli_close(cli, fnum);
+
+ if (!cli_qpathinfo(cli, alt_name, &change_time, &access_time,
+ &write_time, &size, &mode)) {
+ d_printf("cli_qpathinfo(%s) failed: %s\n", alt_name,
+ cli_errstr(cli));
+ return false;
+ }
+
+ return true;
+}
+
+static size_t null_source(uint8_t *buf, size_t n, void *priv)
+{
+ size_t *to_pull = (size_t *)priv;
+ size_t thistime = *to_pull;
+
+ thistime = MIN(thistime, n);
+ if (thistime == 0) {
+ return 0;
+ }
+
+ memset(buf, 0, thistime);
+ *to_pull -= thistime;
+ return thistime;
+}
+
+static bool run_windows_write(int dummy)
+{
+ struct cli_state *cli1;
+ uint16_t fnum;
+ int i;
+ bool ret = false;
+ const char *fname = "\\writetest.txt";
+ struct timeval start;
+ double seconds;
+ double kbytes;
+
+ printf("starting windows_write test\n");
+ if (!torture_open_connection(&cli1, 0)) {
+ return False;
+ }
+
+ if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
+ printf("open failed (%s)\n", cli_errstr(cli1));
+ return False;
+ }
+
+ cli_sockopt(cli1, sockops);
+
+ start = timeval_current();
+
+ for (i=0; i<torture_numops; i++) {
+ char c = 0;
+ off_t start = i * torture_blocksize;
+ NTSTATUS status;
+ size_t to_pull = torture_blocksize - 1;
+
+ if (cli_write(cli1, fnum, 0, &c,
+ start + torture_blocksize - 1, 1) != 1) {
+ printf("cli_write failed: %s\n", cli_errstr(cli1));
+ goto fail;
+ }
+
+ status = cli_push(cli1, fnum, 0, i * torture_blocksize, torture_blocksize,
+ null_source, &to_pull);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("cli_push returned: %s\n", nt_errstr(status));
+ goto fail;
+ }
+ }
+
+ seconds = timeval_elapsed(&start);
+ kbytes = (double)torture_blocksize * torture_numops;
+ kbytes /= 1024;
+
+ printf("Wrote %d kbytes in %.2f seconds: %d kb/sec\n", (int)kbytes,
+ (double)seconds, (int)(kbytes/seconds));
+
+ ret = true;
+ fail:
+ cli_close(cli1, fnum);
+ cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
+ torture_close_connection(cli1);
+ return ret;
+}
+
+static bool run_cli_echo(int dummy)
+{
+ struct cli_state *cli;
+ NTSTATUS status;
+
+ printf("starting cli_echo test\n");
+ if (!torture_open_connection(&cli, 0)) {
+ return false;
+ }
+ cli_sockopt(cli, sockops);
+
+ status = cli_echo(cli, 5, data_blob_const("hello", 5));
+
+ d_printf("cli_echo returned %s\n", nt_errstr(status));
+
+ torture_close_connection(cli);
+ return NT_STATUS_IS_OK(status);
+}
+
+static bool run_uid_regression_test(int dummy)
+{
+ static struct cli_state *cli;
+ int16_t old_vuid;
+ int16_t old_cnum;
+ bool correct = True;
+
+ printf("starting uid regression test\n");
+
+ if (!torture_open_connection(&cli, 0)) {
+ return False;
+ }
+
+ cli_sockopt(cli, sockops);
+
+ /* Ok - now save then logoff our current user. */
+ old_vuid = cli->vuid;
+
+ if (!cli_ulogoff(cli)) {
+ d_printf("(%s) cli_ulogoff failed: %s\n",
+ __location__, cli_errstr(cli));
+ correct = false;
+ goto out;
+ }
+
+ cli->vuid = old_vuid;
+
+ /* Try an operation. */
+ if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\uid_reg_test"))) {
+ /* We expect bad uid. */
+ if (!check_error(__LINE__, cli, ERRSRV, ERRbaduid,
+ NT_STATUS_NO_SUCH_USER)) {
+ return False;
+ }
+ }
+
+ old_cnum = cli->cnum;
+
+ /* Now try a SMBtdis with the invald vuid set to zero. */
+ cli->vuid = 0;
+
+ /* This should succeed. */
+ if (cli_tdis(cli)) {
+ printf("First tdis with invalid vuid should succeed.\n");
+ } else {
+ printf("First tdis failed (%s)\n", cli_errstr(cli));
+ }
+
+ cli->vuid = old_vuid;
+ cli->cnum = old_cnum;
+
+ /* This should fail. */
+ if (cli_tdis(cli)) {
+ printf("Second tdis with invalid vuid should fail - succeeded instead !.\n");
+ } else {
+ /* Should be bad tid. */
+ if (!check_error(__LINE__, cli, ERRSRV, ERRinvnid,
+ NT_STATUS_NETWORK_NAME_DELETED)) {
+ return False;
+ }
+ }
+
+ cli_rmdir(cli, "\\uid_reg_test");
+
+ out:
+
+ cli_shutdown(cli);
+ return correct;
+}
+
+
+static const char *illegal_chars = "*\\/?<>|\":";
+static char force_shortname_chars[] = " +,.[];=\177";
+
+static void shortname_del_fn(const char *mnt, file_info *finfo, const char *mask, void *state)
+{
+ struct cli_state *pcli = (struct cli_state *)state;
+ fstring fname;
+ slprintf(fname, sizeof(fname), "\\shortname\\%s", finfo->name);
+
+ if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
+ return;
+
+ if (finfo->mode & aDIR) {
+ if (!NT_STATUS_IS_OK(cli_rmdir(pcli, fname)))
+ printf("del_fn: failed to rmdir %s\n,", fname );
+ } else {
+ if (!NT_STATUS_IS_OK(cli_unlink(pcli, fname, aSYSTEM | aHIDDEN)))
+ printf("del_fn: failed to unlink %s\n,", fname );
+ }
+}
+
+struct sn_state {
+ int i;
+ bool val;
+};
+
+static void shortname_list_fn(const char *mnt, file_info *finfo, const char *name, void *state)
+{
+ struct sn_state *s = (struct sn_state *)state;
+ int i = s->i;
+
+#if 0
+ printf("shortname list: i = %d, name = |%s|, shortname = |%s|\n",
+ i, finfo->name, finfo->short_name);
+#endif
+
+ if (strchr(force_shortname_chars, i)) {
+ if (!finfo->short_name[0]) {
+ /* Shortname not created when it should be. */
+ d_printf("(%s) ERROR: Shortname was not created for file %s containing %d\n",
+ __location__, finfo->name, i);
+ s->val = true;
+ }
+ } else if (finfo->short_name[0]){
+ /* Shortname created when it should not be. */
+ d_printf("(%s) ERROR: Shortname %s was created for file %s\n",
+ __location__, finfo->short_name, finfo->name);
+ s->val = true;
+ }
+}
+
+static bool run_shortname_test(int dummy)
+{
+ static struct cli_state *cli;
+ bool correct = True;
+ int i;
+ struct sn_state s;
+ char fname[20];
+
+ printf("starting shortname test\n");
+
+ if (!torture_open_connection(&cli, 0)) {
+ return False;
+ }
+
+ cli_sockopt(cli, sockops);
+
+ cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
+ cli_list(cli, "\\shortname\\*", aDIR, shortname_del_fn, cli);
+ cli_rmdir(cli, "\\shortname");
+
+ if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\shortname"))) {
+ d_printf("(%s) cli_mkdir of \\shortname failed: %s\n",
+ __location__, cli_errstr(cli));
+ correct = false;
+ goto out;
+ }
+
+ strlcpy(fname, "\\shortname\\", sizeof(fname));
+ strlcat(fname, "test .txt", sizeof(fname));
+
+ s.val = false;
+
+ for (i = 32; i < 128; i++) {
+ NTSTATUS status;
+ uint16_t fnum = (uint16_t)-1;
+
+ s.i = i;
+
+ if (strchr(illegal_chars, i)) {
+ continue;
+ }
+ fname[15] = i;
+
+ status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
+ FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum);
+ if (!NT_STATUS_IS_OK(status)) {
+ d_printf("(%s) cli_nt_create of %s failed: %s\n",
+ __location__, fname, cli_errstr(cli));
+ correct = false;
+ goto out;
+ }
+ cli_close(cli, fnum);
+ if (cli_list(cli, "\\shortname\\test*.*", 0, shortname_list_fn, &s) != 1) {
+ d_printf("(%s) failed to list %s: %s\n",
+ __location__, fname, cli_errstr(cli));
+ correct = false;
+ goto out;
+ }
+ if (!NT_STATUS_IS_OK(cli_unlink(cli, fname, aSYSTEM | aHIDDEN))) {
+ d_printf("(%s) failed to delete %s: %s\n",
+ __location__, fname, cli_errstr(cli));
+ correct = false;
+ goto out;
+ }
+
+ if (s.val) {
+ correct = false;
+ goto out;
+ }
+ }
+
+ out:
+
+ cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
+ cli_list(cli, "\\shortname\\*", aDIR, shortname_del_fn, cli);
+ cli_rmdir(cli, "\\shortname");
+ torture_close_connection(cli);
+ return correct;
+}
+
+static void pagedsearch_cb(struct tevent_req *req)
+{
+ int rc;
+ struct tldap_message *msg;
+ char *dn;
+
+ rc = tldap_search_paged_recv(req, talloc_tos(), &msg);
+ if (rc != TLDAP_SUCCESS) {
+ d_printf("tldap_search_paged_recv failed: %s\n",
+ tldap_err2string(rc));
+ return;
+ }
+ if (tldap_msg_type(msg) != TLDAP_RES_SEARCH_ENTRY) {
+ TALLOC_FREE(msg);
+ return;
+ }
+ if (!tldap_entry_dn(msg, &dn)) {
+ d_printf("tldap_entry_dn failed\n");
+ return;
+ }
+ d_printf("%s\n", dn);
+ TALLOC_FREE(msg);
+}
+
+static bool run_tldap(int dummy)
+{
+ struct tldap_context *ld;
+ int fd, rc;
+ NTSTATUS status;
+ struct sockaddr_storage addr;
+ struct tevent_context *ev;
+ struct tevent_req *req;
+ char *basedn;
+
+ if (!resolve_name(host, &addr, 0, false)) {
+ d_printf("could not find host %s\n", host);
+ return false;
+ }
+ status = open_socket_out(&addr, 389, 9999, &fd);
+ if (!NT_STATUS_IS_OK(status)) {
+ d_printf("open_socket_out failed: %s\n", nt_errstr(status));
+ return false;
+ }
+
+ ld = tldap_context_create(talloc_tos(), fd);
+ if (ld == NULL) {
+ close(fd);
+ d_printf("tldap_context_create failed\n");
+ return false;
+ }
+
+ rc = tldap_fetch_rootdse(ld);
+ if (rc != TLDAP_SUCCESS) {
+ d_printf("tldap_fetch_rootdse failed: %s\n",
+ tldap_errstr(talloc_tos(), ld, rc));
+ return false;
+ }
+
+ basedn = tldap_talloc_single_attribute(
+ tldap_rootdse(ld), "defaultNamingContext", talloc_tos());
+ if (basedn == NULL) {
+ d_printf("no defaultNamingContext\n");
+ return false;
+ }
+ d_printf("defaultNamingContext: %s\n", basedn);
+
+ ev = tevent_context_init(talloc_tos());
+ if (ev == NULL) {
+ d_printf("tevent_context_init failed\n");
+ return false;
+ }
+
+ req = tldap_search_paged_send(talloc_tos(), ev, ld, basedn,
+ TLDAP_SCOPE_SUB, "(objectclass=*)",
+ NULL, 0, 0,
+ NULL, 0, NULL, 0, 0, 0, 0, 5);
+ if (req == NULL) {
+ d_printf("tldap_search_paged_send failed\n");
+ return false;
+ }
+ tevent_req_set_callback(req, pagedsearch_cb, NULL);
+
+ tevent_req_poll(req, ev);
+
+ TALLOC_FREE(req);
+
+ TALLOC_FREE(ld);
+ return true;
+}
+
+static bool run_streamerror(int dummy)
+{
+ struct cli_state *cli;
+ const char *dname = "\\testdir";
+ const char *streamname =
+ "testdir:{4c8cc155-6c1e-11d1-8e41-00c04fb9386d}:$DATA";
+ NTSTATUS status;
+ time_t change_time, access_time, write_time;
+ SMB_OFF_T size;
+ uint16_t mode, fnum;
+ bool ret = true;
+
+ if (!torture_open_connection(&cli, 0)) {
+ return false;
+ }
+
+ cli_rmdir(cli, dname);
+
+ status = cli_mkdir(cli, dname);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("mkdir failed: %s\n", nt_errstr(status));
+ return false;
+ }
+
+ cli_qpathinfo(cli, streamname, &change_time, &access_time, &write_time,
+ &size, &mode);
+ status = cli_nt_error(cli);
+
+ if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+ printf("pathinfo returned %s, expected "
+ "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
+ nt_errstr(status));
+ ret = false;
+ }
+
+ status = cli_ntcreate(cli, streamname, 0x16,
+ FILE_READ_DATA|FILE_READ_EA|
+ FILE_READ_ATTRIBUTES|READ_CONTROL_ACCESS,
+ FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
+ FILE_OPEN, 0, 0, &fnum);
+
+ if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+ printf("ntcreate returned %s, expected "
+ "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
+ nt_errstr(status));
+ ret = false;
+ }
+
+
+ cli_rmdir(cli, dname);
+ return ret;
+}
+
+static bool run_local_substitute(int dummy)
{
bool ok = true;
return ok;
}
+static bool run_local_base64(int dummy)
+{
+ int i;
+ bool ret = true;
+
+ for (i=1; i<2000; i++) {
+ DATA_BLOB blob1, blob2;
+ char *b64;
+
+ blob1.data = talloc_array(talloc_tos(), uint8_t, i);
+ blob1.length = i;
+ generate_random_buffer(blob1.data, blob1.length);
+
+ b64 = base64_encode_data_blob(talloc_tos(), blob1);
+ if (b64 == NULL) {
+ d_fprintf(stderr, "base64_encode_data_blob failed "
+ "for %d bytes\n", i);
+ ret = false;
+ }
+ blob2 = base64_decode_data_blob(b64);
+ TALLOC_FREE(b64);
+
+ if (data_blob_cmp(&blob1, &blob2)) {
+ d_fprintf(stderr, "data_blob_cmp failed for %d "
+ "bytes\n", i);
+ ret = false;
+ }
+ TALLOC_FREE(blob1.data);
+ data_blob_free(&blob2);
+ }
+ return ret;
+}
+
static bool run_local_gencache(int dummy)
{
char *val;
time_t tm;
DATA_BLOB blob;
- if (!gencache_init()) {
- d_printf("%s: gencache_init() failed\n", __location__);
+ if (!gencache_set("foo", "bar", time(NULL) + 1000)) {
+ d_printf("%s: gencache_set() failed\n", __location__);
return False;
}
- if (!gencache_set("foo", "bar", time(NULL) + 1000)) {
- d_printf("%s: gencache_set() failed\n", __location__);
+ if (!gencache_get("foo", NULL, NULL)) {
+ d_printf("%s: gencache_get() failed\n", __location__);
return False;
}
__location__);
return False;
}
-
+
if (gencache_get("foo", &val, &tm)) {
d_printf("%s: gencache_get() on deleted entry "
"succeeded\n", __location__);
}
blob = data_blob_string_const_null("bar");
- tm = time(NULL);
+ tm = time(NULL) + 60;
if (!gencache_set_data_blob("foo", &blob, tm)) {
d_printf("%s: gencache_set_data_blob() failed\n", __location__);
return False;
}
- data_blob_free(&blob);
-
- if (!gencache_get_data_blob("foo", &blob, NULL)) {
+ if (!gencache_get_data_blob("foo", &blob, NULL, NULL)) {
d_printf("%s: gencache_get_data_blob() failed\n", __location__);
return False;
}
return False;
}
- if (gencache_get_data_blob("foo", &blob, NULL)) {
+ if (gencache_get_data_blob("foo", &blob, NULL, NULL)) {
d_printf("%s: gencache_get_data_blob() on deleted entry "
"succeeded\n", __location__);
return False;
}
- if (!gencache_shutdown()) {
- d_printf("%s: gencache_shutdown() failed\n", __location__);
- return False;
- }
-
- if (gencache_shutdown()) {
- d_printf("%s: second gencache_shutdown() succeeded\n",
- __location__);
- return False;
- }
-
return True;
}
return ret;
}
+struct talloc_dict_test {
+ int content;
+};
+
+static int talloc_dict_traverse_fn(DATA_BLOB key, void *data, void *priv)
+{
+ int *count = (int *)priv;
+ *count += 1;
+ return 0;
+}
+
+static bool run_local_talloc_dict(int dummy)
+{
+ struct talloc_dict *dict;
+ struct talloc_dict_test *t;
+ int key, count;
+
+ dict = talloc_dict_init(talloc_tos());
+ if (dict == NULL) {
+ return false;
+ }
+
+ t = talloc(talloc_tos(), struct talloc_dict_test);
+ if (t == NULL) {
+ return false;
+ }
+
+ key = 1;
+ t->content = 1;
+ if (!talloc_dict_set(dict, data_blob_const(&key, sizeof(key)), t)) {
+ return false;
+ }
+
+ count = 0;
+ if (talloc_dict_traverse(dict, talloc_dict_traverse_fn, &count) != 0) {
+ return false;
+ }
+
+ if (count != 1) {
+ return false;
+ }
+
+ TALLOC_FREE(dict);
+
+ return true;
+}
+
+/* Split a path name into filename and stream name components. Canonicalise
+ * such that an implicit $DATA token is always explicit.
+ *
+ * The "specification" of this function can be found in the
+ * run_local_stream_name() function in torture.c, I've tried those
+ * combinations against a W2k3 server.
+ */
+
+static NTSTATUS split_ntfs_stream_name(TALLOC_CTX *mem_ctx, const char *fname,
+ char **pbase, char **pstream)
+{
+ char *base = NULL;
+ char *stream = NULL;
+ char *sname; /* stream name */
+ const char *stype; /* stream type */
+
+ DEBUG(10, ("split_ntfs_stream_name called for [%s]\n", fname));
+
+ sname = strchr_m(fname, ':');
+
+ if (lp_posix_pathnames() || (sname == NULL)) {
+ if (pbase != NULL) {
+ base = talloc_strdup(mem_ctx, fname);
+ NT_STATUS_HAVE_NO_MEMORY(base);
+ }
+ goto done;
+ }
+
+ if (pbase != NULL) {
+ base = talloc_strndup(mem_ctx, fname, PTR_DIFF(sname, fname));
+ NT_STATUS_HAVE_NO_MEMORY(base);
+ }
+
+ sname += 1;
+
+ stype = strchr_m(sname, ':');
+
+ if (stype == NULL) {
+ sname = talloc_strdup(mem_ctx, sname);
+ stype = "$DATA";
+ }
+ else {
+ if (StrCaseCmp(stype, ":$DATA") != 0) {
+ /*
+ * If there is an explicit stream type, so far we only
+ * allow $DATA. Is there anything else allowed? -- vl
+ */
+ DEBUG(10, ("[%s] is an invalid stream type\n", stype));
+ TALLOC_FREE(base);
+ return NT_STATUS_OBJECT_NAME_INVALID;
+ }
+ sname = talloc_strndup(mem_ctx, sname, PTR_DIFF(stype, sname));
+ stype += 1;
+ }
+
+ if (sname == NULL) {
+ TALLOC_FREE(base);
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ if (sname[0] == '\0') {
+ /*
+ * no stream name, so no stream
+ */
+ goto done;
+ }
+
+ if (pstream != NULL) {
+ stream = talloc_asprintf(mem_ctx, "%s:%s", sname, stype);
+ if (stream == NULL) {
+ TALLOC_FREE(sname);
+ TALLOC_FREE(base);
+ return NT_STATUS_NO_MEMORY;
+ }
+ /*
+ * upper-case the type field
+ */
+ strupper_m(strchr_m(stream, ':')+1);
+ }
+
+ done:
+ if (pbase != NULL) {
+ *pbase = base;
+ }
+ if (pstream != NULL) {
+ *pstream = stream;
+ }
+ return NT_STATUS_OK;
+}
+
static bool test_stream_name(const char *fname, const char *expected_base,
const char *expected_stream,
NTSTATUS expected_status)
BlockSignals(True, SIGPIPE);
- ev = event_context_init(talloc_tos());
+ ev = tevent_context_init_byname(talloc_tos(), "epoll");
if (ev == NULL) {
goto fail;
}
- wb_ctx = TALLOC_ARRAY(ev, struct wb_context *, torture_numops);
+ wb_ctx = TALLOC_ARRAY(ev, struct wb_context *, nprocs);
if (wb_ctx == NULL) {
goto fail;
}
ZERO_STRUCT(wb_req);
wb_req.cmd = WINBINDD_PING;
- for (i=0; i<torture_numops; i++) {
- wb_ctx[i] = wb_context_init(ev);
+ d_printf("nprocs=%d, numops=%d\n", (int)nprocs, (int)torture_numops);
+
+ for (i=0; i<nprocs; i++) {
+ wb_ctx[i] = wb_context_init(ev, NULL);
if (wb_ctx[i] == NULL) {
goto fail;
}
- for (j=0; j<5; j++) {
+ for (j=0; j<torture_numops; j++) {
struct tevent_req *req;
req = wb_trans_send(ev, ev, wb_ctx[i],
(j % 2) == 0, &wb_req);
i = 0;
- while (i < 5 * torture_numops) {
+ while (i < nprocs * torture_numops) {
event_loop_once(ev);
}
return result;
}
+static void getaddrinfo_finished(struct tevent_req *req)
+{
+ char *name = (char *)tevent_req_callback_data_void(req);
+ struct addrinfo *ainfo;
+ int res;
+
+ res = getaddrinfo_recv(req, &ainfo);
+ if (res != 0) {
+ d_printf("gai(%s) returned %s\n", name, gai_strerror(res));
+ return;
+ }
+ d_printf("gai(%s) succeeded\n", name);
+ freeaddrinfo(ainfo);
+}
+
+static bool run_getaddrinfo_send(int dummy)
+{
+ TALLOC_CTX *frame = talloc_stackframe();
+ struct fncall_context *ctx;
+ struct tevent_context *ev;
+ bool result = false;
+ const char *names[4] = { "www.samba.org", "notfound.samba.org",
+ "www.slashdot.org", "heise.de" };
+ struct tevent_req *reqs[4];
+ int i;
+
+ ev = event_context_init(frame);
+ if (ev == NULL) {
+ goto fail;
+ }
+
+ ctx = fncall_context_init(frame, 4);
+
+ for (i=0; i<ARRAY_SIZE(names); i++) {
+ reqs[i] = getaddrinfo_send(frame, ev, ctx, names[i], NULL,
+ NULL);
+ if (reqs[i] == NULL) {
+ goto fail;
+ }
+ tevent_req_set_callback(reqs[i], getaddrinfo_finished,
+ (void *)names[i]);
+ }
+
+ for (i=0; i<ARRAY_SIZE(reqs); i++) {
+ tevent_loop_once(ev);
+ }
+
+ result = true;
+fail:
+ TALLOC_FREE(frame);
+ return result;
+}
+
+
static double create_procs(bool (*fn)(int), bool *result)
{
int i, status;
volatile bool *child_status_out;
int synccount;
int tries = 8;
+ struct timeval start;
synccount = 0;
child_status_out[i] = True;
}
- start_timer();
+ start = timeval_current();
for (i=0;i<nprocs;i++) {
procnum = i;
child_status[i] = getpid();
- while (child_status[i] && end_timer() < 5) smb_msleep(2);
+ while (child_status[i] && timeval_elapsed(&start) < 5) smb_msleep(2);
child_status_out[i] = fn(i);
_exit(0);
}
if (synccount == nprocs) break;
smb_msleep(10);
- } while (end_timer() < 30);
+ } while (timeval_elapsed(&start) < 30);
if (synccount != nprocs) {
printf("FAILED TO START %d CLIENTS (started %d)\n", nprocs, synccount);
*result = False;
- return end_timer();
+ return timeval_elapsed(&start);
}
/* start the client load */
- start_timer();
+ start = timeval_current();
for (i=0;i<nprocs;i++) {
child_status[i] = 0;
}
printf("\n");
-
+
for (i=0;i<nprocs;i++) {
if (!child_status_out[i]) {
*result = False;
}
}
- return end_timer();
+ return timeval_elapsed(&start);
}
#define FLAG_MULTIPROC 1
{"LOCK5", run_locktest5, 0},
{"LOCK6", run_locktest6, 0},
{"LOCK7", run_locktest7, 0},
+ {"LOCK8", run_locktest8, 0},
+ {"LOCK9", run_locktest9, 0},
{"UNLINK", run_unlinktest, 0},
{"BROWSE", run_browsetest, 0},
{"ATTR", run_attrtest, 0},
{"RW3", run_readwritelarge, 0},
{"OPEN", run_opentest, 0},
{"POSIX", run_simple_posix_open_test, 0},
+ { "UID-REGRESSION-TEST", run_uid_regression_test, 0},
+ { "SHORTNAME-TEST", run_shortname_test, 0},
#if 1
{"OPENATTR", run_openattrtest, 0},
#endif
{"DELETE", run_deletetest, 0},
{"PROPERTIES", run_properties, 0},
{"MANGLE", torture_mangle, 0},
+ {"MANGLE1", run_mangle1, 0},
{"W2K", run_w2ktest, 0},
{"TRANS2SCAN", torture_trans2_scan, 0},
{"NTTRANSSCAN", torture_nttrans_scan, 0},
{ "EATEST", run_eatest, 0},
{ "SESSSETUP_BENCH", run_sesssetup_bench, 0},
{ "CHAIN1", run_chain1, 0},
+ { "CHAIN2", run_chain2, 0},
{ "WINDOWS-WRITE", run_windows_write, 0},
{ "CLI_ECHO", run_cli_echo, 0},
+ { "GETADDRINFO", run_getaddrinfo_send, 0},
+ { "TLDAP", run_tldap },
+ { "STREAMERROR", run_streamerror },
+ { "NOTIFY-BENCH", run_notify_bench },
{ "LOCAL-SUBSTITUTE", run_local_substitute, 0},
{ "LOCAL-GENCACHE", run_local_gencache, 0},
+ { "LOCAL-TALLOC-DICT", run_local_talloc_dict, 0},
+ { "LOCAL-BASE64", run_local_base64, 0},
{ "LOCAL-RBTREE", run_local_rbtree, 0},
{ "LOCAL-MEMCACHE", run_local_memcache, 0},
{ "LOCAL-STREAM-NAME", run_local_stream_name, 0},
}
found = True;
}
-
+
for (i=0;torture_ops[i].name;i++) {
fstr_sprintf(randomfname, "\\XX%x",
(unsigned)random());
ret = False;
printf("TEST %s FAILED!\n", name);
}
-
} else {
- start_timer();
+ struct timeval start;
+ start = timeval_current();
if (!torture_ops[i].fn(0)) {
ret = False;
printf("TEST %s FAILED!\n", name);
}
- t = end_timer();
+ t = timeval_elapsed(&start);
}
printf("%s took %g secs\n\n", name, t);
}
printf("\n");
printf("default test is ALL\n");
-
+
exit(1);
}
for(p = argv[1]; *p; p++)
if(*p == '\\')
*p = '/';
-
+
if (strncmp(argv[1], "//", 2)) {
usage();
}
fstrcpy(workgroup, lp_workgroup());
- while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ld:Aec:ks:b:B:")) != EOF) {
+ while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ll:d:Aec:ks:b:B:")) != EOF) {
switch (opt) {
case 'p':
port_to_use = atoi(optarg);
case 'L':
use_oplocks = True;
break;
+ case 'l':
+ local_path = optarg;
+ break;
case 'A':
torture_showall = True;
break;
git.samba.org / ira / wip.git / blobdiff