int main(int argc, char *argv[])
{
struct tdb_context *tdb;
TDB_DATA key, data;
plan_tests(11);
tdb = tdb_open_ex("run-readonly-check.tdb", 1024,
TDB_DEFAULT,
O_CREAT|O_TRUNC|O_RDWR, 0600, &taplogctx, NULL);
ok1(tdb);
key.dsize = strlen("hi");
key.dptr = discard_const_p(uint8_t, "hi");
data.dsize = strlen("world");
data.dptr = discard_const_p(uint8_t, "world");
ok1(tdb_store(tdb, key, data, TDB_INSERT) == 0);
ok1(tdb_check(tdb, NULL, NULL) == 0);
/* We are also allowed to do a check inside a transaction. */
ok1(tdb_transaction_start(tdb) == 0);
ok1(tdb_check(tdb, NULL, NULL) == 0);
ok1(tdb_close(tdb) == 0);
tdb = tdb_open_ex("run-readonly-check.tdb", 1024,
TDB_DEFAULT, O_RDONLY, 0, &taplogctx, NULL);
ok1(tdb);
ok1(tdb_store(tdb, key, data, TDB_MODIFY) == -1);
ok1(tdb_error(tdb) == TDB_ERR_RDONLY);
ok1(tdb_check(tdb, NULL, NULL) == 0);
ok1(tdb_close(tdb) == 0);
return exit_status();
}
/*
* Create a bkrp_encrypted_secret_vX structure
* the version depends on the version parameter
* the structure is returned as a blob.
* The broken flag is to indicate if we want
* to create a non conform to specification structre
*/
static DATA_BLOB *create_unencryptedsecret(TALLOC_CTX *mem_ctx,
bool broken,
int version)
{
TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
DATA_BLOB *blob = talloc_zero(mem_ctx, DATA_BLOB);
enum ndr_err_code ndr_err;
if (version == 2) {
struct bkrp_encrypted_secret_v2 unenc_sec;
ZERO_STRUCT(unenc_sec);
unenc_sec.secret_len = sizeof(secret);
unenc_sec.secret = discard_const_p(uint8_t, secret);
generate_random_buffer(unenc_sec.payload_key,
sizeof(unenc_sec.payload_key));
ndr_err = ndr_push_struct_blob(blob, blob, &unenc_sec,
(ndr_push_flags_fn_t)ndr_push_bkrp_encrypted_secret_v2);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return NULL;
}
if (broken) {
/* The magic value is correctly set by the NDR push
* but we want to test the behavior of the server
* if a differrent value is provided
*/
((uint8_t*)blob->data)[4] = 79; /* A great year !!! */
}
}
if (version == 3) {
struct bkrp_encrypted_secret_v3 unenc_sec;
ZERO_STRUCT(unenc_sec);
unenc_sec.secret_len = sizeof(secret);
unenc_sec.secret = discard_const_p(uint8_t, secret);
generate_random_buffer(unenc_sec.payload_key,
sizeof(unenc_sec.payload_key));
ndr_err = ndr_push_struct_blob(blob, blob, &unenc_sec,
(ndr_push_flags_fn_t)ndr_push_bkrp_encrypted_secret_v3);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return NULL;
}
if (broken) {
/*
* The magic value is correctly set by the NDR push
* but we want to test the behavior of the server
* if a differrent value is provided
*/
((uint8_t*)blob->data)[4] = 79; /* A great year !!! */
}
}
talloc_free(tmp_ctx);
return blob;
}
/* The code should barf on TDBs created with rwlocks. */
int main(int argc, char *argv[])
{
struct tdb_context *tdb;
unsigned int log_count;
struct tdb_logging_context log_ctx = { log_fn, &log_count };
int ret, status;
pid_t child, wait_ret;
int fromchild[2];
int tochild[2];
char c;
int tdb_flags;
bool runtime_support;
runtime_support = tdb_runtime_check_for_robust_mutexes();
if (!runtime_support) {
skip(1, "No robust mutex support");
return exit_status();
}
key.dsize = strlen("hi");
key.dptr = discard_const_p(uint8_t, "hi");
data.dsize = strlen("world");
data.dptr = discard_const_p(uint8_t, "world");
pipe(fromchild);
pipe(tochild);
tdb_flags = TDB_INCOMPATIBLE_HASH|
TDB_MUTEX_LOCKING|
TDB_CLEAR_IF_FIRST;
child = fork();
if (child == 0) {
close(fromchild[0]);
close(tochild[1]);
return do_child(tdb_flags, fromchild[1], tochild[0]);
}
close(fromchild[1]);
close(tochild[0]);
read(fromchild[0], &c, sizeof(c));
tdb = tdb_open_ex("mutex-allrecord-trylock.tdb", 0, tdb_flags,
O_RDWR|O_CREAT, 0755, &log_ctx, NULL);
ok(tdb, "tdb_open_ex should succeed");
ret = tdb_allrecord_lock(tdb, F_WRLCK, TDB_LOCK_NOWAIT, false);
ok(ret == -1, "tdb_allrecord_lock (nowait) should not succeed");
write(tochild[1], &c, sizeof(c));
wait_ret = wait(&status);
ok(wait_ret == child, "child should have exited correctly");
diag("done");
return exit_status();
}
int main(int argc, char *argv[])
{
struct tdb_context *tdb;
TDB_DATA key, data;
plan_tests(13);
tdb = tdb_open_ex("run-check.tdb", 1, TDB_CLEAR_IF_FIRST,
O_CREAT|O_TRUNC|O_RDWR, 0600, &taplogctx, NULL);
ok1(tdb);
ok1(tdb_check(tdb, NULL, NULL) == 0);
key.dsize = strlen("hi");
key.dptr = discard_const_p(uint8_t, "hi");
data.dsize = strlen("world");
data.dptr = discard_const_p(uint8_t, "world");
ok1(tdb_store(tdb, key, data, TDB_INSERT) == 0);
ok1(tdb_check(tdb, NULL, NULL) == 0);
tdb_close(tdb);
tdb = tdb_open_ex("run-check.tdb", 1024, 0, O_RDWR, 0,
&taplogctx, NULL);
ok1(tdb);
ok1(tdb_check(tdb, NULL, NULL) == 0);
tdb_close(tdb);
tdb = tdb_open_ex("test/tdb.corrupt", 1024, 0, O_RDWR, 0,
&taplogctx, NULL);
ok1(tdb);
ok1(tdb_check(tdb, NULL, NULL) == -1);
ok1(tdb_error(tdb) == TDB_ERR_CORRUPT);
tdb_close(tdb);
/* Big and little endian should work! */
tdb = tdb_open_ex("test/old-nohash-le.tdb", 1024, 0, O_RDWR, 0,
&taplogctx, NULL);
ok1(tdb);
ok1(tdb_check(tdb, NULL, NULL) == 0);
tdb_close(tdb);
tdb = tdb_open_ex("test/old-nohash-be.tdb", 1024, 0, O_RDWR, 0,
&taplogctx, NULL);
ok1(tdb);
ok1(tdb_check(tdb, NULL, NULL) == 0);
tdb_close(tdb);
return exit_status();
}
smb_ucs2_t *strchr_w(const smb_ucs2_t *s, smb_ucs2_t c)
{
smb_ucs2_t cp;
while (*(COPY_UCS2_CHAR(&cp,s))) {
if (c == cp) {
return discard_const_p(smb_ucs2_t, s);
}
s++;
}
if (c == cp) {
return discard_const_p(smb_ucs2_t, s);
}
return NULL;
}
TDB_DATA make_tdb_data(const uint8_t *dptr, size_t dsize)
{
TDB_DATA ret;
ret.dptr = discard_const_p(uint8_t, dptr);
ret.dsize = dsize;
return ret;
}
/*
push a string in a uint16_t ofs/ uint16_t length/blob format
UTF-16 without termination
*/
NTSTATUS smb2_push_o16s16_string(struct smb2_request_buffer *buf,
uint16_t ofs, const char *str)
{
DATA_BLOB blob;
NTSTATUS status;
bool ret;
void *ptr = NULL;
if (str == NULL) {
return smb2_push_o16s16_blob(buf, ofs, data_blob(NULL, 0));
}
if (*str == 0) {
blob.data = discard_const_p(uint8_t, str);
blob.length = 0;
return smb2_push_o16s16_blob(buf, ofs, blob);
}
ret = convert_string_talloc(buf->buffer, CH_UNIX, CH_UTF16,
str, strlen(str), &ptr, &blob.length);
if (!ret) {
return NT_STATUS_ILLEGAL_CHARACTER;
}
blob.data = (uint8_t *)ptr;
status = smb2_push_o16s16_blob(buf, ofs, blob);
data_blob_free(&blob);
return status;
}
static int dump_tdb(const char *fname, const char *keyname, bool emergency)
{
TDB_CONTEXT *tdb;
TDB_DATA key, value;
struct tdb_logging_context logfn = { log_stderr };
tdb = tdb_open_ex(fname, 0, 0, O_RDONLY, 0, &logfn, NULL);
if (!tdb) {
printf("Failed to open %s\n", fname);
return 1;
}
if (emergency) {
return tdb_rescue(tdb, emergency_walk, keyname) == 0;
}
if (!keyname) {
return tdb_traverse(tdb, traverse_fn, NULL) == -1 ? 1 : 0;
} else {
key.dptr = discard_const_p(uint8_t, keyname);
key.dsize = strlen(keyname);
value = tdb_fetch(tdb, key);
if (!value.dptr) {
return 1;
} else {
print_data(value);
free(value.dptr);
}
}
return 0;
}
IXML_Element*
XMLUtil_FindFirstElement (const IXML_Node* const node,
const char* const tagname,
bool const deep, bool const log_error)
{
IXML_Element* res = NULL;
if (node == NULL || tagname == NULL) {
Log_Printf (LOG_ERROR,
"GetFirstElementByTagName invalid NULL parameter");
} else {
IXML_Node* const n = discard_const_p (IXML_Node, node);
if (ixmlNode_getNodeType (n) == eELEMENT_NODE) {
const char* const name = ixmlNode_getNodeName (n);
if (name && strcmp (tagname, name) == 0) {
res = (IXML_Element*) n;
}
}
if (res == NULL) {
res = findFirstElementRecursive (n, tagname, deep);
}
if (res == NULL) {
Log_Printf ((log_error ? LOG_ERROR : LOG_DEBUG),
"Can't find '%s' element in XML Node"
" (deep search=%d)", tagname, (int) deep);
}
}
return res;
}
void opt_test_copy_default(void **state)
{
int ret;
TALLOC_CTX *mem_ctx;
struct dp_option *opts;
struct dp_opt_blob b;
mem_ctx = talloc_new(global_talloc_context);
assert_non_null(mem_ctx);
ret = dp_copy_defaults(mem_ctx, test_def_opts, OPT_NUM_OPTS, &opts);
assert_int_equal(ret, EOK);
assert_defaults(opts);
/* Test that copy_defaults would still copy defaults even if we
* change the values
*/
ret = dp_opt_set_string(opts, OPT_STRING_NODEFAULT, "str1");
assert_int_equal(ret, EOK);
ret = dp_opt_set_string(opts, OPT_STRING_DEFAULT, "str2");
assert_int_equal(ret, EOK);
b.data = discard_const_p(uint8_t, "blob1");
b.length = strlen("blob1");
ret = dp_opt_set_blob(opts, OPT_BLOB_NODEFAULT, b);
assert_int_equal(ret, EOK);
ret = dp_opt_set_blob(opts, OPT_BLOB_DEFAULT, b);
b.data = discard_const_p(uint8_t, "blob2");
b.length = strlen("blob2");
assert_int_equal(ret, EOK);
ret = dp_opt_set_int(opts, OPT_INT_NODEFAULT, 456);
assert_int_equal(ret, EOK);
ret = dp_opt_set_int(opts, OPT_INT_DEFAULT, 789);
assert_int_equal(ret, EOK);
ret = dp_opt_set_bool(opts, OPT_BOOL_TRUE, false);
assert_int_equal(ret, EOK);
ret = dp_opt_set_bool(opts, OPT_BOOL_FALSE, true);
assert_int_equal(ret, EOK);
talloc_free(opts);
ret = dp_copy_defaults(mem_ctx, test_def_opts, OPT_NUM_OPTS, &opts);
assert_int_equal(ret, EOK);
assert_defaults(opts);
}
bool torture_samba3_oplock_logoff(struct torture_context *tctx, struct smbcli_state *cli)
{
union smb_open io;
const char *fname = "testfile";
bool ret = false;
struct smbcli_request *req;
struct smb_echo echo_req;
smbcli_unlink(cli->tree, fname);
ZERO_STRUCT(io);
io.generic.level = RAW_OPEN_NTCREATEX;
io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
io.ntcreatex.in.root_fid.fnum = 0;
io.ntcreatex.in.security_flags = 0;
io.ntcreatex.in.access_mask =
SEC_STD_SYNCHRONIZE | SEC_FILE_EXECUTE;
io.ntcreatex.in.alloc_size = 0;
io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
io.ntcreatex.in.create_options = 0;
io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
io.ntcreatex.in.fname = "testfile";
torture_assert_ntstatus_equal_goto(tctx, smb_raw_open(cli->tree, tctx, &io),
NT_STATUS_OK,
ret, done, "first smb_open on the file failed");
/*
* Create a conflicting open, causing the one-second delay
*/
torture_assert_goto(tctx, req = smb_raw_open_send(cli->tree, &io),
ret, done, "smb_raw_open_send on the file failed");
/*
* Pull the VUID from under that request. As of Nov 3, 2008 all Samba3
* versions (3.0, 3.2 and master) would spin sending ERRinvuid errors
* as long as the client is still connected.
*/
torture_assert_ntstatus_equal_goto(tctx, smb_raw_ulogoff(cli->session),
NT_STATUS_OK,
ret, done, "ulogoff failed failed");
echo_req.in.repeat_count = 1;
echo_req.in.size = 1;
echo_req.in.data = discard_const_p(uint8_t, "");
torture_assert_ntstatus_equal_goto(tctx, smb_raw_echo(cli->session->transport, &echo_req),
NT_STATUS_OK,
ret, done, "smb_raw_echo failed");
ret = true;
done:
return ret;
}
int main(int argc, char *argv[])
{
struct tdb_context *tdb;
TDB_DATA key, data;
plan_tests(13);
agent = prepare_external_agent();
tdb = tdb_open_ex("run-traverse-in-transaction.tdb",
1024, TDB_CLEAR_IF_FIRST, O_CREAT|O_TRUNC|O_RDWR,
0600, &taplogctx, NULL);
ok1(tdb);
key.dsize = strlen("hi");
key.dptr = discard_const_p(uint8_t, "hi");
data.dptr = discard_const_p(uint8_t, "world");
data.dsize = strlen("world");
ok1(tdb_store(tdb, key, data, TDB_INSERT) == 0);
ok1(external_agent_operation(agent, OPEN, tdb_name(tdb)) == SUCCESS);
ok1(tdb_transaction_start(tdb) == 0);
ok1(external_agent_operation(agent, TRANSACTION_START, tdb_name(tdb))
== WOULD_HAVE_BLOCKED);
tdb_traverse(tdb, traverse, NULL);
/* That should *not* release the transaction lock! */
ok1(external_agent_operation(agent, TRANSACTION_START, tdb_name(tdb))
== WOULD_HAVE_BLOCKED);
tdb_traverse_read(tdb, traverse, NULL);
/* That should *not* release the transaction lock! */
ok1(external_agent_operation(agent, TRANSACTION_START, tdb_name(tdb))
== WOULD_HAVE_BLOCKED);
ok1(tdb_transaction_commit(tdb) == 0);
/* Now we should be fine. */
ok1(external_agent_operation(agent, TRANSACTION_START, tdb_name(tdb))
== SUCCESS);
tdb_close(tdb);
return exit_status();
}
void opt_test_copy_options(void **state)
{
int ret;
TALLOC_CTX *mem_ctx;
struct dp_option *opts;
char *s;
struct dp_opt_blob b;
int i;
bool bo;
mem_ctx = talloc_new(global_talloc_context);
assert_non_null(mem_ctx);
ret = dp_copy_options(mem_ctx, test_def_opts, OPT_NUM_OPTS, &opts);
assert_int_equal(ret, EOK);
assert_int_equal(ret, EOK);
ret = dp_opt_set_string(opts, OPT_STRING_NODEFAULT, "str1");
assert_int_equal(ret, EOK);
b.data = discard_const_p(uint8_t, "blob1");
b.length = strlen("blob1");
ret = dp_opt_set_blob(opts, OPT_BLOB_NODEFAULT, b);
assert_int_equal(ret, EOK);
ret = dp_opt_set_int(opts, OPT_INT_NODEFAULT, 456);
assert_int_equal(ret, EOK);
ret = dp_opt_set_bool(opts, OPT_BOOL_TRUE, false);
assert_int_equal(ret, EOK);
/* Test that options set to an explicit value retain
* the value and even options with default value
* do not return the default unless explicitly set
*/
s = dp_opt_get_string(opts, OPT_STRING_NODEFAULT);
assert_string_equal(s, "str1");
s = dp_opt_get_string(opts, OPT_STRING_DEFAULT);
assert_null(s);
b = dp_opt_get_blob(opts, OPT_BLOB_NODEFAULT);
assert_non_null(b.data);
assert_int_equal(b.length, strlen("blob1"));
assert_memory_equal(b.data, "blob1", strlen("blob1"));
b = dp_opt_get_blob(opts, OPT_BLOB_DEFAULT);
assert_null(b.data);
assert_int_equal(b.length, 0);
i = dp_opt_get_int(opts, OPT_INT_NODEFAULT);
assert_int_equal(i, 456);
i = dp_opt_get_int(opts, OPT_INT_DEFAULT);
assert_int_equal(i, 0);
bo = dp_opt_get_bool(opts, OPT_BOOL_TRUE);
assert_false(bo == true);
}
static void set_nondefault_blob(struct dp_option *opts)
{
struct dp_opt_blob b;
int ret;
b.data = discard_const_p(uint8_t, "blob2");
b.length = strlen("blob2");
ret = dp_opt_set_blob(opts, OPT_BLOB_NODEFAULT, b);
assert_int_equal(ret, EOK);
}
int main(int argc, char *argv[])
{
const int flags[] = { TDB_DEFAULT,
TDB_CLEAR_IF_FIRST,
TDB_NOMMAP,
TDB_CLEAR_IF_FIRST | TDB_NOMMAP };
int i;
struct tdb_context *tdb;
TDB_DATA key, data;
plan_tests(20);
agent = prepare_external_agent();
unlock_callback = after_unlock;
for (i = 0; i < sizeof(flags)/sizeof(flags[0]); i++) {
clear_if_first = (flags[i] & TDB_CLEAR_IF_FIRST);
diag("Test with %s and %s",
clear_if_first ? "CLEAR" : "DEFAULT",
(flags[i] & TDB_NOMMAP) ? "no mmap" : "mmap");
unlink(TEST_DBNAME);
tdb = tdb_open_ex(TEST_DBNAME, 1024, flags[i],
O_CREAT|O_TRUNC|O_RDWR, 0600,
&taplogctx, NULL);
ok1(tdb);
opened = true;
ok1(tdb_transaction_start(tdb) == 0);
key.dsize = strlen("hi");
key.dptr = discard_const_p(uint8_t, "hi");
data.dptr = discard_const_p(uint8_t, "world");
data.dsize = strlen("world");
ok1(tdb_store(tdb, key, data, TDB_INSERT) == 0);
ok1(tdb_transaction_commit(tdb) == 0);
ok(!errors, "We had %u open errors", errors);
opened = false;
tdb_close(tdb);
}
return exit_status();
}
/*
check the signature on a packet
*/
static NTSTATUS schannel_check_packet(struct gensec_security *gensec_security,
const uint8_t *data, size_t length,
const uint8_t *whole_pdu, size_t pdu_length,
const DATA_BLOB *sig)
{
struct schannel_state *state =
talloc_get_type(gensec_security->private_data,
struct schannel_state);
return netsec_incoming_packet(state, false,
discard_const_p(uint8_t, data),
length, sig);
}
/*
sign a packet
*/
static NTSTATUS schannel_sign_packet(struct gensec_security *gensec_security,
TALLOC_CTX *mem_ctx,
const uint8_t *data, size_t length,
const uint8_t *whole_pdu, size_t pdu_length,
DATA_BLOB *sig)
{
struct schannel_state *state =
talloc_get_type(gensec_security->private_data,
struct schannel_state);
return netsec_outgoing_packet(state, mem_ctx, false,
discard_const_p(uint8_t, data),
length, sig);
}
/*
add a string element to a message
*/
int ldb_msg_add_string(struct ldb_message *msg,
const char *attr_name, const char *str)
{
struct ldb_val val;
val.data = discard_const_p(uint8_t, str);
val.length = strlen(str);
if (val.length == 0) {
/* allow empty strings as non-existent attributes */
return LDB_SUCCESS;
}
return ldb_msg_add_value(msg, attr_name, &val, NULL);
}
const char*
XMLUtil_GetElementValue (IN const IXML_Element* element)
{
char* res = NULL;
IXML_Node* child = ixmlNode_getFirstChild
(discard_const_p (IXML_Node, XML_E2N (element)));
while (child && !res) {
if (ixmlNode_getNodeType (child) == eTEXT_NODE) {
// The resulting string should be copied if necessary
res = ixmlNode_getNodeValue (child);
}
child = ixmlNode_getNextSibling (child);
}
return res;
}
static void reply_lockingX_error(struct blocking_lock_record *blr, NTSTATUS status)
{
files_struct *fsp = blr->fsp;
uint16 num_ulocks = SVAL(blr->req->vwv+6, 0);
uint64_t count = (uint64_t)0, offset = (uint64_t) 0;
uint64_t smblctx;
unsigned char locktype = CVAL(blr->req->vwv+3, 0);
bool large_file_format = (locktype & LOCKING_ANDX_LARGE_FILES);
uint8_t *data;
int i;
data = discard_const_p(uint8_t, blr->req->buf)
+ ((large_file_format ? 20 : 10)*num_ulocks);
/*
* Data now points at the beginning of the list
* of smb_lkrng structs.
*/
/*
* Ensure we don't do a remove on the lock that just failed,
* as under POSIX rules, if we have a lock already there, we
* will delete it (and we shouldn't) .....
*/
for(i = blr->lock_num - 1; i >= 0; i--) {
bool err;
smblctx = get_lock_pid( data, i, large_file_format);
count = get_lock_count( data, i, large_file_format);
offset = get_lock_offset( data, i, large_file_format, &err);
/*
* We know err cannot be set as if it was the lock
* request would never have been queued. JRA.
*/
do_unlock(fsp->conn->sconn->msg_ctx,
fsp,
smblctx,
count,
offset,
WINDOWS_LOCK);
}
generic_blocking_lock_error(blr, status);
}
/******************************************************************************
* XMLUtil_GetNodeString
*****************************************************************************/
char*
XMLUtil_GetNodeString (void* context, const IXML_Node* node)
{
char* ret = NULL;
if (node) {
DOMString s = ixmlPrintNode (discard_const_p (IXML_Node,node));
if (s) {
ret = talloc_strdup (context, s);
ixmlFreeDOMString (s);
} else {
ret = talloc_strdup (context, "(error)");
}
} else {
ret = talloc_strdup (context, "(null)");
}
return ret;
}
smb_ucs2_t *strrchr_w(const smb_ucs2_t *s, smb_ucs2_t c)
{
smb_ucs2_t cp;
const smb_ucs2_t *p = s;
int len = strlen_w(s);
if (len == 0) {
return NULL;
}
p += (len - 1);
do {
if (c == *(COPY_UCS2_CHAR(&cp,p))) {
return discard_const_p(smb_ucs2_t, p);
}
} while (p-- != s);
return NULL;
}
smb_ucs2_t *strstr_w(const smb_ucs2_t *s, const smb_ucs2_t *ins)
{
const smb_ucs2_t *r;
size_t inslen;
if (!s || !*s || !ins || !*ins) {
return NULL;
}
inslen = strlen_w(ins);
r = s;
while ((r = strchr_w(r, *ins))) {
if (strncmp_w(r, ins, inslen) == 0) {
return discard_const_p(smb_ucs2_t, r);
}
r++;
}
return NULL;
}
static IXML_Element*
findFirstElementRecursive (const IXML_Node* const node,
const char* const tagname,
bool const deep)
{
IXML_Element* res = NULL;
IXML_Node* n = ixmlNode_getFirstChild (discard_const_p (IXML_Node,
node));
while (n && !res) {
if (ixmlNode_getNodeType (n) == eELEMENT_NODE) {
const char* const name = ixmlNode_getNodeName (n);
if (name && strcmp (tagname, name) == 0) {
res = (IXML_Element*) n;
}
}
if (deep && !res) {
res = findFirstElementRecursive (n, tagname, deep);
}
n = ixmlNode_getNextSibling (n);
}
return res;
}
static NTSTATUS gensec_gssapi_client_start(struct gensec_security *gensec_security)
{
struct gensec_gssapi_state *gensec_gssapi_state;
struct cli_credentials *creds = gensec_get_credentials(gensec_security);
NTSTATUS nt_status;
gss_buffer_desc name_token;
gss_OID name_type;
OM_uint32 maj_stat, min_stat;
const char *hostname = gensec_get_target_hostname(gensec_security);
if (!hostname) {
DEBUG(3, ("No hostname for target computer passed in, cannot use kerberos for this connection\n"));
return NT_STATUS_INVALID_PARAMETER;
}
if (is_ipaddress(hostname)) {
DEBUG(2, ("Cannot do GSSAPI to an IP address\n"));
return NT_STATUS_INVALID_PARAMETER;
}
if (strcmp(hostname, "localhost") == 0) {
DEBUG(2, ("GSSAPI to 'localhost' does not make sense\n"));
return NT_STATUS_INVALID_PARAMETER;
}
nt_status = gensec_gssapi_start(gensec_security);
if (!NT_STATUS_IS_OK(nt_status)) {
return nt_status;
}
gensec_gssapi_state = talloc_get_type(gensec_security->private_data, struct gensec_gssapi_state);
if (cli_credentials_get_impersonate_principal(creds)) {
gensec_gssapi_state->gss_want_flags &= ~(GSS_C_DELEG_FLAG|GSS_C_DELEG_POLICY_FLAG);
}
gensec_gssapi_state->target_principal = gensec_get_target_principal(gensec_security);
if (gensec_gssapi_state->target_principal) {
name_type = GSS_C_NULL_OID;
} else {
gensec_gssapi_state->target_principal = talloc_asprintf(gensec_gssapi_state, "%s/%s@%s",
gensec_get_target_service(gensec_security),
hostname, cli_credentials_get_realm(creds));
name_type = GSS_C_NT_USER_NAME;
}
name_token.value = discard_const_p(uint8_t, gensec_gssapi_state->target_principal);
name_token.length = strlen(gensec_gssapi_state->target_principal);
maj_stat = gss_import_name (&min_stat,
&name_token,
name_type,
&gensec_gssapi_state->server_name);
if (maj_stat) {
DEBUG(2, ("GSS Import name of %s failed: %s\n",
(char *)name_token.value,
gssapi_error_string(gensec_gssapi_state, maj_stat, min_stat, gensec_gssapi_state->gss_oid)));
return NT_STATUS_INVALID_PARAMETER;
}
return NT_STATUS_OK;
}
static void speed_tdb(const char *tlimit)
{
const char *str = "store test", *str2 = "transaction test";
unsigned timelimit = tlimit?atoi(tlimit):0;
double t;
int ops;
if (timelimit == 0) timelimit = 5;
ops = 0;
printf("Testing store speed for %u seconds\n", timelimit);
_start_timer();
do {
long int r = random();
TDB_DATA key, dbuf;
key.dptr = discard_const_p(uint8_t, str);
key.dsize = strlen((char *)key.dptr);
dbuf.dptr = (uint8_t *) &r;
dbuf.dsize = sizeof(r);
tdb_store(tdb, key, dbuf, TDB_REPLACE);
t = _end_timer();
ops++;
} while (t < timelimit);
printf("%10.3f ops/sec\n", ops/t);
ops = 0;
printf("Testing fetch speed for %u seconds\n", timelimit);
_start_timer();
do {
TDB_DATA key;
key.dptr = discard_const_p(uint8_t, str);
key.dsize = strlen((char *)key.dptr);
tdb_fetch(tdb, key);
t = _end_timer();
ops++;
} while (t < timelimit);
printf("%10.3f ops/sec\n", ops/t);
ops = 0;
printf("Testing transaction speed for %u seconds\n", timelimit);
_start_timer();
do {
long int r = random();
TDB_DATA key, dbuf;
key.dptr = discard_const_p(uint8_t, str2);
key.dsize = strlen((char *)key.dptr);
dbuf.dptr = (uint8_t *) &r;
dbuf.dsize = sizeof(r);
tdb_transaction_start(tdb);
tdb_store(tdb, key, dbuf, TDB_REPLACE);
tdb_transaction_commit(tdb);
t = _end_timer();
ops++;
} while (t < timelimit);
printf("%10.3f ops/sec\n", ops/t);
ops = 0;
printf("Testing traverse speed for %u seconds\n", timelimit);
_start_timer();
do {
tdb_traverse(tdb, traverse_fn, NULL);
t = _end_timer();
ops++;
} while (t < timelimit);
printf("%10.3f ops/sec\n", ops/t);
}
static bool test_wbc_logon_user(struct torture_context *tctx)
{
struct wbcLogonUserParams params;
struct wbcLogonUserInfo *info = NULL;
struct wbcAuthErrorInfo *error = NULL;
struct wbcUserPasswordPolicyInfo *policy = NULL;
struct wbcInterfaceDetails *iface;
struct wbcDomainSid sid;
enum wbcSidType sidtype;
char *sidstr;
wbcErr ret;
ZERO_STRUCT(params);
ret = wbcLogonUser(¶ms, &info, &error, &policy);
torture_assert_wbc_equal(tctx, ret, WBC_ERR_INVALID_PARAM,
"wbcLogonUser succeeded where it should "
"have failed");
params.username = getenv("USERNAME");
params.password = getenv("PASSWORD");
ret = wbcAddNamedBlob(¶ms.num_blobs, ¶ms.blobs,
"foo", 0, discard_const_p(uint8_t, "bar"), 4);
torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
"wbcAddNamedBlob failed");
ret = wbcLogonUser(¶ms, &info, &error, &policy);
torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
"wbcLogonUser failed");
wbcFreeMemory(info); info = NULL;
wbcFreeMemory(error); error = NULL;
wbcFreeMemory(policy); policy = NULL;
params.password = "******";
ret = wbcLogonUser(¶ms, &info, &error, &policy);
torture_assert_wbc_equal(tctx, ret, WBC_ERR_AUTH_ERROR,
"wbcLogonUser should have failed with "
"WBC_ERR_AUTH_ERROR");
wbcFreeMemory(info); info = NULL;
wbcFreeMemory(error); error = NULL;
wbcFreeMemory(policy); policy = NULL;
ret = wbcAddNamedBlob(¶ms.num_blobs, ¶ms.blobs,
"membership_of", 0,
discard_const_p(uint8_t, "S-1-2-3-4"),
strlen("S-1-2-3-4")+1);
torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
"wbcAddNamedBlob failed");
params.password = getenv("PASSWORD");
ret = wbcLogonUser(¶ms, &info, &error, &policy);
torture_assert_wbc_equal(tctx, ret, WBC_ERR_AUTH_ERROR,
"wbcLogonUser should have failed with "
"WBC_ERR_AUTH_ERROR");
wbcFreeMemory(info); info = NULL;
wbcFreeMemory(error); error = NULL;
wbcFreeMemory(policy); policy = NULL;
wbcFreeMemory(params.blobs);
params.blobs = NULL; params.num_blobs = 0;
ret = wbcInterfaceDetails(&iface);
torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
"wbcInterfaceDetails failed");
ret = wbcLookupName(iface->netbios_domain, getenv("USERNAME"), &sid,
&sidtype);
wbcFreeMemory(iface);
torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
"wbcLookupName failed");
ret = wbcSidToString(&sid, &sidstr);
torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
"wbcSidToString failed");
ret = wbcAddNamedBlob(¶ms.num_blobs, ¶ms.blobs,
"membership_of", 0,
(uint8_t *)sidstr, strlen(sidstr)+1);
torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
"wbcAddNamedBlob failed");
wbcFreeMemory(sidstr);
params.password = getenv("PASSWORD");
ret = wbcLogonUser(¶ms, &info, &error, &policy);
torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
"wbcLogonUser failed");
wbcFreeMemory(info); info = NULL;
wbcFreeMemory(error); error = NULL;
wbcFreeMemory(policy); policy = NULL;
wbcFreeMemory(params.blobs);
params.blobs = NULL; params.num_blobs = 0;
return true;
}
bool run_local_conv_auth_info(int dummy)
{
struct lsa_TrustDomainInfoAuthInfo auth_info;
struct lsa_TrustDomainInfoBuffer ic[1];
struct lsa_TrustDomainInfoBuffer ip[1];
struct lsa_TrustDomainInfoBuffer oc[2];
struct lsa_TrustDomainInfoBuffer op[2];
uint32_t version = 3;
ic[0].last_update_time = 12345;
ic[0].AuthType = TRUST_AUTH_TYPE_CLEAR;
ic[0].data.size = strlen("iPaSsWoRd");
ic[0].data.data = discard_const_p(uint8_t, "iPaSsWoRd");
ip[0].last_update_time = 67890;
ip[0].AuthType = TRUST_AUTH_TYPE_CLEAR;
ip[0].data.size = strlen("OlDiPaSsWoRd");
ip[0].data.data = discard_const_p(uint8_t, "OlDiPaSsWoRd");
oc[0].last_update_time = 24580;
oc[0].AuthType = TRUST_AUTH_TYPE_CLEAR;
oc[0].data.size = strlen("oPaSsWoRd");
oc[0].data.data = discard_const_p(uint8_t, "oPaSsWoRd");
oc[1].last_update_time = 24580;
oc[1].AuthType = TRUST_AUTH_TYPE_VERSION;
oc[1].data.size = 4;
oc[1].data.data = (uint8_t *) &version;
op[0].last_update_time = 13579;
op[0].AuthType = TRUST_AUTH_TYPE_CLEAR;
op[0].data.size = strlen("OlDoPaSsWoRd");
op[0].data.data = discard_const_p(uint8_t, "OlDoPaSsWoRd");
op[1].last_update_time = 24580;
op[1].AuthType = TRUST_AUTH_TYPE_VERSION;
op[1].data.size = 4;
op[1].data.data = (uint8_t *) &version;
auth_info.incoming_count = 0;
auth_info.incoming_current_auth_info = NULL;
auth_info.incoming_previous_auth_info = NULL;
auth_info.outgoing_count = 0;
auth_info.outgoing_current_auth_info = NULL;
auth_info.outgoing_previous_auth_info = NULL;
if (!covert_and_compare(&auth_info)) {
return false;
}
auth_info.incoming_count = 1;
auth_info.incoming_current_auth_info = ic;
auth_info.incoming_previous_auth_info = NULL;
auth_info.outgoing_count = 0;
auth_info.outgoing_current_auth_info = NULL;
auth_info.outgoing_previous_auth_info = NULL;
if (!covert_and_compare(&auth_info)) {
return false;
}
auth_info.incoming_count = 0;
auth_info.incoming_current_auth_info = NULL;
auth_info.incoming_previous_auth_info = NULL;
auth_info.outgoing_count = 2;
auth_info.outgoing_current_auth_info = oc;
auth_info.outgoing_previous_auth_info = NULL;
if (!covert_and_compare(&auth_info)) {
return false;
}
auth_info.incoming_count = 1;
auth_info.incoming_current_auth_info = ic;
auth_info.incoming_previous_auth_info = NULL;
auth_info.outgoing_count = 2;
auth_info.outgoing_current_auth_info = oc;
auth_info.outgoing_previous_auth_info = NULL;
if (!covert_and_compare(&auth_info)) {
return false;
}
auth_info.incoming_count = 1;
auth_info.incoming_current_auth_info = ic;
auth_info.incoming_previous_auth_info = ip;
auth_info.outgoing_count = 2;
auth_info.outgoing_current_auth_info = oc;
auth_info.outgoing_previous_auth_info = op;
if (!covert_and_compare(&auth_info)) {
return false;
}
return true;
}
static bool test_one(struct cli_state *cli, const char *name)
{
uint16_t fnum;
fstring shortname;
fstring name2;
NTSTATUS status;
TDB_DATA data;
total++;
status = cli_openx(cli, name, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
if (!NT_STATUS_IS_OK(status)) {
printf("open of %s failed (%s)\n", name, nt_errstr(status));
return False;
}
status = cli_close(cli, fnum);
if (!NT_STATUS_IS_OK(status)) {
printf("close of %s failed (%s)\n", name, nt_errstr(status));
return False;
}
/* get the short name */
status = cli_qpathinfo_alt_name(cli, name, shortname);
if (!NT_STATUS_IS_OK(status)) {
printf("query altname of %s failed (%s)\n", name, nt_errstr(status));
return False;
}
fstr_sprintf(name2, "\\mangle_test\\%s", shortname);
status = cli_unlink(cli, name2, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
if (!NT_STATUS_IS_OK(status)) {
printf("unlink of %s (%s) failed (%s)\n",
name2, name, nt_errstr(status));
return False;
}
/* recreate by short name */
status = cli_openx(cli, name2, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
if (!NT_STATUS_IS_OK(status)) {
printf("open2 of %s failed (%s)\n", name2, nt_errstr(status));
return False;
}
status = cli_close(cli, fnum);
if (!NT_STATUS_IS_OK(status)) {
printf("close of %s failed (%s)\n", name, nt_errstr(status));
return False;
}
/* and unlink by long name */
status = cli_unlink(cli, name, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
if (!NT_STATUS_IS_OK(status)) {
printf("unlink2 of %s (%s) failed (%s)\n",
name, name2, nt_errstr(status));
failures++;
cli_unlink(cli, name2, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
return True;
}
/* see if the short name is already in the tdb */
data = tdb_fetch_bystring(tdb, shortname);
if (data.dptr) {
/* maybe its a duplicate long name? */
if (!strequal(name, (const char *)data.dptr)) {
/* we have a collision */
collisions++;
printf("Collision between %s and %s -> %s "
" (coll/tot: %u/%u)\n",
name, data.dptr, shortname, collisions, total);
}
free(data.dptr);
} else {
TDB_DATA namedata;
/* store it for later */
namedata.dptr = discard_const_p(uint8_t, name);
namedata.dsize = strlen(name)+1;
tdb_store_bystring(tdb, shortname, namedata, TDB_REPLACE);
}
return True;
}
static bool process_lockingX(struct blocking_lock_record *blr)
{
unsigned char locktype = CVAL(blr->req->vwv+3, 0);
files_struct *fsp = blr->fsp;
uint16 num_ulocks = SVAL(blr->req->vwv+6, 0);
uint16 num_locks = SVAL(blr->req->vwv+7, 0);
uint64_t count = (uint64_t)0, offset = (uint64_t)0;
uint64_t smblctx;
bool large_file_format = (locktype & LOCKING_ANDX_LARGE_FILES);
uint8_t *data;
NTSTATUS status = NT_STATUS_OK;
data = discard_const_p(uint8_t, blr->req->buf)
+ ((large_file_format ? 20 : 10)*num_ulocks);
/*
* Data now points at the beginning of the list
* of smb_lkrng structs.
*/
for(; blr->lock_num < num_locks; blr->lock_num++) {
struct byte_range_lock *br_lck = NULL;
bool err;
smblctx = get_lock_pid( data, blr->lock_num, large_file_format);
count = get_lock_count( data, blr->lock_num, large_file_format);
offset = get_lock_offset( data, blr->lock_num, large_file_format, &err);
/*
* We know err cannot be set as if it was the lock
* request would never have been queued. JRA.
*/
errno = 0;
br_lck = do_lock(fsp->conn->sconn->msg_ctx,
fsp,
smblctx,
count,
offset,
((locktype & LOCKING_ANDX_SHARED_LOCK) ?
READ_LOCK : WRITE_LOCK),
WINDOWS_LOCK,
True,
&status,
&blr->blocking_smblctx,
blr);
TALLOC_FREE(br_lck);
if (NT_STATUS_IS_ERR(status)) {
break;
}
}
if(blr->lock_num == num_locks) {
/*
* Success - we got all the locks.
*/
DEBUG(3,("process_lockingX file = %s, %s, type=%d "
"num_locks=%d\n", fsp_str_dbg(fsp), fsp_fnum_dbg(fsp),
(unsigned int)locktype, num_locks));
reply_lockingX_success(blr);
return True;
}
if (!NT_STATUS_EQUAL(status,NT_STATUS_LOCK_NOT_GRANTED) &&
!NT_STATUS_EQUAL(status,NT_STATUS_FILE_LOCK_CONFLICT)) {
/*
* We have other than a "can't get lock"
* error. Free any locks we had and return an error.
* Return True so we get dequeued.
*/
blocking_lock_reply_error(blr, status);
return True;
}
/*
* Still can't get all the locks - keep waiting.
*/
DEBUG(10, ("process_lockingX: only got %d locks of %d needed for "
"file %s, %s. Waiting....\n",
blr->lock_num, num_locks, fsp_str_dbg(fsp),
fsp_fnum_dbg(fsp)));
return False;
}