#include "includes.h"
#include "system/time.h"
#include "system/filesys.h"
-#include "request.h"
+#include "libcli/raw/request.h"
#include "libcli/libcli.h"
#include "libcli/raw/libcliraw.h"
-#include "librpc/gen_ndr/ndr_security.h"
+#include "librpc/gen_ndr/security.h"
#include "auth/gensec/gensec.h"
#define NSERVERS 2
static struct {
int notify_count;
NTSTATUS status;
- struct smb_notify notify;
+ union smb_notify notify;
} notifies[NSERVERS][NINSTANCES];
/* info relevant to the current operation */
static uint_t time_skew(void)
{
uint_t ret;
- ret = ABS(servers[0].cli[0]->transport->negotiate.server_time -
+ ret = labs(servers[0].cli[0]->transport->negotiate.server_time -
servers[1].cli[0]->transport->negotiate.server_time);
return ret + 300;
}
"ASOMEWHATLONGERATTRIBUTEVALUE"};
int i;
+ ZERO_STRUCT(ea);
+
do {
i = gen_int_range(0, ARRAY_SIZE(names)-1);
} while (ignore_pattern(names[i]));
*/
static void async_notify(struct smbcli_request *req)
{
- struct smb_notify notify;
+ union smb_notify notify;
NTSTATUS status;
int i, j;
uint16_t tid;
tid = SVAL(req->in.hdr, HDR_TID);
+ notify.nttrans.level = RAW_NOTIFY_NTTRANS;
status = smb_raw_changenotify_recv(req, current_op.mem_ctx, ¬ify);
if (NT_STATUS_IS_OK(status)) {
printf("notify tid=%d num_changes=%d action=%d name=%s\n",
tid,
- notify.out.num_changes,
- notify.out.changes[0].action,
- notify.out.changes[0].name.s);
+ notify.nttrans.out.num_changes,
+ notify.nttrans.out.changes[0].action,
+ notify.nttrans.out.changes[0].name.s);
}
for (i=0;i<NSERVERS;i++) {
static BOOL oplock_handler(struct smbcli_transport *transport, uint16_t tid, uint16_t fnum, uint8_t level, void *private)
{
union smb_close io;
- NTSTATUS status;
int i, j;
BOOL do_close;
struct smbcli_tree *tree = NULL;
printf("oplock close fnum=%d\n", fnum);
io.close.level = RAW_CLOSE_CLOSE;
- io.close.in.fnum = fnum;
+ io.close.in.file.fnum = fnum;
io.close.in.write_time = 0;
req = smb_raw_close_send(tree, &io);
if (req == NULL) {
- printf("WARNING: close failed in oplock_handler_close - %s\n",
- nt_errstr(status));
+ printf("WARNING: close failed in oplock_handler_close\n");
return False;
}
for (j=0;j<NINSTANCES;j++) {
for (i=1;i<NSERVERS;i++) {
int n;
- struct smb_notify not1, not2;
+ union smb_notify not1, not2;
if (notifies[0][j].notify_count != notifies[i][j].notify_count) {
if (tries++ < 10) goto again;
not1 = notifies[0][j].notify;
not2 = notifies[i][j].notify;
- for (n=0;n<not1.out.num_changes;n++) {
- if (not1.out.changes[n].action !=
- not2.out.changes[n].action) {
+ for (n=0;n<not1.nttrans.out.num_changes;n++) {
+ if (not1.nttrans.out.changes[n].action !=
+ not2.nttrans.out.changes[n].action) {
printf("Notify action %d inconsistent %d %d\n", n,
- not1.out.changes[n].action,
- not2.out.changes[n].action);
+ not1.nttrans.out.changes[n].action,
+ not2.nttrans.out.changes[n].action);
return False;
}
- if (strcmp(not1.out.changes[n].name.s,
- not2.out.changes[n].name.s)) {
+ if (strcmp(not1.nttrans.out.changes[n].name.s,
+ not2.nttrans.out.changes[n].name.s)) {
printf("Notify name %d inconsistent %s %s\n", n,
- not1.out.changes[n].name.s,
- not2.out.changes[n].name.s);
+ not1.nttrans.out.changes[n].name.s,
+ not2.nttrans.out.changes[n].name.s);
return False;
}
- if (not1.out.changes[n].name.private_length !=
- not2.out.changes[n].name.private_length) {
+ if (not1.nttrans.out.changes[n].name.private_length !=
+ not2.nttrans.out.changes[n].name.private_length) {
printf("Notify name length %d inconsistent %d %d\n", n,
- not1.out.changes[n].name.private_length,
- not2.out.changes[n].name.private_length);
+ not1.nttrans.out.changes[n].name.private_length,
+ not2.nttrans.out.changes[n].name.private_length);
return False;
}
}
} while(0)
#define CHECK_TIMES_EQUAL(field) do { \
- if (ABS(parm[0].field - parm[1].field) > time_skew() && \
+ if (labs(parm[0].field - parm[1].field) > time_skew() && \
!ignore_pattern(#field)) { \
printf("Mismatch in %s - 0x%x 0x%x\n", #field, \
(int)parm[0].field, (int)parm[1].field); \
} while(0)
#define CHECK_NTTIMES_EQUAL(field) do { \
- if (ABS(nt_time_to_unix(parm[0].field) - \
+ if (labs(nt_time_to_unix(parm[0].field) - \
nt_time_to_unix(parm[1].field)) > time_skew() && \
!ignore_pattern(#field)) { \
printf("Mismatch in %s - 0x%x 0x%x\n", #field, \
CHECK_TIMES_EQUAL(openx.out.write_time);
/* open creates a new file handle */
- ADD_HANDLE(parm[0].openx.in.fname, openx.out.fnum);
+ ADD_HANDLE(parm[0].openx.in.fname, openx.out.file.fnum);
return True;
}
CHECK_EQUAL(openold.out.rmode);
/* open creates a new file handle */
- ADD_HANDLE(parm[0].openold.in.fname, openold.out.fnum);
+ ADD_HANDLE(parm[0].openold.in.fname, openold.out.file.fnum);
return True;
}
CHECK_EQUAL(ntcreatex.out.is_directory);
/* ntcreatex creates a new file handle */
- ADD_HANDLE(parm[0].ntcreatex.in.fname, ntcreatex.out.fnum);
+ ADD_HANDLE(parm[0].ntcreatex.in.fname, ntcreatex.out.file.fnum);
return True;
}
NTSTATUS status[NSERVERS];
parm[0].close.level = RAW_CLOSE_CLOSE;
- parm[0].close.in.fnum = gen_fnum_close(instance);
+ parm[0].close.in.file.fnum = gen_fnum_close(instance);
parm[0].close.in.write_time = gen_timet();
GEN_COPY_PARM;
- GEN_SET_FNUM(close.in.fnum);
+ GEN_SET_FNUM(close.in.file.fnum);
GEN_CALL(smb_raw_close(tree, &parm[i]));
- REMOVE_HANDLE(close.in.fnum);
+ REMOVE_HANDLE(close.in.file.fnum);
return True;
}
*/
static BOOL handler_unlink(int instance)
{
- struct smb_unlink parm[NSERVERS];
+ union smb_unlink parm[NSERVERS];
NTSTATUS status[NSERVERS];
- parm[0].in.pattern = gen_pattern();
- parm[0].in.attrib = gen_attrib();
+ parm[0].unlink.in.pattern = gen_pattern();
+ parm[0].unlink.in.attrib = gen_attrib();
GEN_COPY_PARM;
GEN_CALL(smb_raw_unlink(tree, &parm[i]));
*/
static BOOL handler_chkpath(int instance)
{
- struct smb_chkpath parm[NSERVERS];
+ union smb_chkpath parm[NSERVERS];
NTSTATUS status[NSERVERS];
- parm[0].in.path = gen_fname_open(instance);
+ parm[0].chkpath.in.path = gen_fname_open(instance);
GEN_COPY_PARM;
GEN_CALL(smb_raw_chkpath(tree, &parm[i]));
*/
static BOOL handler_seek(int instance)
{
- struct smb_seek parm[NSERVERS];
+ union smb_seek parm[NSERVERS];
NTSTATUS status[NSERVERS];
- parm[0].in.fnum = gen_fnum(instance);
- parm[0].in.mode = gen_bits_mask2(0x3, 0xFFFF);
- parm[0].in.offset = gen_offset();
+ parm[0].lseek.in.file.fnum = gen_fnum(instance);
+ parm[0].lseek.in.mode = gen_bits_mask2(0x3, 0xFFFF);
+ parm[0].lseek.in.offset = gen_offset();
GEN_COPY_PARM;
- GEN_SET_FNUM(in.fnum);
+ GEN_SET_FNUM(lseek.in.file.fnum);
GEN_CALL(smb_raw_seek(tree, &parm[i]));
- CHECK_EQUAL(out.offset);
+ CHECK_EQUAL(lseek.out.offset);
return True;
}
NTSTATUS status[NSERVERS];
parm[0].readx.level = RAW_READ_READX;
- parm[0].readx.in.fnum = gen_fnum(instance);
+ parm[0].readx.in.file.fnum = gen_fnum(instance);
parm[0].readx.in.offset = gen_offset();
parm[0].readx.in.mincnt = gen_io_count();
parm[0].readx.in.maxcnt = gen_io_count();
parm[0].readx.in.remaining = gen_io_count();
+ parm[0].readx.in.read_for_execute = gen_bool();
parm[0].readx.out.data = talloc_size(current_op.mem_ctx,
MAX(parm[0].readx.in.mincnt, parm[0].readx.in.maxcnt));
GEN_COPY_PARM;
- GEN_SET_FNUM(readx.in.fnum);
+ GEN_SET_FNUM(readx.in.file.fnum);
GEN_CALL(smb_raw_read(tree, &parm[i]));
CHECK_EQUAL(readx.out.remaining);
NTSTATUS status[NSERVERS];
parm[0].writex.level = RAW_WRITE_WRITEX;
- parm[0].writex.in.fnum = gen_fnum(instance);
+ parm[0].writex.in.file.fnum = gen_fnum(instance);
parm[0].writex.in.offset = gen_offset();
parm[0].writex.in.wmode = gen_bits_mask(0xFFFF);
parm[0].writex.in.remaining = gen_io_count();
parm[0].writex.in.data = talloc_zero_size(current_op.mem_ctx, parm[0].writex.in.count);
GEN_COPY_PARM;
- GEN_SET_FNUM(writex.in.fnum);
+ GEN_SET_FNUM(writex.in.file.fnum);
GEN_CALL(smb_raw_write(tree, &parm[i]));
CHECK_EQUAL(writex.out.nwritten);
int n, nlocks;
parm[0].lockx.level = RAW_LOCK_LOCKX;
- parm[0].lockx.in.fnum = gen_fnum(instance);
+ parm[0].lockx.in.file.fnum = gen_fnum(instance);
parm[0].lockx.in.mode = gen_lock_mode();
parm[0].lockx.in.timeout = gen_timeout();
do {
}
GEN_COPY_PARM;
- GEN_SET_FNUM(lockx.in.fnum);
+ GEN_SET_FNUM(lockx.in.file.fnum);
GEN_CALL(smb_raw_lock(tree, &parm[i]));
return True;
union smb_fileinfo parm[NSERVERS];
NTSTATUS status[NSERVERS];
- parm[0].generic.in.fname = gen_fname_open(instance);
+ parm[0].generic.in.file.path = gen_fname_open(instance);
gen_fileinfo(instance, &parm[0]);
union smb_fileinfo parm[NSERVERS];
NTSTATUS status[NSERVERS];
- parm[0].generic.in.fnum = gen_fnum(instance);
+ parm[0].generic.in.file.fnum = gen_fnum(instance);
gen_fileinfo(instance, &parm[0]);
GEN_COPY_PARM;
- GEN_SET_FNUM(generic.in.fnum);
+ GEN_SET_FNUM(generic.in.file.fnum);
GEN_CALL(smb_raw_fileinfo(tree, current_op.mem_ctx, &parm[i]));
return cmp_fileinfo(instance, parm, status);
union smb_setfileinfo parm[NSERVERS];
NTSTATUS status[NSERVERS];
- parm[0].generic.file.fname = gen_fname_open(instance);
+ parm[0].generic.in.file.path = gen_fname_open(instance);
gen_setfileinfo(instance, &parm[0]);
union smb_setfileinfo parm[NSERVERS];
NTSTATUS status[NSERVERS];
- parm[0].generic.file.fnum = gen_fnum(instance);
+ parm[0].generic.in.file.fnum = gen_fnum(instance);
gen_setfileinfo(instance, &parm[0]);
GEN_COPY_PARM;
- GEN_SET_FNUM(generic.file.fnum);
+ GEN_SET_FNUM(generic.in.file.fnum);
GEN_CALL(smb_raw_setfileinfo(tree, &parm[i]));
return True;
*/
static BOOL handler_notify(int instance)
{
- struct smb_notify parm[NSERVERS];
+ union smb_notify parm[NSERVERS];
int n;
- parm[0].in.buffer_size = gen_io_count();
- parm[0].in.completion_filter = gen_bits_mask(0xFF);
- parm[0].in.fnum = gen_fnum(instance);
- parm[0].in.recursive = gen_bool();
+ ZERO_STRUCT(parm[0]);
+ parm[0].nttrans.level = RAW_NOTIFY_NTTRANS;
+ parm[0].nttrans.in.buffer_size = gen_io_count();
+ parm[0].nttrans.in.completion_filter = gen_bits_mask(0xFF);
+ parm[0].nttrans.in.file.fnum = gen_fnum(instance);
+ parm[0].nttrans.in.recursive = gen_bool();
GEN_COPY_PARM;
- GEN_SET_FNUM(in.fnum);
+ GEN_SET_FNUM(nttrans.in.file.fnum);
for (n=0;n<NSERVERS;n++) {
struct smbcli_request *req;
");
}
+/**
+ split a UNC name into server and share names
+*/
+static BOOL split_unc_name(const char *unc, char **server, char **share)
+{
+ char *p = strdup(unc);
+ if (!p) return False;
+ all_string_sub(p, "\\", "/", 0);
+ if (strncmp(p, "//", 2) != 0) return False;
+
+ (*server) = p+2;
+ p = strchr(*server, '/');
+ if (!p) return False;
+
+ *p = 0;
+ (*share) = p+1;
+
+ return True;
+}
+
+
+
/****************************************************************************
main program
****************************************************************************/