This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ 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,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
+#include "libcli/libcli.h"
+#include "torture/util.h"
+#include "libcli/raw/raw_proto.h"
+#include "system/filesys.h"
+#include "param/param.h"
#define VERBOSE 0
#define OP_MIN 0
#define OP_MAX 100
+#define PARAM_SIZE 1024
/****************************************************************************
look for a partial hit
****************************************************************************/
static void trans2_check_hit(const char *format, int op, int level, NTSTATUS status)
{
- if (NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_INVALID_LEVEL) ||
- NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_NOT_IMPLEMENTED) ||
- NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_NOT_SUPPORTED) ||
- NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_UNSUCCESSFUL) ||
- NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_INVALID_INFO_CLASS)) {
+ if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_LEVEL) ||
+ NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED) ||
+ NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED) ||
+ NT_STATUS_EQUAL(status, NT_STATUS_UNSUCCESSFUL) ||
+ NT_STATUS_EQUAL(status, NT_STATUS_INVALID_INFO_CLASS)) {
return;
}
#if VERBOSE
/****************************************************************************
check for existance of a trans2 call
****************************************************************************/
-static NTSTATUS try_trans2(struct cli_state *cli,
+static NTSTATUS try_trans2(struct smbcli_state *cli,
int op,
- char *param, char *data,
+ uint8_t *param, uint8_t *data,
int param_len, int data_len,
int *rparam_len, int *rdata_len)
{
mem_ctx = talloc_init("try_trans2");
- t2.in.max_param = 1024;
- t2.in.max_data = 0x8000;
+ t2.in.max_param = UINT16_MAX;
+ t2.in.max_data = UINT16_MAX;
t2.in.max_setup = 10;
t2.in.flags = 0;
t2.in.timeout = 0;
*rparam_len = t2.out.params.length;
*rdata_len = t2.out.data.length;
- talloc_destroy(mem_ctx);
-
+ talloc_free(mem_ctx);
+
return status;
}
-static NTSTATUS try_trans2_len(struct cli_state *cli,
+static NTSTATUS try_trans2_len(struct smbcli_state *cli,
const char *format,
int op, int level,
- char *param, char *data,
+ uint8_t *param, uint8_t *data,
int param_len, int *data_len,
int *rparam_len, int *rdata_len)
{
NTSTATUS ret=NT_STATUS_OK;
ret = try_trans2(cli, op, param, data, param_len,
- sizeof(pstring), rparam_len, rdata_len);
-#if VERBOSE
+ PARAM_SIZE, rparam_len, rdata_len);
+#if VERBOSE
printf("op=%d level=%d ret=%s\n", op, level, nt_errstr(ret));
#endif
if (!NT_STATUS_IS_OK(ret)) return ret;
*data_len = 0;
- while (*data_len < sizeof(pstring)) {
+ while (*data_len < PARAM_SIZE) {
ret = try_trans2(cli, op, param, data, param_len,
*data_len, rparam_len, rdata_len);
if (NT_STATUS_IS_OK(ret)) break;
/****************************************************************************
check whether a trans2 opnum exists at all
****************************************************************************/
-static BOOL trans2_op_exists(struct cli_state *cli, int op)
+static bool trans2_op_exists(struct smbcli_state *cli, int op)
{
- int data_len = 0;
- int param_len = 0;
+ int data_len = PARAM_SIZE;
+ int param_len = PARAM_SIZE;
int rparam_len, rdata_len;
- pstring param, data;
+ uint8_t *param, *data;
NTSTATUS status1, status2;
+ TALLOC_CTX *mem_ctx;
- memset(data, 0, sizeof(data));
- data_len = 4;
+ mem_ctx = talloc_init("trans2_op_exists");
/* try with a info level only */
- param_len = sizeof(param);
- data_len = sizeof(data);
- memset(param, 0xFF, sizeof(param));
- memset(data, 0xFF, sizeof(data));
-
- status1 = try_trans2(cli, 0xFFFF, param, data, param_len, data_len,
+ param = talloc_array(mem_ctx, uint8_t, param_len);
+ data = talloc_array(mem_ctx, uint8_t, data_len);
+
+ memset(param, 0xFF, param_len);
+ memset(data, 0xFF, data_len);
+
+ status1 = try_trans2(cli, 0xFFFF, param, data, param_len, data_len,
&rparam_len, &rdata_len);
- status2 = try_trans2(cli, op, param, data, param_len, data_len,
+ status2 = try_trans2(cli, op, param, data, param_len, data_len,
&rparam_len, &rdata_len);
- if (NT_STATUS_EQUAL(status1, status2)) return False;
+ if (NT_STATUS_EQUAL(status1, status2)) {
+ talloc_free(mem_ctx);
+ return false;
+ }
printf("Found op %d (status=%s)\n", op, nt_errstr(status2));
- return True;
+ talloc_free(mem_ctx);
+ return true;
}
/****************************************************************************
check for existance of a trans2 call
****************************************************************************/
-static BOOL scan_trans2(struct cli_state *cli, int op, int level,
+static bool scan_trans2(
+ struct smbcli_state *cli, int op, int level,
int fnum, int dnum, int qfnum, const char *fname)
{
int data_len = 0;
int param_len = 0;
int rparam_len, rdata_len;
- pstring param, data;
+ uint8_t *param, *data;
NTSTATUS status;
+ TALLOC_CTX *mem_ctx;
- memset(data, 0, sizeof(data));
+ mem_ctx = talloc_init("scan_trans2");
+
+ data = talloc_array(mem_ctx, uint8_t, PARAM_SIZE);
+ param = talloc_array(mem_ctx, uint8_t, PARAM_SIZE);
+
+ memset(data, 0, PARAM_SIZE);
data_len = 4;
/* try with a info level only */
param_len = 2;
SSVAL(param, 0, level);
- status = try_trans2_len(cli, "void", op, level, param, data, param_len, &data_len,
- &rparam_len, &rdata_len);
- if (NT_STATUS_IS_OK(status)) return True;
+ status = try_trans2_len(cli, "void", op, level, param, data, param_len,
+ &data_len, &rparam_len, &rdata_len);
+ if (NT_STATUS_IS_OK(status)) {
+ talloc_free(mem_ctx);
+ return true;
+ }
/* try with a file descriptor */
param_len = 6;
SSVAL(param, 0, fnum);
SSVAL(param, 2, level);
SSVAL(param, 4, 0);
- status = try_trans2_len(cli, "fnum", op, level, param, data, param_len, &data_len,
- &rparam_len, &rdata_len);
- if (NT_STATUS_IS_OK(status)) return True;
+ status = try_trans2_len(cli, "fnum", op, level, param, data, param_len,
+ &data_len, &rparam_len, &rdata_len);
+ if (NT_STATUS_IS_OK(status)) {
+ talloc_free(mem_ctx);
+ return true;
+ }
/* try with a quota file descriptor */
param_len = 6;
SSVAL(param, 0, qfnum);
SSVAL(param, 2, level);
SSVAL(param, 4, 0);
- status = try_trans2_len(cli, "qfnum", op, level, param, data, param_len, &data_len,
- &rparam_len, &rdata_len);
- if (NT_STATUS_IS_OK(status)) return True;
+ status = try_trans2_len(cli, "qfnum", op, level, param, data, param_len,
+ &data_len, &rparam_len, &rdata_len);
+ if (NT_STATUS_IS_OK(status)) {
+ talloc_free(mem_ctx);
+ return true;
+ }
/* try with a notify style */
param_len = 6;
SSVAL(param, 0, dnum);
SSVAL(param, 2, dnum);
SSVAL(param, 4, level);
- status = try_trans2_len(cli, "notify", op, level, param, data, param_len, &data_len,
- &rparam_len, &rdata_len);
- if (NT_STATUS_IS_OK(status)) return True;
+ status = try_trans2_len(cli, "notify", op, level, param, data,
+ param_len, &data_len, &rparam_len, &rdata_len);
+ if (NT_STATUS_IS_OK(status)) {
+ talloc_free(mem_ctx);
+ return true;
+ }
/* try with a file name */
param_len = 6;
SSVAL(param, 0, level);
SSVAL(param, 2, 0);
SSVAL(param, 4, 0);
- param_len += push_string(NULL, ¶m[6], fname, sizeof(pstring)-7, STR_TERMINATE|STR_UNICODE);
-
- status = try_trans2_len(cli, "fname", op, level, param, data, param_len, &data_len,
- &rparam_len, &rdata_len);
- if (NT_STATUS_IS_OK(status)) return True;
+ param_len += push_string(
+ ¶m[6], fname, PARAM_SIZE-7,
+ STR_TERMINATE|STR_UNICODE);
+
+ status = try_trans2_len(cli, "fname", op, level, param, data, param_len,
+ &data_len, &rparam_len, &rdata_len);
+ if (NT_STATUS_IS_OK(status)) {
+ talloc_free(mem_ctx);
+ return true;
+ }
/* try with a new file name */
param_len = 6;
SSVAL(param, 0, level);
SSVAL(param, 2, 0);
SSVAL(param, 4, 0);
- param_len += push_string(NULL, ¶m[6], "\\newfile.dat", sizeof(pstring)-7, STR_TERMINATE|STR_UNICODE);
-
- status = try_trans2_len(cli, "newfile", op, level, param, data, param_len, &data_len,
- &rparam_len, &rdata_len);
- cli_unlink(cli->tree, "\\newfile.dat");
- cli_rmdir(cli->tree, "\\newfile.dat");
- if (NT_STATUS_IS_OK(status)) return True;
+ param_len += push_string(
+ ¶m[6], "\\newfile.dat", PARAM_SIZE-7,
+ STR_TERMINATE|STR_UNICODE);
+
+ status = try_trans2_len(cli, "newfile", op, level, param, data,
+ param_len, &data_len, &rparam_len, &rdata_len);
+ smbcli_unlink(cli->tree, "\\newfile.dat");
+ smbcli_rmdir(cli->tree, "\\newfile.dat");
+ if (NT_STATUS_IS_OK(status)) {
+ talloc_free(mem_ctx);
+ return true;
+ }
/* try dfs style */
- cli_mkdir(cli->tree, "\\testdir");
+ smbcli_mkdir(cli->tree, "\\testdir");
param_len = 2;
SSVAL(param, 0, level);
- param_len += push_string(NULL, ¶m[2], "\\testdir", sizeof(pstring)-3, STR_TERMINATE|STR_UNICODE);
-
- status = try_trans2_len(cli, "dfs", op, level, param, data, param_len, &data_len,
- &rparam_len, &rdata_len);
- cli_rmdir(cli->tree, "\\testdir");
- if (NT_STATUS_IS_OK(status)) return True;
+ param_len += push_string(
+ ¶m[2], "\\testdir", PARAM_SIZE-3,
+ STR_TERMINATE|STR_UNICODE);
+
+ status = try_trans2_len(cli, "dfs", op, level, param, data, param_len,
+ &data_len, &rparam_len, &rdata_len);
+ smbcli_rmdir(cli->tree, "\\testdir");
+ if (NT_STATUS_IS_OK(status)) {
+ talloc_free(mem_ctx);
+ return true;
+ }
- return False;
+ talloc_free(mem_ctx);
+ return false;
}
-
-BOOL torture_trans2_scan(int dummy)
+bool torture_trans2_scan(struct torture_context *torture,
+ struct smbcli_state *cli)
{
- static struct cli_state *cli;
int op, level;
const char *fname = "\\scanner.dat";
int fnum, dnum, qfnum;
- printf("starting trans2 scan test\n");
-
- if (!torture_open_connection(&cli)) {
- return False;
- }
-
- fnum = cli_open(cli->tree, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
+ fnum = smbcli_open(cli->tree, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
if (fnum == -1) {
- printf("file open failed - %s\n", cli_errstr(cli->tree));
+ printf("file open failed - %s\n", smbcli_errstr(cli->tree));
}
- dnum = cli_nt_create_full(cli->tree, "\\",
- 0, GENERIC_RIGHTS_FILE_READ, FILE_ATTRIBUTE_NORMAL,
- NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE,
- NTCREATEX_DISP_OPEN,
- NTCREATEX_OPTIONS_DIRECTORY, 0);
+ dnum = smbcli_nt_create_full(cli->tree, "\\",
+ 0,
+ SEC_RIGHTS_FILE_READ,
+ FILE_ATTRIBUTE_NORMAL,
+ NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE,
+ NTCREATEX_DISP_OPEN,
+ NTCREATEX_OPTIONS_DIRECTORY, 0);
if (dnum == -1) {
- printf("directory open failed - %s\n", cli_errstr(cli->tree));
+ printf("directory open failed - %s\n", smbcli_errstr(cli->tree));
}
- qfnum = cli_nt_create_full(cli->tree, "\\$Extend\\$Quota:$Q:$INDEX_ALLOCATION",
+ qfnum = smbcli_nt_create_full(cli->tree, "\\$Extend\\$Quota:$Q:$INDEX_ALLOCATION",
NTCREATEX_FLAGS_EXTENDED,
- SEC_RIGHTS_MAXIMUM_ALLOWED,
+ SEC_FLAG_MAXIMUM_ALLOWED,
0,
NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE,
NTCREATEX_DISP_OPEN,
0, 0);
if (qfnum == -1) {
- printf("quota open failed - %s\n", cli_errstr(cli->tree));
+ printf("quota open failed - %s\n", smbcli_errstr(cli->tree));
}
for (op=OP_MIN; op<=OP_MAX; op++) {
}
}
- torture_close_connection(cli);
-
- printf("trans2 scan finished\n");
- return True;
+ return true;
}
****************************************************************************/
static void nttrans_check_hit(const char *format, int op, int level, NTSTATUS status)
{
- if (NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_INVALID_LEVEL) ||
- NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_NOT_IMPLEMENTED) ||
- NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_NOT_SUPPORTED) ||
- NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_UNSUCCESSFUL) ||
- NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_INVALID_INFO_CLASS)) {
+ if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_LEVEL) ||
+ NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED) ||
+ NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED) ||
+ NT_STATUS_EQUAL(status, NT_STATUS_UNSUCCESSFUL) ||
+ NT_STATUS_EQUAL(status, NT_STATUS_INVALID_INFO_CLASS)) {
return;
}
#if VERBOSE
/****************************************************************************
check for existence of a nttrans call
****************************************************************************/
-static NTSTATUS try_nttrans(struct cli_state *cli,
+static NTSTATUS try_nttrans(struct smbcli_state *cli,
int op,
- char *param, char *data,
+ uint8_t *param, uint8_t *data,
int param_len, int data_len,
int *rparam_len, int *rdata_len)
{
ntdata_blob.length = data_len;
ntdata_blob.data = data;
- parms.in.max_param = 1024;
- parms.in.max_data = 1024;
+ parms.in.max_param = UINT32_MAX;
+ parms.in.max_data = UINT32_MAX;
parms.in.max_setup = 0;
parms.in.setup_count = 0;
parms.in.function = op;
if (NT_STATUS_IS_ERR(status)) {
DEBUG(1,("Failed to send NT_TRANS\n"));
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return status;
}
*rparam_len = parms.out.params.length;
*rdata_len = parms.out.data.length;
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return status;
}
-static NTSTATUS try_nttrans_len(struct cli_state *cli,
+static NTSTATUS try_nttrans_len(struct smbcli_state *cli,
const char *format,
int op, int level,
- char *param, char *data,
+ uint8_t *param, uint8_t *data,
int param_len, int *data_len,
int *rparam_len, int *rdata_len)
{
NTSTATUS ret=NT_STATUS_OK;
ret = try_nttrans(cli, op, param, data, param_len,
- sizeof(pstring), rparam_len, rdata_len);
-#if VERBOSE
+ PARAM_SIZE, rparam_len, rdata_len);
+#if VERBOSE
printf("op=%d level=%d ret=%s\n", op, level, nt_errstr(ret));
#endif
if (!NT_STATUS_IS_OK(ret)) return ret;
*data_len = 0;
- while (*data_len < sizeof(pstring)) {
+ while (*data_len < PARAM_SIZE) {
ret = try_nttrans(cli, op, param, data, param_len,
*data_len, rparam_len, rdata_len);
if (NT_STATUS_IS_OK(ret)) break;
/****************************************************************************
check for existance of a nttrans call
****************************************************************************/
-static BOOL scan_nttrans(struct cli_state *cli, int op, int level,
+static bool scan_nttrans(struct smbcli_state *cli, int op, int level,
int fnum, int dnum, const char *fname)
{
int data_len = 0;
int param_len = 0;
int rparam_len, rdata_len;
- pstring param, data;
+ uint8_t *param, *data;
NTSTATUS status;
+ TALLOC_CTX *mem_ctx;
+
+ mem_ctx = talloc_init("scan_nttrans");
- memset(data, 0, sizeof(data));
+ param = talloc_array(mem_ctx, uint8_t, PARAM_SIZE);
+ data = talloc_array(mem_ctx, uint8_t, PARAM_SIZE);
+ memset(data, 0, PARAM_SIZE);
data_len = 4;
/* try with a info level only */
param_len = 2;
SSVAL(param, 0, level);
- status = try_nttrans_len(cli, "void", op, level, param, data, param_len, &data_len,
- &rparam_len, &rdata_len);
- if (NT_STATUS_IS_OK(status)) return True;
+ status = try_nttrans_len(cli, "void", op, level, param, data, param_len,
+ &data_len, &rparam_len, &rdata_len);
+ if (NT_STATUS_IS_OK(status)) {
+ talloc_free(mem_ctx);
+ return true;
+ }
/* try with a file descriptor */
param_len = 6;
SSVAL(param, 0, fnum);
SSVAL(param, 2, level);
SSVAL(param, 4, 0);
- status = try_nttrans_len(cli, "fnum", op, level, param, data, param_len, &data_len,
- &rparam_len, &rdata_len);
- if (NT_STATUS_IS_OK(status)) return True;
-
+ status = try_nttrans_len(cli, "fnum", op, level, param, data, param_len,
+ &data_len, &rparam_len, &rdata_len);
+ if (NT_STATUS_IS_OK(status)) {
+ talloc_free(mem_ctx);
+ return true;
+ }
/* try with a notify style */
param_len = 6;
SSVAL(param, 0, dnum);
SSVAL(param, 2, dnum);
SSVAL(param, 4, level);
- status = try_nttrans_len(cli, "notify", op, level, param, data, param_len, &data_len,
- &rparam_len, &rdata_len);
- if (NT_STATUS_IS_OK(status)) return True;
+ status = try_nttrans_len(cli, "notify", op, level, param, data,
+ param_len, &data_len, &rparam_len, &rdata_len);
+ if (NT_STATUS_IS_OK(status)) {
+ talloc_free(mem_ctx);
+ return true;
+ }
/* try with a file name */
param_len = 6;
SSVAL(param, 0, level);
SSVAL(param, 2, 0);
SSVAL(param, 4, 0);
- param_len += push_string(NULL, ¶m[6], fname, -1, STR_TERMINATE | STR_UNICODE);
-
- status = try_nttrans_len(cli, "fname", op, level, param, data, param_len, &data_len,
- &rparam_len, &rdata_len);
- if (NT_STATUS_IS_OK(status)) return True;
+ param_len += push_string(
+ ¶m[6], fname, PARAM_SIZE,
+ STR_TERMINATE | STR_UNICODE);
+
+ status = try_nttrans_len(cli, "fname", op, level, param, data,
+ param_len, &data_len, &rparam_len, &rdata_len);
+ if (NT_STATUS_IS_OK(status)) {
+ talloc_free(mem_ctx);
+ return true;
+ }
/* try with a new file name */
param_len = 6;
SSVAL(param, 0, level);
SSVAL(param, 2, 0);
SSVAL(param, 4, 0);
- param_len += push_string(NULL, ¶m[6], "\\newfile.dat", -1, STR_TERMINATE | STR_UNICODE);
-
- status = try_nttrans_len(cli, "newfile", op, level, param, data, param_len, &data_len,
- &rparam_len, &rdata_len);
- cli_unlink(cli->tree, "\\newfile.dat");
- cli_rmdir(cli->tree, "\\newfile.dat");
- if (NT_STATUS_IS_OK(status)) return True;
+ param_len += push_string(
+ ¶m[6], "\\newfile.dat", PARAM_SIZE,
+ STR_TERMINATE | STR_UNICODE);
+
+ status = try_nttrans_len(cli, "newfile", op, level, param, data,
+ param_len, &data_len, &rparam_len, &rdata_len);
+ smbcli_unlink(cli->tree, "\\newfile.dat");
+ smbcli_rmdir(cli->tree, "\\newfile.dat");
+ if (NT_STATUS_IS_OK(status)) {
+ talloc_free(mem_ctx);
+ return true;
+ }
/* try dfs style */
- cli_mkdir(cli->tree, "\\testdir");
+ smbcli_mkdir(cli->tree, "\\testdir");
param_len = 2;
SSVAL(param, 0, level);
- param_len += push_string(NULL, ¶m[2], "\\testdir", -1, STR_TERMINATE | STR_UNICODE);
-
- status = try_nttrans_len(cli, "dfs", op, level, param, data, param_len, &data_len,
- &rparam_len, &rdata_len);
- cli_rmdir(cli->tree, "\\testdir");
- if (NT_STATUS_IS_OK(status)) return True;
+ param_len += push_string(¶m[2], "\\testdir", PARAM_SIZE,
+ STR_TERMINATE | STR_UNICODE);
+
+ status = try_nttrans_len(cli, "dfs", op, level, param, data, param_len,
+ &data_len, &rparam_len, &rdata_len);
+ smbcli_rmdir(cli->tree, "\\testdir");
+ if (NT_STATUS_IS_OK(status)) {
+ talloc_free(mem_ctx);
+ return true;
+ }
- return False;
+ talloc_free(mem_ctx);
+ return false;
}
-BOOL torture_nttrans_scan(int dummy)
+bool torture_nttrans_scan(struct torture_context *torture,
+ struct smbcli_state *cli)
{
- static struct cli_state *cli;
int op, level;
const char *fname = "\\scanner.dat";
int fnum, dnum;
- printf("starting nttrans scan test\n");
-
- if (!torture_open_connection(&cli)) {
- return False;
- }
-
- fnum = cli_open(cli->tree, fname, O_RDWR | O_CREAT | O_TRUNC,
+ fnum = smbcli_open(cli->tree, fname, O_RDWR | O_CREAT | O_TRUNC,
DENY_NONE);
- dnum = cli_open(cli->tree, "\\", O_RDONLY, DENY_NONE);
+ dnum = smbcli_open(cli->tree, "\\", O_RDONLY, DENY_NONE);
for (op=OP_MIN; op<=OP_MAX; op++) {
printf("Scanning op=%d\n", op);
}
}
- torture_close_connection(cli);
-
printf("nttrans scan finished\n");
- return True;
+ return true;
}
/* scan for valid base SMB requests */
-BOOL torture_smb_scan(int dummy)
+bool torture_smb_scan(struct torture_context *torture)
{
- static struct cli_state *cli;
+ static struct smbcli_state *cli;
int op;
- struct cli_request *req;
+ struct smbcli_request *req;
NTSTATUS status;
for (op=0x0;op<=0xFF;op++) {
if (op == SMBreadbraw) continue;
- if (!torture_open_connection(&cli)) {
- return False;
+ if (!torture_open_connection(&cli, torture, 0)) {
+ return false;
}
- req = cli_request_setup(cli->tree, op, 0, 0);
+ req = smbcli_request_setup(cli->tree, op, 0, 0);
- if (!cli_request_send(req)) {
- cli_request_destroy(req);
+ if (!smbcli_request_send(req)) {
+ smbcli_request_destroy(req);
break;
}
usleep(10000);
- cli_transport_process(cli->transport);
- if (req->state > CLI_REQUEST_RECV) {
- status = cli_request_simple_recv(req);
+ smbcli_transport_process(cli->transport);
+ if (req->state > SMBCLI_REQUEST_RECV) {
+ status = smbcli_request_simple_recv(req);
printf("op=0x%x status=%s\n", op, nt_errstr(status));
torture_close_connection(cli);
continue;
}
sleep(1);
- cli_transport_process(cli->transport);
- if (req->state > CLI_REQUEST_RECV) {
- status = cli_request_simple_recv(req);
+ smbcli_transport_process(cli->transport);
+ if (req->state > SMBCLI_REQUEST_RECV) {
+ status = smbcli_request_simple_recv(req);
printf("op=0x%x status=%s\n", op, nt_errstr(status));
} else {
printf("op=0x%x no reply\n", op);
- cli_request_destroy(req);
+ smbcli_request_destroy(req);
continue; /* don't attempt close! */
}
printf("smb scan finished\n");
- return True;
+ return true;
}