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 "torture/torture.h"
+#include "lib/events/events.h"
#include "libcli/raw/libcliraw.h"
+#include "libcli/libcli.h"
+#include "libcli/security/security.h"
#include "libcli/composite/composite.h"
+#include "libcli/smb_composite/smb_composite.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"
+#include "torture/raw/proto.h"
#define BASEDIR "\\composite"
static void loadfile_complete(struct composite_context *c)
{
- int *count = talloc_get_type(c->async.private, int);
+ int *count = talloc_get_type(c->async.private_data, int);
(*count)++;
}
/*
test a simple savefile/loadfile combination
*/
-static BOOL test_loadfile(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_loadfile(struct torture_context *tctx, struct smbcli_state *cli)
{
const char *fname = BASEDIR "\\test.txt";
NTSTATUS status;
struct smb_composite_savefile io1;
- struct smb_composite_loadfile io2;
+ struct smb_composite_loadfile *io2;
struct composite_context **c;
- char *data;
+ uint8_t *data;
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");
+ torture_comment(tctx, "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;
- }
-
- io2.in.fname = fname;
+ torture_assert_ntstatus_equal(tctx, status, NT_STATUS_OK, "savefile failed");
- printf("testing parallel loadfile with %d ops\n", num_ops);
+ torture_comment(tctx, "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);
+ io2 = talloc_zero_array(tctx, struct smb_composite_loadfile, num_ops);
for (i=0;i<num_ops;i++) {
- c[i] = smb_composite_loadfile_send(cli->tree, &io2);
+ io2[i].in.fname = fname;
+ c[i] = smb_composite_loadfile_send(cli->tree, &io2[i]);
c[i]->async.fn = loadfile_complete;
- c[i]->async.private = count;
+ c[i]->async.private_data = count;
}
- printf("waiting for completion\n");
+ torture_comment(tctx, "waiting for completion\n");
while (*count != num_ops) {
- event_loop_once(cli->transport->socket->event.ctx);
- printf("count=%d\r", *count);
- fflush(stdout);
+ tevent_loop_once(tctx->ev);
+ if (torture_setting_bool(tctx, "progress", true)) {
+ torture_comment(tctx, "(%s) count=%d\r", __location__, *count);
+ fflush(stdout);
+ }
}
- printf("count=%d\n", *count);
+ torture_comment(tctx, "count=%d\n", *count);
for (i=0;i<num_ops;i++) {
- status = smb_composite_loadfile_recv(c[i], mem_ctx);
- if (!NT_STATUS_IS_OK(status)) {
- printf("loadfile[%d] failed - %s\n", i, nt_errstr(status));
- return False;
- }
+ status = smb_composite_loadfile_recv(c[i], tctx);
+ torture_assert_ntstatus_equal(tctx, status, NT_STATUS_OK, "loadfile failed");
- if (io2.out.size != len) {
- printf("wrong length in returned data - %d should be %d\n",
- io2.out.size, len);
- return False;
- }
-
- if (memcmp(io2.out.data, data, len) != 0) {
- printf("wrong data in loadfile!\n");
- return False;
- }
+ torture_assert_int_equal(tctx, io2[i].out.size, len, "wrong length in returned data");
+ torture_assert_mem_equal(tctx, io2[i].out.data, data, len, "wrong data in loadfile");
}
talloc_free(data);
- return True;
+ return true;
+}
+
+static bool test_loadfile_t(struct torture_context *tctx, struct smbcli_state *cli)
+{
+ int ret;
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "failed to setup " BASEDIR);
+
+ ret = test_loadfile(tctx, cli);
+ smb_raw_exit(cli->session);
+ smbcli_deltree(cli->tree, BASEDIR);
+
+ return ret;
}
/*
test a simple savefile/loadfile combination
*/
-static BOOL test_fetchfile(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
+static bool test_fetchfile(struct torture_context *tctx, struct smbcli_state *cli)
{
const char *fname = BASEDIR "\\test.txt";
NTSTATUS status;
struct smb_composite_savefile io1;
struct smb_composite_fetchfile io2;
struct composite_context **c;
- char *data;
+ uint8_t *data;
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);
+ ZERO_STRUCT(io1);
io1.in.fname = fname;
io1.in.data = data;
io1.in.size = len;
- printf("testing savefile\n");
+ torture_comment(tctx, "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;
- }
+ torture_assert_ntstatus_equal(tctx, status, NT_STATUS_OK, "savefile failed");
- 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.calling_name = lp_netbios_name();
- io2.in.service = lp_parm_string(-1, "torture", "share");
+ ZERO_STRUCT(io2);
+
+ io2.in.dest_host = torture_setting_string(tctx, "host", NULL);
+ io2.in.ports = lpcfg_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.user = lp_parm_string(-1, "torture", "username");
- io2.in.domain = lp_parm_string(-1, "torture", "userdomain");
- io2.in.password = lp_parm_string(-1, "torture", "password");
+ io2.in.socket_options = lpcfg_socket_options(tctx->lp_ctx);
+
+ io2.in.credentials = cmdline_credentials;
+ io2.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
io2.in.filename = fname;
+ lpcfg_smbcli_options(tctx->lp_ctx, &io2.in.options);
+ lpcfg_smbcli_session_options(tctx->lp_ctx, &io2.in.session_options);
+ io2.in.resolve_ctx = lpcfg_resolve_context(tctx->lp_ctx);
+ io2.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);
- printf("testing parallel fetchfile with %d ops\n", torture_numops);
+ torture_comment(tctx, "Testing parallel fetchfile with %d ops\n", torture_numops);
- event_ctx = event_context_init(mem_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_fetchfile_send(&io2, event_ctx);
c[i]->async.fn = loadfile_complete;
- c[i]->async.private = count;
+ c[i]->async.private_data = count;
}
- printf("waiting for completion\n");
+ torture_comment(tctx, "waiting for completion\n");
while (*count != torture_numops) {
- event_loop_once(event_ctx);
- printf("count=%d\r", *count);
- fflush(stdout);
+ tevent_loop_once(event_ctx);
+ if (torture_setting_bool(tctx, "progress", true)) {
+ torture_comment(tctx, "(%s) count=%d\r", __location__, *count);
+ fflush(stdout);
+ }
}
- printf("count=%d\n", *count);
+ torture_comment(tctx, "count=%d\n", *count);
for (i=0;i<torture_numops;i++) {
- status = smb_composite_fetchfile_recv(c[i], mem_ctx);
- if (!NT_STATUS_IS_OK(status)) {
- printf("loadfile[%d] failed - %s\n", i,
- nt_errstr(status));
- ret = False;
- continue;
+ status = smb_composite_fetchfile_recv(c[i], tctx);
+ torture_assert_ntstatus_equal(tctx, status, NT_STATUS_OK, "loadfile failed");
+
+ torture_assert_int_equal(tctx, io2.out.size, len, "wrong length in returned data");
+ torture_assert_mem_equal(tctx, io2.out.data, data, len, "wrong data in loadfile");
+ }
+
+ return ret;
+}
+
+static bool test_fetchfile_t(struct torture_context *tctx, struct smbcli_state *cli)
+{
+ int ret;
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "failed to setup " BASEDIR);
+ ret = test_fetchfile(tctx, cli);
+ smb_raw_exit(cli->session);
+ smbcli_deltree(cli->tree, BASEDIR);
+
+ return ret;
+}
+
+/*
+ test setfileacl
+*/
+static bool test_appendacl(struct torture_context *tctx, struct smbcli_state *cli)
+{
+ struct smb_composite_appendacl **io;
+ struct smb_composite_appendacl **io_orig;
+ struct composite_context **c;
+ 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(tctx, int);
+ struct smb_composite_savefile io1;
+
+ NTSTATUS status;
+ int i;
+
+ 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);
+
+ for (i = 0; i < num_ops; i++) {
+ io1.in.fname = talloc_asprintf(io_orig, BASEDIR "\\test%d.txt", i);
+ io1.in.data = NULL;
+ io1.in.size = 0;
+
+ status = smb_composite_savefile(cli->tree, &io1);
+ torture_assert_ntstatus_equal(tctx, status, NT_STATUS_OK, "savefile failed");
+
+ io_orig[i] = talloc (io_orig, struct smb_composite_appendacl);
+ io_orig[i]->in.fname = talloc_steal(io_orig[i], io1.in.fname);
+ io_orig[i]->in.sd = security_descriptor_initialise(io_orig[i]);
+ status = smb_composite_appendacl(cli->tree, io_orig[i], io_orig[i]);
+ torture_assert_ntstatus_equal(tctx, status, NT_STATUS_OK, "appendacl failed");
+ }
+
+
+ /* fill Security Descriptor with aces to be added */
+
+ test_sd = security_descriptor_initialise(tctx);
+ test_sid = dom_sid_parse_talloc (tctx, "S-1-5-32-1234-5432");
+
+ ace = talloc_zero(tctx, struct security_ace);
+
+ ace->type = SEC_ACE_TYPE_ACCESS_ALLOWED;
+ ace->flags = 0;
+ ace->access_mask = SEC_STD_ALL;
+ ace->trustee = *test_sid;
+
+ status = security_descriptor_dacl_add(test_sd, ace);
+ torture_assert_ntstatus_equal(tctx, status, NT_STATUS_OK, "appendacl failed");
+
+ /* set parameters for appendacl async call */
+
+ torture_comment(tctx, "Testing parallel appendacl with %d ops\n", 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);
+ io[i]->in.sd = test_sd;
+ io[i]->in.fname = talloc_asprintf(io[i], BASEDIR "\\test%d.txt", i);
+
+ c[i] = smb_composite_appendacl_send(cli->tree, io[i]);
+ c[i]->async.fn = loadfile_complete;
+ c[i]->async.private_data = count;
+ }
+
+ event_ctx = tctx->ev;
+ torture_comment(tctx, "waiting for completion\n");
+ while (*count != num_ops) {
+ tevent_loop_once(event_ctx);
+ if (torture_setting_bool(tctx, "progress", true)) {
+ torture_comment(tctx, "(%s) count=%d\r", __location__, *count);
+ fflush(stdout);
}
+ }
+ torture_comment(tctx, "count=%d\n", *count);
- if (io2.out.size != len) {
- printf("wrong length in returned data - %d "
- "should be %d\n",
- io2.out.size, len);
- ret = False;
- continue;
+ for (i=0; i < num_ops; i++) {
+ status = smb_composite_appendacl_recv(c[i], io[i]);
+ if (!NT_STATUS_IS_OK(status)) {
+ torture_comment(tctx, "(%s) appendacl[%d] failed - %s\n", __location__, i, nt_errstr(status));
+ return false;
}
- if (memcmp(io2.out.data, data, len) != 0) {
- printf("wrong data in loadfile!\n");
- ret = False;
- continue;
- }
+ security_descriptor_dacl_add(io_orig[i]->out.sd, ace);
+ torture_assert(tctx,
+ security_acl_equal(io_orig[i]->out.sd->dacl,
+ io[i]->out.sd->dacl),
+ "appendacl failed - needed acl isn't set");
}
+
+
+ talloc_free (ace);
+ talloc_free (test_sid);
+ talloc_free (test_sd);
+
+ return true;
+}
+
+static bool test_appendacl_t(struct torture_context *tctx, struct smbcli_state *cli)
+{
+ int ret;
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "failed to setup " BASEDIR);
+ ret = test_appendacl(tctx, cli);
+ smb_raw_exit(cli->session);
+ smbcli_deltree(cli->tree, BASEDIR);
return ret;
}
-/*
- basic testing of libcli composite calls
-*/
-BOOL torture_raw_composite(void)
+/* test a query FS info by asking for share's GUID */
+static bool test_fsinfo(struct torture_context *tctx, struct smbcli_state *cli)
{
- struct smbcli_state *cli;
- BOOL ret = True;
- TALLOC_CTX *mem_ctx;
+ char *guid = NULL;
+ NTSTATUS status;
+ struct smb_composite_fsinfo io1;
+ struct composite_context **c;
+
+ int i;
+ extern int torture_numops;
+ 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 = lpcfg_smb_ports(tctx->lp_ctx);
+ io1.in.socket_options = lpcfg_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 = lpcfg_workgroup(tctx->lp_ctx);
+ io1.in.level = RAW_QFS_OBJECTID_INFORMATION;
+ io1.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);
+
+ torture_comment(tctx, "Testing parallel queryfsinfo [Object ID] with %d ops\n",
+ torture_numops);
+
+ event_ctx = tctx->ev;
+ c = talloc_array(tctx, struct composite_context *, torture_numops);
- if (!torture_open_connection(&cli)) {
- return False;
+ for (i=0; i<torture_numops; i++) {
+ c[i] = smb_composite_fsinfo_send(cli->tree, &io1, lpcfg_resolve_context(tctx->lp_ctx), event_ctx);
+ torture_assert(tctx, c[i], "smb_composite_fsinfo_send failed!");
+ c[i]->async.fn = loadfile_complete;
+ c[i]->async.private_data = count;
}
- mem_ctx = talloc_init("torture_raw_composite");
+ torture_comment(tctx, "waiting for completion\n");
- if (!torture_setup_dir(cli, BASEDIR)) {
- return False;
+ while (*count < torture_numops) {
+ tevent_loop_once(event_ctx);
+ if (torture_setting_bool(tctx, "progress", true)) {
+ torture_comment(tctx, "(%s) count=%d\r", __location__, *count);
+ fflush(stdout);
+ }
}
+ torture_comment(tctx, "count=%d\n", *count);
- ret &= test_fetchfile(cli, mem_ctx);
- ret &= test_loadfile(cli, mem_ctx);
+ for (i=0;i<torture_numops;i++) {
+ status = smb_composite_fsinfo_recv(c[i], tctx);
+ torture_assert_ntstatus_equal(tctx, status, NT_STATUS_OK, "smb_composite_fsinfo_recv failed");
+
+ torture_assert_int_equal(tctx, io1.out.fsinfo->generic.level, RAW_QFS_OBJECTID_INFORMATION, "wrong level in returned info");
+ guid=GUID_string(tctx, &io1.out.fsinfo->objectid_information.out.guid);
+ torture_comment(tctx, "[%d] GUID: %s\n", i, guid);
+ }
+
+ return ret;
+}
+
+static bool test_fsinfo_t(struct torture_context *tctx, struct smbcli_state *cli)
+{
+ int ret;
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "failed to setup " BASEDIR);
+ ret = test_fsinfo(tctx, cli);
smb_raw_exit(cli->session);
smbcli_deltree(cli->tree, BASEDIR);
- torture_close_connection(cli);
- talloc_free(mem_ctx);
return ret;
}
+
+/*
+ basic testing of all RAW_SEARCH_* calls using a single file
+*/
+struct torture_suite *torture_raw_composite(TALLOC_CTX *mem_ctx)
+{
+ struct torture_suite *suite = torture_suite_create(mem_ctx, "composite");
+
+ torture_suite_add_1smb_test(suite, "fetchfile", test_fetchfile_t);
+ torture_suite_add_1smb_test(suite, "loadfile", test_loadfile_t);
+ torture_suite_add_1smb_test(suite, "appendacl", test_appendacl_t);
+ torture_suite_add_1smb_test(suite, "fsinfo", test_fsinfo_t);
+
+ return suite;
+}
git.samba.org / samba.git / blobdiff