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 "librpc/gen_ndr/ndr_misc.h"
#include "lib/cmdline/popt_common.h"
#include "torture/util.h"
+#include "param/param.h"
+#include "libcli/resolve/resolve.h"
#define BASEDIR "\\composite"
/*
test a simple savefile/loadfile combination
*/
-static BOOL test_loadfile(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_loadfile(struct smbcli_state *cli, struct torture_context *tctx)
{
const char *fname = BASEDIR "\\test.txt";
NTSTATUS status;
size_t len = random() % 100000;
const int num_ops = 50;
int i;
- int *count = talloc_zero(mem_ctx, int);
+ int *count = talloc_zero(tctx, int);
- data = talloc_array(mem_ctx, uint8_t, len);
+ data = talloc_array(tctx, uint8_t, len);
generate_random_buffer(data, len);
io1.in.data = data;
io1.in.size = len;
- printf("testing savefile\n");
+ printf("Testing savefile\n");
status = smb_composite_savefile(cli->tree, &io1);
if (!NT_STATUS_IS_OK(status)) {
- printf("savefile failed: %s\n", nt_errstr(status));
- return False;
+ printf("(%s) savefile failed: %s\n", __location__,nt_errstr(status));
+ return false;
}
io2.in.fname = fname;
- printf("testing parallel loadfile with %d ops\n", num_ops);
+ printf("Testing parallel loadfile with %d ops\n", num_ops);
- c = talloc_array(mem_ctx, struct composite_context *, num_ops);
+ c = talloc_array(tctx, struct composite_context *, num_ops);
for (i=0;i<num_ops;i++) {
c[i] = smb_composite_loadfile_send(cli->tree, &io2);
printf("waiting for completion\n");
while (*count != num_ops) {
event_loop_once(cli->transport->socket->event.ctx);
- printf("count=%d\r", *count);
- fflush(stdout);
+ if (torture_setting_bool(tctx, "progress", true)) {
+ printf("(%s) count=%d\r", __location__, *count);
+ fflush(stdout);
+ }
}
printf("count=%d\n", *count);
for (i=0;i<num_ops;i++) {
- status = smb_composite_loadfile_recv(c[i], mem_ctx);
+ status = smb_composite_loadfile_recv(c[i], tctx);
if (!NT_STATUS_IS_OK(status)) {
- printf("loadfile[%d] failed - %s\n", i, nt_errstr(status));
- return False;
+ printf("(%s) loadfile[%d] failed - %s\n", __location__, i, nt_errstr(status));
+ return false;
}
if (io2.out.size != len) {
- printf("wrong length in returned data - %d should be %d\n",
+ printf("(%s) wrong length in returned data - %d should be %d\n",__location__,
io2.out.size, (int)len);
- return False;
+ return false;
}
if (memcmp(io2.out.data, data, len) != 0) {
- printf("wrong data in loadfile!\n");
- return False;
+ printf("(%s) wrong data in loadfile!\n",__location__);
+ return false;
}
}
talloc_free(data);
- return True;
+ return true;
}
/*
test a simple savefile/loadfile combination
*/
-static BOOL test_fetchfile(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_fetchfile(struct smbcli_state *cli, struct torture_context *tctx)
{
const char *fname = BASEDIR "\\test.txt";
NTSTATUS status;
int i;
size_t len = random() % 10000;
extern int torture_numops;
- struct event_context *event_ctx;
- int *count = talloc_zero(mem_ctx, int);
- BOOL ret = True;
+ struct tevent_context *event_ctx;
+ int *count = talloc_zero(tctx, int);
+ bool ret = true;
- data = talloc_array(mem_ctx, uint8_t, len);
+ data = talloc_array(tctx, uint8_t, len);
generate_random_buffer(data, len);
io1.in.data = data;
io1.in.size = len;
- printf("testing savefile\n");
+ printf("Testing savefile\n");
status = smb_composite_savefile(cli->tree, &io1);
if (!NT_STATUS_IS_OK(status)) {
- printf("savefile failed: %s\n", nt_errstr(status));
- return False;
+ printf("(%s) savefile failed: %s\n",__location__, nt_errstr(status));
+ return false;
}
- io2.in.dest_host = lp_parm_string(-1, "torture", "host");
- io2.in.port = 0;
- io2.in.called_name = lp_parm_string(-1, "torture", "host");
- io2.in.service = lp_parm_string(-1, "torture", "share");
+ io2.in.dest_host = torture_setting_string(tctx, "host", NULL);
+ io2.in.ports = lp_smb_ports(tctx->lp_ctx);
+ io2.in.called_name = torture_setting_string(tctx, "host", NULL);
+ io2.in.service = torture_setting_string(tctx, "share", NULL);
io2.in.service_type = "A:";
io2.in.credentials = cmdline_credentials;
- io2.in.workgroup = lp_workgroup();
+ io2.in.workgroup = lp_workgroup(tctx->lp_ctx);
io2.in.filename = fname;
+ io2.in.resolve_ctx = lp_resolve_context(tctx->lp_ctx);
+ io2.in.iconv_convenience = lp_iconv_convenience(tctx->lp_ctx);
+ io2.in.gensec_settings = lp_gensec_settings(tctx, tctx->lp_ctx);
+ lp_smbcli_options(tctx->lp_ctx, &io2.in.options);
+ lp_smbcli_session_options(tctx->lp_ctx, &io2.in.session_options);
- printf("testing parallel fetchfile with %d ops\n", torture_numops);
+ printf("Testing parallel fetchfile with %d ops\n", torture_numops);
- event_ctx = event_context_find(mem_ctx);
- c = talloc_array(mem_ctx, struct composite_context *, torture_numops);
+ event_ctx = cli->transport->socket->event.ctx;
+ c = talloc_array(tctx, struct composite_context *, torture_numops);
for (i=0; i<torture_numops; i++) {
c[i] = smb_composite_fetchfile_send(&io2, event_ctx);
while (*count != torture_numops) {
event_loop_once(event_ctx);
- printf("count=%d\r", *count);
- fflush(stdout);
+ if (torture_setting_bool(tctx, "progress", true)) {
+ printf("(%s) count=%d\r", __location__, *count);
+ fflush(stdout);
+ }
}
printf("count=%d\n", *count);
for (i=0;i<torture_numops;i++) {
- status = smb_composite_fetchfile_recv(c[i], mem_ctx);
+ status = smb_composite_fetchfile_recv(c[i], tctx);
if (!NT_STATUS_IS_OK(status)) {
- printf("loadfile[%d] failed - %s\n", i,
+ printf("(%s) loadfile[%d] failed - %s\n", __location__, i,
nt_errstr(status));
- ret = False;
+ ret = false;
continue;
}
if (io2.out.size != len) {
- printf("wrong length in returned data - %d "
- "should be %d\n",
+ printf("(%s) wrong length in returned data - %d "
+ "should be %d\n", __location__,
io2.out.size, (int)len);
- ret = False;
+ ret = false;
continue;
}
if (memcmp(io2.out.data, data, len) != 0) {
- printf("wrong data in loadfile!\n");
- ret = False;
+ printf("(%s) wrong data in loadfile!\n", __location__);
+ ret = false;
continue;
}
}
/*
test setfileacl
*/
-static BOOL test_appendacl(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_appendacl(struct smbcli_state *cli, struct torture_context *tctx)
{
struct smb_composite_appendacl **io;
struct smb_composite_appendacl **io_orig;
struct composite_context **c;
- struct event_context *event_ctx;
+ struct tevent_context *event_ctx;
struct security_descriptor *test_sd;
struct security_ace *ace;
struct dom_sid *test_sid;
const int num_ops = 50;
- int *count = talloc_zero(mem_ctx, int);
+ int *count = talloc_zero(tctx, int);
struct smb_composite_savefile io1;
NTSTATUS status;
int i;
- io_orig = talloc_array(mem_ctx, struct smb_composite_appendacl *, num_ops);
+ io_orig = talloc_array(tctx, struct smb_composite_appendacl *, num_ops);
printf ("creating %d empty files and getting their acls with appendacl\n", num_ops);
status = smb_composite_savefile(cli->tree, &io1);
if (!NT_STATUS_IS_OK(status)) {
- printf("savefile failed: %s\n", nt_errstr(status));
- return False;
+ printf("(%s) savefile failed: %s\n", __location__, nt_errstr(status));
+ return false;
}
io_orig[i] = talloc (io_orig, struct smb_composite_appendacl);
io_orig[i]->in.sd = security_descriptor_initialise(io_orig[i]);
status = smb_composite_appendacl(cli->tree, io_orig[i], io_orig[i]);
if (!NT_STATUS_IS_OK(status)) {
- printf("appendacl failed: %s\n", nt_errstr(status));
- return False;
+ printf("(%s) appendacl failed: %s\n", __location__, nt_errstr(status));
+ return false;
}
}
/* fill Security Descriptor with aces to be added */
- test_sd = security_descriptor_initialise(mem_ctx);
- test_sid = dom_sid_parse_talloc (mem_ctx, "S-1-5-32-1234-5432");
+ test_sd = security_descriptor_initialise(tctx);
+ test_sid = dom_sid_parse_talloc (tctx, "S-1-5-32-1234-5432");
- ace = talloc_zero(mem_ctx, struct security_ace);
+ ace = talloc_zero(tctx, struct security_ace);
ace->type = SEC_ACE_TYPE_ACCESS_ALLOWED;
ace->flags = 0;
status = security_descriptor_dacl_add(test_sd, ace);
if (!NT_STATUS_IS_OK(status)) {
- printf("appendacl failed: %s\n", nt_errstr(status));
- return False;
+ printf("(%s) appendacl failed: %s\n", __location__, nt_errstr(status));
+ return false;
}
/* set parameters for appendacl async call */
- printf("testing parallel appendacl with %d ops\n", num_ops);
+ printf("Testing parallel appendacl with %d ops\n", num_ops);
- c = talloc_array(mem_ctx, struct composite_context *, num_ops);
- io = talloc_array(mem_ctx, struct smb_composite_appendacl *, num_ops);
+ c = talloc_array(tctx, struct composite_context *, num_ops);
+ io = talloc_array(tctx, struct smb_composite_appendacl *, num_ops);
for (i=0; i < num_ops; i++) {
io[i] = talloc (io, struct smb_composite_appendacl);
c[i]->async.private_data = count;
}
- event_ctx = talloc_reference(mem_ctx, cli->tree->session->transport->socket->event.ctx);
+ event_ctx = tctx->ev;
printf("waiting for completion\n");
while (*count != num_ops) {
event_loop_once(event_ctx);
- printf("count=%d\r", *count);
- fflush(stdout);
+ if (torture_setting_bool(tctx, "progress", true)) {
+ printf("(%s) count=%d\r", __location__, *count);
+ fflush(stdout);
+ }
}
printf("count=%d\n", *count);
for (i=0; i < num_ops; i++) {
status = smb_composite_appendacl_recv(c[i], io[i]);
if (!NT_STATUS_IS_OK(status)) {
- printf("appendacl[%d] failed - %s\n", i, nt_errstr(status));
- return False;
+ printf("(%s) appendacl[%d] failed - %s\n", __location__, i, nt_errstr(status));
+ return false;
}
security_descriptor_dacl_add(io_orig[i]->out.sd, ace);
if (!security_acl_equal(io_orig[i]->out.sd->dacl, io[i]->out.sd->dacl)) {
- printf("appendacl[%d] failed - needed acl isn't set\n", i);
- return False;
+ printf("(%s) appendacl[%d] failed - needed acl isn't set\n", __location__, i);
+ return false;
}
}
talloc_free (test_sid);
talloc_free (test_sd);
- return True;
+ return true;
}
/* test a query FS info by asking for share's GUID */
-static BOOL test_fsinfo(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_fsinfo(struct smbcli_state *cli, struct torture_context *tctx)
{
char *guid = NULL;
NTSTATUS status;
int i;
extern int torture_numops;
- struct event_context *event_ctx;
- int *count = talloc_zero(mem_ctx, int);
- BOOL ret = True;
-
- io1.in.dest_host = lp_parm_string(-1, "torture", "host");
- io1.in.port = 0;
- io1.in.called_name = lp_parm_string(-1, "torture", "host");
- io1.in.service = lp_parm_string(-1, "torture", "share");
+ struct tevent_context *event_ctx;
+ int *count = talloc_zero(tctx, int);
+ bool ret = true;
+
+ io1.in.dest_host = torture_setting_string(tctx, "host", NULL);
+ io1.in.dest_ports = lp_smb_ports(tctx->lp_ctx);
+ io1.in.socket_options = lp_socket_options(tctx->lp_ctx);
+ io1.in.called_name = torture_setting_string(tctx, "host", NULL);
+ io1.in.service = torture_setting_string(tctx, "share", NULL);
io1.in.service_type = "A:";
io1.in.credentials = cmdline_credentials;
- io1.in.workgroup = lp_workgroup();
+ io1.in.workgroup = lp_workgroup(tctx->lp_ctx);
io1.in.level = RAW_QFS_OBJECTID_INFORMATION;
+ io1.in.iconv_convenience = lp_iconv_convenience(tctx->lp_ctx);
+ io1.in.gensec_settings = lp_gensec_settings(tctx, tctx->lp_ctx);
- printf("testing parallel queryfsinfo [Object ID] with %d ops\n", torture_numops);
+ printf("Testing parallel queryfsinfo [Object ID] with %d ops\n",
+ torture_numops);
- event_ctx = talloc_reference(mem_ctx, cli->tree->session->transport->socket->event.ctx);
- c = talloc_array(mem_ctx, struct composite_context *, torture_numops);
+ event_ctx = tctx->ev;
+ c = talloc_array(tctx, struct composite_context *, torture_numops);
for (i=0; i<torture_numops; i++) {
- c[i] = smb_composite_fsinfo_send(cli->tree,&io1);
+ c[i] = smb_composite_fsinfo_send(cli->tree, &io1, lp_resolve_context(tctx->lp_ctx));
c[i]->async.fn = loadfile_complete;
c[i]->async.private_data = count;
}
while (*count < torture_numops) {
event_loop_once(event_ctx);
- printf("count=%d\r", *count);
- fflush(stdout);
+ if (torture_setting_bool(tctx, "progress", true)) {
+ printf("(%s) count=%d\r", __location__, *count);
+ fflush(stdout);
+ }
}
printf("count=%d\n", *count);
for (i=0;i<torture_numops;i++) {
- status = smb_composite_fsinfo_recv(c[i], mem_ctx);
+ status = smb_composite_fsinfo_recv(c[i], tctx);
if (!NT_STATUS_IS_OK(status)) {
- printf("fsinfo[%d] failed - %s\n", i, nt_errstr(status));
- ret = False;
+ printf("(%s) fsinfo[%d] failed - %s\n", __location__, i, nt_errstr(status));
+ ret = false;
continue;
}
if (io1.out.fsinfo->generic.level != RAW_QFS_OBJECTID_INFORMATION) {
- printf("wrong level in returned info - %d "
- "should be %d\n",
+ printf("(%s) wrong level in returned info - %d "
+ "should be %d\n", __location__,
io1.out.fsinfo->generic.level, RAW_QFS_OBJECTID_INFORMATION);
- ret = False;
+ ret = false;
continue;
}
- guid=GUID_string(mem_ctx, &io1.out.fsinfo->objectid_information.out.guid);
+ guid=GUID_string(tctx, &io1.out.fsinfo->objectid_information.out.guid);
printf("[%d] GUID: %s\n", i, guid);
/*
basic testing of libcli composite calls
*/
-BOOL torture_raw_composite(struct torture_context *torture)
+bool torture_raw_composite(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
- struct smbcli_state *cli;
- BOOL ret = True;
- TALLOC_CTX *mem_ctx;
-
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- mem_ctx = talloc_init("torture_raw_composite");
+ bool ret = true;
if (!torture_setup_dir(cli, BASEDIR)) {
- return False;
+ return false;
}
- ret &= test_fetchfile(cli, mem_ctx);
- ret &= test_loadfile(cli, mem_ctx);
- ret &= test_appendacl(cli, mem_ctx);
- ret &= test_fsinfo(cli, mem_ctx);
+ ret &= test_fetchfile(cli, tctx);
+ ret &= test_loadfile(cli, tctx);
+ ret &= test_appendacl(cli, tctx);
+ ret &= test_fsinfo(cli, tctx);
smb_raw_exit(cli->session);
smbcli_deltree(cli->tree, BASEDIR);
- torture_close_connection(cli);
- talloc_free(mem_ctx);
return ret;
}
git.samba.org / sfrench / samba-autobuild / .git / blobdiff