#include "dbwrap/dbwrap.h"
#include "dbwrap/dbwrap_open.h"
#include "dbwrap/dbwrap_rbt.h"
-#include "talloc_dict.h"
#include "async_smb.h"
#include "libsmb/libsmb.h"
#include "libsmb/clirap.h"
static bool torture_open_connection_share(struct cli_state **c,
const char *hostname,
- const char *sharename)
+ const char *sharename,
+ int flags)
{
- int flags = 0;
NTSTATUS status;
- if (use_oplocks)
- flags |= CLI_FULL_CONNECTION_OPLOCKS;
- if (use_level_II_oplocks)
- flags |= CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS;
-
status = cli_full_connection_creds(c,
myname,
hostname,
return True;
}
-bool torture_open_connection(struct cli_state **c, int conn_index)
+bool torture_open_connection_flags(struct cli_state **c, int conn_index, int flags)
{
char **unc_list = NULL;
int num_unc_names = 0;
exit(1);
}
- result = torture_open_connection_share(c, h, s);
+ result = torture_open_connection_share(c, h, s, flags);
/* h, s were copied earlier */
TALLOC_FREE(unc_list);
return result;
}
- return torture_open_connection_share(c, host, share);
+ return torture_open_connection_share(c, host, share, flags);
+}
+
+bool torture_open_connection(struct cli_state **c, int conn_index)
+{
+ int flags = CLI_FULL_CONNECTION_FORCE_SMB1;
+
+ if (use_oplocks) {
+ flags |= CLI_FULL_CONNECTION_OPLOCKS;
+ }
+ if (use_level_II_oplocks) {
+ flags |= CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS;
+ }
+
+ return torture_open_connection_flags(c, conn_index, flags);
}
bool torture_init_connection(struct cli_state **pcli)
static struct cli_state *cli;
const char *fname = "\\tcontest.tmp";
uint16_t fnum1;
- uint16_t cnum1, cnum2, cnum3;
+ uint32_t cnum1, cnum2, cnum3;
+ struct smbXcli_tcon *orig_tcon = NULL;
uint16_t vuid1, vuid2;
char buf[4];
bool ret = True;
return False;
}
+ orig_tcon = cli_state_save_tcon(cli);
+ if (orig_tcon == NULL) {
+ return false;
+ }
+
status = cli_tree_connect_creds(cli, share, "?????", torture_creds);
if (!NT_STATUS_IS_OK(status)) {
printf("%s refused 2nd tree connect (%s)\n", host,
return False;
}
+ cli_state_restore_tcon(cli, orig_tcon);
+
cli_state_set_tid(cli, cnum1);
if (!torture_close_connection(cli)) {
if (NT_STATUS_IS_OK(expected_error)) {
if (NT_STATUS_IS_OK(status)) {
- if (strcmp(cli->dev, return_devtype) == 0) {
+ if (return_devtype != NULL &&
+ strequal(cli->dev, return_devtype)) {
ret = True;
} else {
printf("tconX to share %s with type %s "
static bool run_tcon_devtype_test(int dummy)
{
static struct cli_state *cli1 = NULL;
- int flags = 0;
+ int flags = CLI_FULL_CONNECTION_FORCE_SMB1;
NTSTATUS status;
bool ret = True;
struct cli_state *cli;
uint16_t new_vuid;
uint16_t saved_vuid;
- uint16_t new_cnum;
- uint16_t saved_cnum;
+ uint32_t new_cnum;
+ uint32_t saved_cnum;
const char *fname = "\\fdsess.tst";
const char *fname1 = "\\fdsess1.tst";
uint16_t fnum1;
struct tevent_req *req;
req = smbXcli_negprot_send(ev, ev, cli->conn, cli->timeout,
- PROTOCOL_CORE, PROTOCOL_NT1);
+ PROTOCOL_CORE, PROTOCOL_NT1, 0);
if (req == NULL) {
TALLOC_FREE(ev);
return false;
}
+static bool check_attributes(struct cli_state *cli,
+ const char *fname,
+ uint16_t expected_attrs)
+{
+ uint16_t attrs = 0;
+ NTSTATUS status = cli_getatr(cli,
+ fname,
+ &attrs,
+ NULL,
+ NULL);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("cli_getatr failed with %s\n",
+ nt_errstr(status));
+ return false;
+ }
+ if (attrs != expected_attrs) {
+ printf("Attributes incorrect 0x%x, should be 0x%x\n",
+ (unsigned int)attrs,
+ (unsigned int)expected_attrs);
+ return false;
+ }
+ return true;
+}
/*
This checks how the getatr calls works
correct = False;
}
- if (abs(t - time(NULL)) > 60*60*24*10) {
+ if (labs(t - time(NULL)) > 60*60*24*10) {
printf("ERROR: SMBgetatr bug. time is %s",
ctime(&t));
t = time(NULL);
cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
+ /* Check cli_setpathinfo_basic() */
+ /* Re-create the file. */
+ status = cli_openx(cli, fname,
+ O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("Failed to recreate %s (%s)\n",
+ fname, nt_errstr(status));
+ correct = false;
+ }
+ cli_close(cli, fnum);
+
+ status = cli_setpathinfo_basic(cli,
+ fname,
+ 0, /* create */
+ 0, /* access */
+ 0, /* write */
+ 0, /* change */
+ FILE_ATTRIBUTE_SYSTEM |
+ FILE_ATTRIBUTE_HIDDEN |
+ FILE_ATTRIBUTE_READONLY);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("cli_setpathinfo_basic failed with %s\n",
+ nt_errstr(status));
+ correct = false;
+ }
+
+ /* Check attributes are correct. */
+ correct = check_attributes(cli,
+ fname,
+ FILE_ATTRIBUTE_SYSTEM |
+ FILE_ATTRIBUTE_HIDDEN |
+ FILE_ATTRIBUTE_READONLY);
+ if (correct == false) {
+ goto out;
+ }
+
+ /* Setting to FILE_ATTRIBUTE_NORMAL should be ignored. */
+ status = cli_setpathinfo_basic(cli,
+ fname,
+ 0, /* create */
+ 0, /* access */
+ 0, /* write */
+ 0, /* change */
+ FILE_ATTRIBUTE_NORMAL);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("cli_setpathinfo_basic failed with %s\n",
+ nt_errstr(status));
+ correct = false;
+ }
+
+ /* Check attributes are correct. */
+ correct = check_attributes(cli,
+ fname,
+ FILE_ATTRIBUTE_SYSTEM |
+ FILE_ATTRIBUTE_HIDDEN |
+ FILE_ATTRIBUTE_READONLY);
+ if (correct == false) {
+ goto out;
+ }
+
+ /* Setting to (uint16_t)-1 should also be ignored. */
+ status = cli_setpathinfo_basic(cli,
+ fname,
+ 0, /* create */
+ 0, /* access */
+ 0, /* write */
+ 0, /* change */
+ (uint16_t)-1);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("cli_setpathinfo_basic failed with %s\n",
+ nt_errstr(status));
+ correct = false;
+ }
+
+ /* Check attributes are correct. */
+ correct = check_attributes(cli,
+ fname,
+ FILE_ATTRIBUTE_SYSTEM |
+ FILE_ATTRIBUTE_HIDDEN |
+ FILE_ATTRIBUTE_READONLY);
+ if (correct == false) {
+ goto out;
+ }
+
+ /* Setting to 0 should clear them all. */
+ status = cli_setpathinfo_basic(cli,
+ fname,
+ 0, /* create */
+ 0, /* access */
+ 0, /* write */
+ 0, /* change */
+ 0);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("cli_setpathinfo_basic failed with %s\n",
+ nt_errstr(status));
+ correct = false;
+ }
+
+ /* Check attributes are correct. */
+ correct = check_attributes(cli,
+ fname,
+ FILE_ATTRIBUTE_NORMAL);
+ if (correct == false) {
+ goto out;
+ }
+
+ out:
+
+ cli_unlink(cli,
+ fname,
+ FILE_ATTRIBUTE_SYSTEM |
+ FILE_ATTRIBUTE_HIDDEN|
+ FILE_ATTRIBUTE_READONLY);
+
if (!torture_close_connection(cli)) {
correct = False;
}
printf("modify time=%s", ctime(&m_time));
printf("This system appears to have sticky create times\n");
}
- if ((abs(a_time - t) > 60) && (a_time % (60*60) == 0)) {
+ if ((labs(a_time - t) > 60) && (a_time % (60*60) == 0)) {
printf("access time=%s", ctime(&a_time));
printf("This system appears to set a midnight access time\n");
correct = False;
}
- if (abs(m_time - t) > 60*60*24*7) {
+ if (labs(m_time - t) > 60*60*24*7) {
printf("ERROR: totally incorrect times - maybe word reversed? mtime=%s", ctime(&m_time));
correct = False;
}
return False;
}
- status = cli_rename(cli1, fname, fname1);
+ status = cli_rename(cli1, fname, fname1, false);
if (!NT_STATUS_IS_OK(status)) {
printf("First rename failed (SHARE_READ) (this is correct) - %s\n", nt_errstr(status));
} else {
return False;
}
- status = cli_rename(cli1, fname, fname1);
+ status = cli_rename(cli1, fname, fname1, false);
if (!NT_STATUS_IS_OK(status)) {
printf("Second rename failed (SHARE_DELETE | SHARE_READ) - this should have succeeded - %s\n", nt_errstr(status));
correct = False;
}
#endif
- status = cli_rename(cli1, fname, fname1);
+ status = cli_rename(cli1, fname, fname1, false);
if (!NT_STATUS_IS_OK(status)) {
printf("Third rename failed (SHARE_NONE) - this should have succeeded - %s\n", nt_errstr(status));
correct = False;
return False;
}
- status = cli_rename(cli1, fname, fname1);
+ status = cli_rename(cli1, fname, fname1, false);
if (!NT_STATUS_IS_OK(status)) {
printf("Fourth rename failed (SHARE_READ | SHARE_WRITE) (this is correct) - %s\n", nt_errstr(status));
} else {
return False;
}
- status = cli_rename(cli1, fname, fname1);
+ status = cli_rename(cli1, fname, fname1, false);
if (!NT_STATUS_IS_OK(status)) {
printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have succeeded - %s ! \n", nt_errstr(status));
correct = False;
* dst directory should fail.
*/
- status = cli_rename(cli, src, dst);
+ status = cli_rename(cli, src, dst, false);
if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
printf("rename of %s -> %s should be ACCESS denied, was %s\n",
src, dst, nt_errstr(status));
goto fail;
}
- status = cli_rename(cli, dsrc, ddst);
+ status = cli_rename(cli, dsrc, ddst, false);
if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
printf("rename of %s -> %s should be ACCESS denied, was %s\n",
src, dst, nt_errstr(status));
}
if (cli) {
- if (fnum != -1) {
+ if (fnum != (uint16_t)-1) {
cli_close(cli, fnum);
}
cli_unlink(cli, src,
fail:
if (cli) {
- if (fnum != -1) {
+ if (fnum != (uint16_t)-1) {
cli_close(cli, fnum);
}
cli_unlink(cli, fname,
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]);
+ reqs[2] = cli_smb1_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);
struct tevent_req *reqs[2], *smbreqs[2];
bool done = false;
NTSTATUS status;
+ int flags = CLI_FULL_CONNECTION_FORCE_SMB1;
printf("starting chain2 test\n");
status = cli_start_connection(&cli1, lp_netbios_name(), host, NULL,
- port_to_use, SMB_SIGNING_DEFAULT, 0);
+ port_to_use, SMB_SIGNING_DEFAULT, flags);
if (!NT_STATUS_IS_OK(status)) {
return False;
}
{
static struct cli_state *cli;
int16_t old_vuid;
- int16_t old_cnum;
+ int32_t old_cnum;
bool correct = True;
+ struct smbXcli_tcon *orig_tcon = NULL;
NTSTATUS status;
printf("starting uid regression test\n");
}
old_cnum = cli_state_get_tid(cli);
+ orig_tcon = cli_state_save_tcon(cli);
+ if (orig_tcon == NULL) {
+ correct = false;
+ goto out;
+ }
/* Now try a SMBtdis with the invald vuid set to zero. */
cli_state_set_uid(cli, 0);
} else {
d_printf("First tdis failed (%s)\n", nt_errstr(status));
correct = false;
+ cli_state_restore_tcon(cli, orig_tcon);
goto out;
}
+ cli_state_restore_tcon(cli, orig_tcon);
cli_state_set_uid(cli, old_vuid);
cli_state_set_tid(cli, old_cnum);
return success;
}
+/*
+ Test Windows open on a bad POSIX symlink.
+ */
+static bool run_symlink_open_test(int dummy)
+{
+ static struct cli_state *cli;
+ const char *fname = "non_existant_file";
+ const char *sname = "dangling_symlink";
+ uint16_t fnum = (uint16_t)-1;
+ bool correct = false;
+ NTSTATUS status;
+ TALLOC_CTX *frame = NULL;
+
+ frame = talloc_stackframe();
+
+ printf("Starting Windows bad symlink open test\n");
+
+ if (!torture_open_connection(&cli, 0)) {
+ TALLOC_FREE(frame);
+ return false;
+ }
+
+ smbXcli_conn_set_sockopt(cli->conn, sockops);
+
+ status = torture_setup_unix_extensions(cli);
+ if (!NT_STATUS_IS_OK(status)) {
+ TALLOC_FREE(frame);
+ return false;
+ }
+
+ /* Ensure nothing exists. */
+ cli_setatr(cli, fname, 0, 0);
+ cli_posix_unlink(cli, fname);
+ cli_setatr(cli, sname, 0, 0);
+ cli_posix_unlink(cli, sname);
+
+ /* Create a symlink pointing nowhere. */
+ status = cli_posix_symlink(cli, fname, sname);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("cli_posix_symlink of %s -> %s failed (%s)\n",
+ sname,
+ fname,
+ nt_errstr(status));
+ goto out;
+ }
+
+ /* Now ensure that a Windows open doesn't hang. */
+ status = cli_ntcreate(cli,
+ sname,
+ 0,
+ FILE_READ_DATA|FILE_WRITE_DATA,
+ 0,
+ FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
+ FILE_OPEN_IF,
+ 0x0,
+ 0x0,
+ &fnum,
+ NULL);
+
+ /*
+ * We get either NT_STATUS_OBJECT_NAME_NOT_FOUND or
+ * NT_STATUS_OBJECT_PATH_NOT_FOUND depending on if
+ * we use O_NOFOLLOW on the server or not.
+ */
+ if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND) ||
+ NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND))
+ {
+ correct = true;
+ } else {
+ printf("cli_ntcreate of %s returned %s - should return"
+ " either (%s) or (%s)\n",
+ sname,
+ nt_errstr(status),
+ nt_errstr(NT_STATUS_OBJECT_NAME_NOT_FOUND),
+ nt_errstr(NT_STATUS_OBJECT_PATH_NOT_FOUND));
+ goto out;
+ }
+
+ correct = true;
+
+ out:
+
+ if (fnum != (uint16_t)-1) {
+ cli_close(cli, fnum);
+ fnum = (uint16_t)-1;
+ }
+
+ cli_setatr(cli, sname, 0, 0);
+ cli_posix_unlink(cli, sname);
+ cli_setatr(cli, fname, 0, 0);
+ cli_posix_unlink(cli, fname);
+
+ if (!torture_close_connection(cli)) {
+ correct = false;
+ }
+
+ TALLOC_FREE(frame);
+ return correct;
+}
+
static bool run_local_substitute(int dummy)
{
bool ok = true;
blob = data_blob_string_const_null("bar");
tm = time(NULL) + 60;
- if (!gencache_set_data_blob("foo", &blob, tm)) {
+ if (!gencache_set_data_blob("foo", blob, tm)) {
d_printf("%s: gencache_set_data_blob() failed\n", __location__);
return False;
}
blob.data = (uint8_t *)&v;
blob.length = sizeof(v);
- if (!gencache_set_data_blob("blob", &blob, tm)) {
+ if (!gencache_set_data_blob("blob", blob, tm)) {
d_printf("%s: gencache_set_data_blob() failed\n",
__location__);
return false;
return false;
}
-
-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, res;
- bool ok;
-
- 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;
- ok = talloc_dict_set(dict, data_blob_const(&key, sizeof(key)), &t);
- if (!ok) {
- return false;
- }
-
- count = 0;
- res = talloc_dict_traverse(dict, talloc_dict_traverse_fn, &count);
- if (res == -1) {
- return false;
- }
-
- if (count != 1) {
- return false;
- }
-
- if (count != res) {
- return false;
- }
-
- TALLOC_FREE(dict);
-
- return true;
-}
-
static bool run_local_string_to_sid(int dummy) {
struct dom_sid sid;
static bool run_local_memcache(int dummy)
{
struct memcache *cache;
- DATA_BLOB k1, k2;
- DATA_BLOB d1, d2, d3;
- DATA_BLOB v1, v2, v3;
+ DATA_BLOB k1, k2, k3;
+ DATA_BLOB d1, d3;
+ DATA_BLOB v1, v3;
TALLOC_CTX *mem_ctx;
+ char *ptr1 = NULL;
+ char *ptr2 = NULL;
+
char *str1, *str2;
size_t size1, size2;
bool ret = false;
+ mem_ctx = talloc_init("foo");
+ if (mem_ctx == NULL) {
+ return false;
+ }
+
+ /* STAT_CACHE TESTS */
+
cache = memcache_init(NULL, sizeof(void *) == 8 ? 200 : 100);
if (cache == NULL) {
}
d1 = data_blob_const("d1", 2);
- d2 = data_blob_const("d2", 2);
d3 = data_blob_const("d3", 2);
k1 = data_blob_const("d1", 2);
k2 = data_blob_const("d2", 2);
+ k3 = data_blob_const("d3", 2);
memcache_add(cache, STAT_CACHE, k1, d1);
- memcache_add(cache, GETWD_CACHE, k2, d2);
if (!memcache_lookup(cache, STAT_CACHE, k1, &v1)) {
printf("could not find k1\n");
return false;
}
- if (!memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
- printf("could not find k2\n");
+ memcache_add(cache, STAT_CACHE, k1, d3);
+
+ if (!memcache_lookup(cache, STAT_CACHE, k1, &v3)) {
+ printf("could not find replaced k1\n");
return false;
}
- if (!data_blob_equal(d2, v2)) {
+ if (!data_blob_equal(d3, v3)) {
return false;
}
- memcache_add(cache, STAT_CACHE, k1, d3);
+ TALLOC_FREE(cache);
- if (!memcache_lookup(cache, STAT_CACHE, k1, &v3)) {
- printf("could not find replaced k1\n");
+ /* GETWD_CACHE TESTS */
+ str1 = talloc_strdup(mem_ctx, "string1");
+ if (str1 == NULL) {
return false;
}
- if (!data_blob_equal(d3, v3)) {
+ ptr2 = str1; /* Keep an alias for comparison. */
+
+ str2 = talloc_strdup(mem_ctx, "string2");
+ if (str2 == NULL) {
return false;
}
- memcache_add(cache, GETWD_CACHE, k1, d1);
+ cache = memcache_init(NULL, sizeof(void *) == 8 ? 200 : 100);
+ if (cache == NULL) {
+ printf("memcache_init failed\n");
+ return false;
+ }
- if (memcache_lookup(cache, GETWD_CACHE, k2, &v2)) {
+ memcache_add_talloc(cache, GETWD_CACHE, k2, &str1);
+ /* str1 == NULL now. */
+ ptr1 = memcache_lookup_talloc(cache, GETWD_CACHE, k2);
+ if (ptr1 == NULL) {
+ printf("could not find k2\n");
+ return false;
+ }
+ if (ptr1 != ptr2) {
+ printf("fetch of k2 got wrong string\n");
+ return false;
+ }
+
+ /* Add a blob to ensure k2 gets purged. */
+ d3 = data_blob_talloc_zero(mem_ctx, 180);
+ memcache_add(cache, STAT_CACHE, k3, d3);
+
+ ptr2 = memcache_lookup_talloc(cache, GETWD_CACHE, k2);
+ if (ptr2 != NULL) {
printf("Did find k2, should have been purged\n");
return false;
}
TALLOC_FREE(cache);
-
- cache = memcache_init(NULL, 0);
+ TALLOC_FREE(mem_ctx);
mem_ctx = talloc_init("foo");
+ if (mem_ctx == NULL) {
+ return false;
+ }
+
+ cache = memcache_init(NULL, 0);
+ if (cache == NULL) {
+ return false;
+ }
str1 = talloc_strdup(mem_ctx, "string1");
+ if (str1 == NULL) {
+ return false;
+ }
str2 = talloc_strdup(mem_ctx, "string2");
-
+ if (str2 == NULL) {
+ return false;
+ }
memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC,
data_blob_string_const("torture"), &str1);
size1 = talloc_total_size(cache);
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 = samba_tevent_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,
- discard_const_p(void, names[i]));
- }
-
- for (i=0; i<ARRAY_SIZE(reqs); i++) {
- tevent_loop_once(ev);
- }
-
- result = true;
-fail:
- TALLOC_FREE(frame);
- return result;
-}
-
static bool dbtrans_inc(struct db_context *db)
{
struct db_record *rec;
/*
* Just a dummy test to be run under a debugger. There's no real way
- * to inspect the tevent_select specific function from outside of
- * tevent_select.c.
+ * to inspect the tevent_poll specific function from outside of
+ * tevent_poll.c.
*/
-static bool run_local_tevent_select(int dummy)
+static bool run_local_tevent_poll(int dummy)
{
struct tevent_context *ev;
struct tevent_fd *fd1, *fd2;
bool result = false;
- ev = tevent_context_init_byname(NULL, "select");
+ ev = tevent_context_init_byname(NULL, "poll");
if (ev == NULL) {
d_fprintf(stderr, "tevent_context_init_byname failed\n");
goto fail;
return true;
}
+static bool run_local_canonicalize_path(int dummy)
+{
+ const char *src[] = {
+ "/foo/..",
+ "/..",
+ "/foo/bar/../baz",
+ "/foo/././",
+ "/../foo",
+ ".././././",
+ ".././././../../../boo",
+ "./..",
+ NULL
+ };
+ const char *dst[] = {
+ "/",
+ "/",
+ "/foo/baz",
+ "/foo",
+ "/foo",
+ "/",
+ "/boo",
+ "/",
+ NULL
+ };
+ unsigned int i;
+
+ for (i = 0; src[i] != NULL; i++) {
+ char *d = canonicalize_absolute_path(talloc_tos(), src[i]);
+ if (d == NULL) {
+ perror("talloc fail\n");
+ return false;
+ }
+ if (strcmp(d, dst[i]) != 0) {
+ d_fprintf(stderr,
+ "canonicalize missmatch %s -> %s != %s",
+ src[i], d, dst[i]);
+ return false;
+ }
+ talloc_free(d);
+ }
+ return true;
+}
+
+static bool run_ign_bad_negprot(int dummy)
+{
+ struct tevent_context *ev;
+ struct tevent_req *req;
+ struct smbXcli_conn *conn;
+ struct sockaddr_storage ss;
+ NTSTATUS status;
+ int fd;
+ bool ok;
+
+ printf("starting ignore bad negprot\n");
+
+ ok = resolve_name(host, &ss, 0x20, true);
+ if (!ok) {
+ d_fprintf(stderr, "Could not resolve name %s\n", host);
+ return false;
+ }
+
+ status = open_socket_out(&ss, 445, 10000, &fd);
+ if (!NT_STATUS_IS_OK(status)) {
+ d_fprintf(stderr, "open_socket_out failed: %s\n",
+ nt_errstr(status));
+ return false;
+ }
+
+ conn = smbXcli_conn_create(talloc_tos(), fd, host, SMB_SIGNING_OFF, 0,
+ NULL, 0);
+ if (conn == NULL) {
+ d_fprintf(stderr, "smbXcli_conn_create failed\n");
+ return false;
+ }
+
+ status = smbXcli_negprot(conn, 0, PROTOCOL_CORE, PROTOCOL_CORE);
+ if (NT_STATUS_IS_OK(status)) {
+ d_fprintf(stderr, "smbXcli_negprot succeeded!\n");
+ return false;
+ }
+
+ ev = samba_tevent_context_init(talloc_tos());
+ if (ev == NULL) {
+ d_fprintf(stderr, "samba_tevent_context_init failed\n");
+ return false;
+ }
+
+ req = smb1cli_session_setup_nt1_send(
+ ev, ev, conn, 0, getpid(), NULL, 65503, 2, 1, 0, "", "",
+ data_blob_null, data_blob_null, 0x40,
+ "Windows 2000 2195", "Windows 2000 5.0");
+ if (req == NULL) {
+ d_fprintf(stderr, "smb1cli_session_setup_nt1_send failed\n");
+ return false;
+ }
+
+ ok = tevent_req_poll_ntstatus(req, ev, &status);
+ if (!ok) {
+ d_fprintf(stderr, "tevent_req_poll failed\n");
+ return false;
+ }
+
+ status = smb1cli_session_setup_nt1_recv(req, NULL, NULL, NULL, NULL,
+ NULL, NULL);
+ if (!NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_RESET)) {
+ d_fprintf(stderr, "smb1cli_session_setup_nt1_recv returned "
+ "%s, expected NT_STATUS_CONNECTION_RESET\n",
+ nt_errstr(status));
+ return false;
+ }
+
+ TALLOC_FREE(conn);
+
+ printf("starting ignore bad negprot\n");
+
+ return true;
+}
+
static double create_procs(bool (*fn)(int), bool *result)
{
int i, status;
{"POSIX-SYMLINK-EA", run_ea_symlink_test, 0},
{"POSIX-STREAM-DELETE", run_posix_stream_delete, 0},
{"POSIX-OFD-LOCK", run_posix_ofd_lock_test, 0},
+ {"WINDOWS-BAD-SYMLINK", run_symlink_open_test, 0},
{"CASE-INSENSITIVE-CREATE", run_case_insensitive_create, 0},
{"ASYNC-ECHO", run_async_echo, 0},
{ "UID-REGRESSION-TEST", run_uid_regression_test, 0},
{ "NTTRANS-CREATE", run_nttrans_create, 0},
{ "NTTRANS-FSCTL", run_nttrans_fsctl, 0},
{ "CLI_ECHO", run_cli_echo, 0},
- { "GETADDRINFO", run_getaddrinfo_send, 0},
{ "TLDAP", run_tldap },
{ "STREAMERROR", run_streamerror },
{ "NOTIFY-BENCH", run_notify_bench },
{ "NOTIFY-BENCH2", run_notify_bench2 },
{ "NOTIFY-BENCH3", run_notify_bench3 },
{ "BAD-NBT-SESSION", run_bad_nbt_session },
+ { "IGN-BAD-NEGPROT", run_ign_bad_negprot },
{ "SMB-ANY-CONNECT", run_smb_any_connect },
{ "NOTIFY-ONLINE", run_notify_online },
{ "SMB2-BASIC", run_smb2_basic },
{ "PIDHIGH", run_pidhigh },
{ "LOCAL-SUBSTITUTE", run_local_substitute, 0},
{ "LOCAL-GENCACHE", run_local_gencache, 0},
- { "LOCAL-TALLOC-DICT", run_local_talloc_dict, 0},
{ "LOCAL-DBWRAP-WATCH1", run_dbwrap_watch1, 0 },
+ { "LOCAL-DBWRAP-WATCH2", run_dbwrap_watch2, 0 },
+ { "LOCAL-DBWRAP-DO-LOCKED1", run_dbwrap_do_locked1, 0 },
{ "LOCAL-MESSAGING-READ1", run_messaging_read1, 0 },
{ "LOCAL-MESSAGING-READ2", run_messaging_read2, 0 },
{ "LOCAL-MESSAGING-READ3", run_messaging_read3, 0 },
{ "LOCAL-sid_to_string", run_local_sid_to_string, 0},
{ "LOCAL-binary_to_sid", run_local_binary_to_sid, 0},
{ "LOCAL-DBTRANS", run_local_dbtrans, 0},
- { "LOCAL-TEVENT-SELECT", run_local_tevent_select, 0},
+ { "LOCAL-TEVENT-POLL", run_local_tevent_poll, 0},
{ "LOCAL-CONVERT-STRING", run_local_convert_string, 0},
{ "LOCAL-CONV-AUTH-INFO", run_local_conv_auth_info, 0},
{ "LOCAL-hex_encode_buf", run_local_hex_encode_buf, 0},
{ "LOCAL-DBWRAP-CTDB", run_local_dbwrap_ctdb, 0 },
{ "LOCAL-BENCH-PTHREADPOOL", run_bench_pthreadpool, 0 },
{ "LOCAL-PTHREADPOOL-TEVENT", run_pthreadpool_tevent, 0 },
+ { "LOCAL-G-LOCK1", run_g_lock1, 0 },
+ { "LOCAL-G-LOCK2", run_g_lock2, 0 },
+ { "LOCAL-G-LOCK3", run_g_lock3, 0 },
+ { "LOCAL-G-LOCK4", run_g_lock4, 0 },
+ { "LOCAL-G-LOCK5", run_g_lock5, 0 },
+ { "LOCAL-G-LOCK-PING-PONG", run_g_lock_ping_pong, 0 },
+ { "LOCAL-CANONICALIZE-PATH", run_local_canonicalize_path, 0 },
+ { "LOCAL-NAMEMAP-CACHE1", run_local_namemap_cache1, 0 },
{ "qpathinfo-bufsize", run_qpathinfo_bufsize, 0 },
{NULL, NULL, 0}};
-/*
- * dummy function to satisfy linker dependency
- */
-struct tevent_context *winbind_event_context(void);
-struct tevent_context *winbind_event_context(void)
-{
- return NULL;
-}
-
/****************************************************************************
run a specified test or "ALL"
****************************************************************************/
git.samba.org / samba.git / blobdiff