static void wait_replies(struct tevent_context *ev_ctx,
struct messaging_context *msg_ctx,
bool multiple_replies)
{
struct tevent_timer *te;
bool timed_out = False;
te = tevent_add_timer(ev_ctx, NULL,
timeval_current_ofs(timeout, 0),
smbcontrol_timeout, (void *)&timed_out);
if (te == NULL) {
DEBUG(0, ("tevent_add_timer failed\n"));
return;
}
while (!timed_out) {
int ret;
if (num_replies > 0 && !multiple_replies)
break;
ret = tevent_loop_once(ev_ctx);
if (ret != 0) {
break;
}
}
}
static void
mock_server_child(void *data)
{
struct mock_server *mock = data;
struct tevent_context *loop;
struct sbus_connection *server;
bool stop_server = false;
TALLOC_CTX *ctx;
ctx = talloc_new(NULL);
loop = tevent_context_init(ctx);
verify_eq (sbus_new_server(ctx, loop, mock->dbus_address, false,
&server, on_accept_connection, mock), EOK);
tevent_add_fd(loop, ctx, mock->sync_fds[1], TEVENT_FD_READ,
on_sync_fd_written, &stop_server);
/* Synchronization point: test_dbus_setup_mock() should connect */
verify_eq (write(mock->sync_fds[1], "X", 1), 1);
/* Do the loop */
while(!stop_server) {
verify_eq (tevent_loop_once(loop), 0);
}
/* TODO: sbus doesn't support cleanup of a server */
talloc_free(ctx);
}
static int smbd_scavenger_main(struct smbd_scavenger_state *state)
{
DEBUG(10, ("scavenger: %s started, parent: %s\n",
server_id_str(talloc_tos(), state->scavenger_id),
server_id_str(talloc_tos(), &state->parent_id)));
while (true) {
TALLOC_CTX *frame = talloc_stackframe();
int ret;
ret = tevent_loop_once(state->ev);
if (ret != 0) {
DEBUG(2, ("tevent_loop_once failed: %s\n",
strerror(errno)));
TALLOC_FREE(frame);
return 1;
}
DEBUG(10, ("scavenger: %s event loop iteration\n",
server_id_str(talloc_tos(), state->scavenger_id)));
TALLOC_FREE(frame);
}
return 0;
}
static int test_loop(struct simple_test_ctx *tctx)
{
while (!tctx->done)
tevent_loop_once(tctx->ev);
return tctx->error;
}
static PyObject *py_tevent_context_loop_once(TeventContext_Object *self)
{
if (tevent_loop_once(self->ev) != 0) {
PyErr_SetNone(PyExc_RuntimeError);
return NULL;
}
Py_RETURN_NONE;
}
void dyndns_test_timeout(void **state)
{
struct tevent_req *req;
errno_t ret;
TALLOC_CTX *tmp_ctx;
tmp_ctx = talloc_new(global_talloc_context);
assert_non_null(tmp_ctx);
check_leaks_push(tmp_ctx);
dyndns_test_ctx->state = MOCK_NSUPDATE_TIMEOUT;
req = be_nsupdate_send(tmp_ctx, dyndns_test_ctx->tctx->ev,
BE_NSUPDATE_AUTH_GSS_TSIG,
discard_const("test message"), false);
assert_non_null(req);
tevent_req_set_callback(req, dyndns_test_done, dyndns_test_ctx);
/* Wait until the test finishes with EIO (child error) */
ret = test_ev_loop(dyndns_test_ctx->tctx);
/* The event queue may not be empty. We need to make sure that all events
* are processed. Unfortunately, tevent_loop_wait() contains a bug that
* prevents exiting the loop even if there are no remaining events, thus
* we have to use tevent_loop_once().
*
* FIXME: use tevent_loop_wait() when the bug is fixed
* https://bugzilla.samba.org/show_bug.cgi?id=10012
*/
tevent_loop_once(dyndns_test_ctx->tctx->ev); /* SIGCHLD handler */
tevent_loop_once(dyndns_test_ctx->tctx->ev); /* nsupdate_child_handler */
DEBUG(SSSDBG_TRACE_LIBS,
"Child request returned [%d]: %s\n", ret, strerror(ret));
assert_int_equal(ret, ERR_DYNDNS_TIMEOUT);
assert_true(check_leaks_pop(tmp_ctx) == true);
talloc_free(tmp_ctx);
}
/*
block until a composite function has completed, then return the status
*/
_PUBLIC_ NTSTATUS composite_wait(struct composite_context *c)
{
if (c == NULL) return NT_STATUS_NO_MEMORY;
c->used_wait = true;
while (c->state < COMPOSITE_STATE_DONE) {
if (tevent_loop_once(c->event_ctx) != 0) {
return NT_STATUS_UNSUCCESSFUL;
}
}
return c->status;
}
/**
* @brief This function destroys the attached private data
* @param[in] req The request to poll
* @param[in] ev The tevent_context to be used
* @retval If a critical error has happened in the
* tevent loop layer false is returned.
* Otherwise true is returned.
* This is not the return value of the given request!
*
* This function can be used to actively poll for the
* given request to finish.
*
* Note: this should only be used if the given tevent context
* was created by the caller, to avoid event loop nesting.
*
* This function is typically used by sync wrapper functions.
*/
bool tevent_req_poll(struct tevent_req *req,
struct tevent_context *ev)
{
while (tevent_req_is_in_progress(req)) {
int ret;
ret = tevent_loop_once(ev);
if (ret != 0) {
return false;
}
}
return true;
}
/*
receive a response to a packet
*/
bool smb2_request_receive(struct smb2_request *req)
{
/* req can be NULL when a send has failed. This eliminates lots of NULL
checks in each module */
if (!req) return false;
/* keep receiving packets until this one is replied to */
while (req->state <= SMB2_REQUEST_RECV) {
if (tevent_loop_once(req->transport->ev) != 0) {
return false;
}
}
return req->state == SMB2_REQUEST_DONE;
}
static int db_freeze_block(struct ctdb_db_context *ctdb_db, void *private_data)
{
struct tevent_context *ev = (struct tevent_context *)private_data;
ctdb_start_db_freeze(ctdb_db);
while (ctdb_db->freeze_mode == CTDB_FREEZE_PENDING) {
tevent_loop_once(ev);
}
if (ctdb_db->freeze_mode != CTDB_FREEZE_FROZEN) {
return -1;
}
return 0;
}
static void *py_cli_state_poll_thread(void *private_data)
{
struct py_cli_state *self = (struct py_cli_state *)private_data;
struct py_cli_thread *t = self->thread_state;
PyGILState_STATE gstate;
gstate = PyGILState_Ensure();
while (!t->do_shutdown) {
int ret;
ret = tevent_loop_once(self->ev);
assert(ret == 0);
}
PyGILState_Release(gstate);
return NULL;
}
static void *test_event_poll_thread(void *private_data)
{
struct tevent_context *ev = (struct tevent_context *)private_data;
test_event_threaded_lock();
while (true) {
int ret;
ret = tevent_loop_once(ev);
assert(ret == 0);
if (do_shutdown) {
test_event_threaded_unlock();
return NULL;
}
}
}
static void smbd_parent_loop(struct tevent_context *ev_ctx,
struct smbd_parent_context *parent)
{
/* now accept incoming connections - forking a new process
for each incoming connection */
DEBUG(2,("waiting for connections\n"));
while (1) {
int ret;
TALLOC_CTX *frame = talloc_stackframe();
ret = tevent_loop_once(ev_ctx);
if (ret != 0) {
exit_server_cleanly("tevent_loop_once() error");
}
TALLOC_FREE(frame);
} /* end while 1 */
/* NOTREACHED return True; */
}
/*
Wait a short period of time to receive a single oplock break request
*/
static void torture_wait_for_lease_break(struct torture_context *tctx)
{
TALLOC_CTX *tmp_ctx = talloc_new(NULL);
struct tevent_timer *te = NULL;
struct timeval ne;
bool timesup = false;
int old_count = break_info.count;
/* Wait .1 seconds for an lease break */
ne = tevent_timeval_current_ofs(0, 100000);
te = tevent_add_timer(tctx->ev, tmp_ctx, ne, timeout_cb, ×up);
if (te == NULL) {
torture_comment(tctx, "Failed to wait for an oplock break. "
"test results may not be accurate.");
goto done;
}
while (!timesup && break_info.count < old_count + 1) {
if (tevent_loop_once(tctx->ev) != 0) {
torture_comment(tctx, "Failed to wait for an oplock "
"break. test results may not be "
"accurate.");
goto done;
}
}
done:
/* We don't know if the timed event fired and was freed, we received
* our oplock break, or some other event triggered the loop. Thus,
* we create a tmp_ctx to be able to safely free/remove the timed
* event in all 3 cases. */
talloc_free(tmp_ctx);
return;
}
int main(int argc, char *argv[])
{
struct tevent_context *evt_ctx;
struct messaging_context *msg_ctx;
pid_t pid;
int i, n;
char buf[12];
int ret;
load_case_tables();
setup_logging(argv[0], DEBUG_STDOUT);
lp_load(get_dyn_CONFIGFILE(),False,False,False,True);
if (!(evt_ctx = tevent_context_init(NULL)) ||
!(msg_ctx = messaging_init(NULL, procid_self(), evt_ctx))) {
fprintf(stderr, "could not init messaging context\n");
exit(1);
}
if (argc != 3) {
fprintf(stderr, "%s: Usage - %s pid count\n", argv[0],
argv[0]);
exit(1);
}
pid = atoi(argv[1]);
n = atoi(argv[2]);
messaging_register(msg_ctx, NULL, MSG_PONG, pong_message);
for (i=0;i<n;i++) {
messaging_send(msg_ctx, pid_to_procid(pid), MSG_PING,
&data_blob_null);
}
while (pong_count < i) {
ret = tevent_loop_once(evt_ctx);
if (ret != 0) {
break;
}
}
/* Now test that the duplicate filtering code works. */
pong_count = 0;
strlcpy(buf, "1234567890", sizeof(buf));
for (i=0;i<n;i++) {
messaging_send(msg_ctx, messaging_server_id(msg_ctx), MSG_PING,
&data_blob_null);
messaging_send_buf(msg_ctx, messaging_server_id(msg_ctx),
MSG_PING,(uint8 *)buf, 11);
}
for (i=0;i<n;i++) {
ret = tevent_loop_once(evt_ctx);
if (ret != 0) {
break;
}
}
if (pong_count != 2) {
fprintf(stderr, "Duplicate filter failed (%d).\n", pong_count);
}
/* Speed testing */
pong_count = 0;
{
struct timeval tv = timeval_current();
size_t timelimit = n;
size_t ping_count = 0;
printf("Sending pings for %d seconds\n", (int)timelimit);
while (timeval_elapsed(&tv) < timelimit) {
if(NT_STATUS_IS_OK(messaging_send_buf(
msg_ctx, pid_to_procid(pid),
MSG_PING,
(uint8 *)buf, 11)))
ping_count++;
if(NT_STATUS_IS_OK(messaging_send(
msg_ctx, pid_to_procid(pid),
MSG_PING, &data_blob_null)))
ping_count++;
while (ping_count > pong_count + 20) {
ret = tevent_loop_once(evt_ctx);
if (ret != 0) {
break;
}
}
}
printf("waiting for %d remaining replies (done %d)\n",
(int)(ping_count - pong_count), pong_count);
while (timeval_elapsed(&tv) < 30 && pong_count < ping_count) {
ret = tevent_loop_once(evt_ctx);
if (ret != 0) {
break;
}
}
if (ping_count != pong_count) {
fprintf(stderr, "ping test failed! received %d, sent "
"%d\n", pong_count, (int)ping_count);
}
printf("ping rate of %.0f messages/sec\n",
(ping_count+pong_count)/timeval_elapsed(&tv));
}
return (0);
}
int main(int argc, char *argv[])
{
struct tevent_context *evt_ctx;
struct messaging_context *msg_ctx;
pid_t pid;
int i, n;
char buf[12];
int ret;
TALLOC_CTX *frame = talloc_stackframe();
load_case_tables();
setup_logging(argv[0], DEBUG_STDOUT);
lp_load_global(get_dyn_CONFIGFILE());
if (!(evt_ctx = samba_tevent_context_init(NULL)) ||
!(msg_ctx = messaging_init(NULL, evt_ctx))) {
fprintf(stderr, "could not init messaging context\n");
TALLOC_FREE(frame);
exit(1);
}
if (argc != 3) {
fprintf(stderr, "%s: Usage - %s pid count\n", argv[0],
argv[0]);
TALLOC_FREE(frame);
exit(1);
}
pid = atoi(argv[1]);
n = atoi(argv[2]);
messaging_register(msg_ctx, NULL, MSG_PONG, pong_message);
for (i=0;i<n;i++) {
messaging_send(msg_ctx, pid_to_procid(pid), MSG_PING,
&data_blob_null);
}
while (pong_count < i) {
ret = tevent_loop_once(evt_ctx);
if (ret != 0) {
break;
}
}
/* Ensure all messages get through to ourselves. */
pong_count = 0;
strlcpy(buf, "1234567890", sizeof(buf));
for (i=0;i<n;i++) {
messaging_send(msg_ctx, messaging_server_id(msg_ctx), MSG_PING,
&data_blob_null);
messaging_send_buf(msg_ctx, messaging_server_id(msg_ctx),
MSG_PING,(uint8 *)buf, 11);
}
/*
* We have to loop at least 2 times for
* each message as local ping messages are
* handled by an immediate callback, that
* has to be dispatched, which sends a pong
* message, which also has to be dispatched.
* Above we sent 2*n messages, which means
* we have to dispatch 4*n times.
*/
while (pong_count < n*2) {
ret = tevent_loop_once(evt_ctx);
if (ret != 0) {
break;
}
}
if (pong_count != 2*n) {
fprintf(stderr, "Message count failed (%d).\n", pong_count);
}
/* Speed testing */
pong_count = 0;
{
struct timeval tv = timeval_current();
size_t timelimit = n;
size_t ping_count = 0;
printf("Sending pings for %d seconds\n", (int)timelimit);
while (timeval_elapsed(&tv) < timelimit) {
if(NT_STATUS_IS_OK(messaging_send_buf(
msg_ctx, pid_to_procid(pid),
MSG_PING,
(uint8 *)buf, 11)))
ping_count++;
if(NT_STATUS_IS_OK(messaging_send(
msg_ctx, pid_to_procid(pid),
MSG_PING, &data_blob_null)))
ping_count++;
while (ping_count > pong_count + 20) {
ret = tevent_loop_once(evt_ctx);
if (ret != 0) {
break;
}
}
}
printf("waiting for %d remaining replies (done %d)\n",
(int)(ping_count - pong_count), pong_count);
while (timeval_elapsed(&tv) < 30 && pong_count < ping_count) {
ret = tevent_loop_once(evt_ctx);
if (ret != 0) {
break;
}
}
if (ping_count != pong_count) {
fprintf(stderr, "ping test failed! received %d, sent "
"%d\n", pong_count, (int)ping_count);
}
printf("ping rate of %.0f messages/sec\n",
(ping_count+pong_count)/timeval_elapsed(&tv));
}
TALLOC_FREE(frame);
return (0);
}
/* test UDP/138 netlogon requests */
static bool nbt_test_netlogon(struct torture_context *tctx)
{
struct dgram_mailslot_handler *dgmslot;
struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev);
struct socket_address *dest;
const char *myaddress;
struct nbt_netlogon_packet logon;
struct nbt_netlogon_response *response;
struct nbt_name myname;
NTSTATUS status;
struct timeval tv = timeval_current();
struct socket_address *socket_address;
const char *address;
struct nbt_name name;
struct interface *ifaces;
name.name = lpcfg_workgroup(tctx->lp_ctx);
name.type = NBT_NAME_LOGON;
name.scope = NULL;
/* do an initial name resolution to find its IP */
torture_assert_ntstatus_ok(tctx,
resolve_name_ex(lpcfg_resolve_context(tctx->lp_ctx),
0, 0,
&name, tctx, &address, tctx->ev),
talloc_asprintf(tctx, "Failed to resolve %s", name.name));
load_interface_list(tctx, tctx->lp_ctx, &ifaces);
myaddress = talloc_strdup(dgmsock, iface_list_best_ip(ifaces, address));
socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
myaddress, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, socket_address != NULL, "Error getting address");
/* try receiving replies on port 138 first, which will only
work if we are root and smbd/nmbd are not running - fall
back to listening on any port, which means replies from
most windows versions won't be seen */
status = socket_listen(dgmsock->sock, socket_address, 0, 0);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(socket_address);
socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
myaddress, 0);
torture_assert(tctx, socket_address != NULL, "Error getting address");
socket_listen(dgmsock->sock, socket_address, 0, 0);
}
/* setup a temporary mailslot listener for replies */
dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
netlogon_handler, NULL);
torture_assert(tctx, dgmslot != NULL, "Error temporary mailslot for GetDC");
ZERO_STRUCT(logon);
logon.command = LOGON_PRIMARY_QUERY;
logon.req.pdc.computer_name = TEST_NAME;
logon.req.pdc.mailslot_name = dgmslot->mailslot_name;
logon.req.pdc.unicode_name = TEST_NAME;
logon.req.pdc.nt_version = 1;
logon.req.pdc.lmnt_token = 0xFFFF;
logon.req.pdc.lm20_token = 0xFFFF;
make_nbt_name_client(&myname, TEST_NAME);
dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
address, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, dest != NULL, "Error getting address");
status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
NBT_MAILSLOT_NETLOGON,
&myname, &logon);
torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
while (timeval_elapsed(&tv) < 5 && !dgmslot->private_data) {
tevent_loop_once(dgmsock->event_ctx);
}
response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
torture_assert(tctx, response->response_type == NETLOGON_GET_PDC, "Got incorrect type of netlogon response");
torture_assert(tctx, response->data.get_pdc.command == NETLOGON_RESPONSE_FROM_PDC, "Got incorrect netlogon response command");
return true;
}
static bool test_event_context(struct torture_context *test,
const void *test_data)
{
struct tevent_context *ev_ctx;
int fd[2] = { -1, -1 };
const char *backend = (const char *)test_data;
int alarm_count=0, info_count=0;
struct tevent_fd *fde_read;
struct tevent_fd *fde_read_1;
struct tevent_fd *fde_write;
struct tevent_fd *fde_write_1;
#ifdef SA_RESTART
struct tevent_signal *se1 = NULL;
#endif
#ifdef SA_RESETHAND
struct tevent_signal *se2 = NULL;
#endif
#ifdef SA_SIGINFO
struct tevent_signal *se3 = NULL;
#endif
int finished=0;
struct timeval t;
int ret;
ev_ctx = tevent_context_init_byname(test, backend);
if (ev_ctx == NULL) {
torture_comment(test, "event backend '%s' not supported\n", backend);
return true;
}
torture_comment(test, "backend '%s' - %s\n",
backend, __FUNCTION__);
/* reset globals */
fde_count = 0;
/* create a pipe */
ret = pipe(fd);
torture_assert_int_equal(test, ret, 0, "pipe failed");
fde_read = tevent_add_fd(ev_ctx, ev_ctx, fd[0], TEVENT_FD_READ,
fde_handler_read, fd);
fde_write_1 = tevent_add_fd(ev_ctx, ev_ctx, fd[0], TEVENT_FD_WRITE,
fde_handler_write_1, fd);
fde_write = tevent_add_fd(ev_ctx, ev_ctx, fd[1], TEVENT_FD_WRITE,
fde_handler_write, fd);
fde_read_1 = tevent_add_fd(ev_ctx, ev_ctx, fd[1], TEVENT_FD_READ,
fde_handler_read_1, fd);
tevent_fd_set_auto_close(fde_read);
tevent_fd_set_auto_close(fde_write);
tevent_add_timer(ev_ctx, ev_ctx, timeval_current_ofs(2,0),
finished_handler, &finished);
#ifdef SA_RESTART
se1 = tevent_add_signal(ev_ctx, ev_ctx, SIGALRM, SA_RESTART, count_handler, &alarm_count);
torture_assert(test, se1 != NULL, "failed to setup se1");
#endif
#ifdef SA_RESETHAND
se2 = tevent_add_signal(ev_ctx, ev_ctx, SIGALRM, SA_RESETHAND, count_handler, &alarm_count);
torture_assert(test, se2 != NULL, "failed to setup se2");
#endif
#ifdef SA_SIGINFO
se3 = tevent_add_signal(ev_ctx, ev_ctx, SIGUSR1, SA_SIGINFO, count_handler, &info_count);
torture_assert(test, se3 != NULL, "failed to setup se3");
#endif
t = timeval_current();
while (!finished) {
errno = 0;
if (tevent_loop_once(ev_ctx) == -1) {
talloc_free(ev_ctx);
torture_fail(test, talloc_asprintf(test, "Failed event loop %s\n", strerror(errno)));
}
}
talloc_free(fde_read_1);
talloc_free(fde_write_1);
talloc_free(fde_read);
talloc_free(fde_write);
while (alarm_count < fde_count+1) {
if (tevent_loop_once(ev_ctx) == -1) {
break;
}
}
torture_comment(test, "Got %.2f pipe events/sec\n", fde_count/timeval_elapsed(&t));
#ifdef SA_RESTART
talloc_free(se1);
#endif
torture_assert_int_equal(test, alarm_count, 1+fde_count, "alarm count mismatch");
#ifdef SA_RESETHAND
/*
* we do not call talloc_free(se2)
* because it is already gone,
* after triggering the event handler.
*/
#endif
#ifdef SA_SIGINFO
talloc_free(se3);
torture_assert_int_equal(test, info_count, fde_count, "info count mismatch");
#endif
talloc_free(ev_ctx);
return true;
}
static bool test_smb2_open_multi(struct torture_context *tctx,
struct smb2_tree *tree)
{
const char *fname = "test_oplock.dat";
NTSTATUS status;
bool ret = true;
union smb_open io;
struct smb2_tree **trees;
struct smb2_request **requests;
union smb_open *ios;
int i, num_files = 3;
int num_ok = 0;
int num_collision = 0;
torture_comment(tctx,
"Testing SMB2 Open with multiple connections\n");
trees = talloc_array(tctx, struct smb2_tree *, num_files);
requests = talloc_array(tctx, struct smb2_request *, num_files);
ios = talloc_array(tctx, union smb_open, num_files);
if ((tctx->ev == NULL) || (trees == NULL) || (requests == NULL) ||
(ios == NULL)) {
torture_comment(tctx, ("talloc failed\n"));
ret = false;
goto done;
}
tree->session->transport->options.request_timeout = 60;
for (i=0; i<num_files; i++) {
if (!torture_smb2_connection(tctx, &(trees[i]))) {
torture_comment(tctx,
"Could not open %d'th connection\n", i);
ret = false;
goto done;
}
trees[i]->session->transport->options.request_timeout = 60;
}
/* cleanup */
smb2_util_unlink(tree, fname);
/*
base ntcreatex parms
*/
ZERO_STRUCT(io.smb2);
io.generic.level = RAW_OPEN_SMB2;
io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
io.smb2.in.alloc_size = 0;
io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
NTCREATEX_SHARE_ACCESS_WRITE|
NTCREATEX_SHARE_ACCESS_DELETE;
io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
io.smb2.in.create_options = 0;
io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
io.smb2.in.security_flags = 0;
io.smb2.in.fname = fname;
io.smb2.in.create_flags = 0;
for (i=0; i<num_files; i++) {
ios[i] = io;
requests[i] = smb2_create_send(trees[i], &(ios[i].smb2));
if (requests[i] == NULL) {
torture_comment(tctx,
"could not send %d'th request\n", i);
ret = false;
goto done;
}
}
torture_comment(tctx, "waiting for replies\n");
while (1) {
bool unreplied = false;
for (i=0; i<num_files; i++) {
if (requests[i] == NULL) {
continue;
}
if (requests[i]->state < SMB2_REQUEST_DONE) {
unreplied = true;
break;
}
status = smb2_create_recv(requests[i], tctx,
&(ios[i].smb2));
torture_comment(tctx,
"File %d returned status %s\n", i,
nt_errstr(status));
if (NT_STATUS_IS_OK(status)) {
num_ok += 1;
}
if (NT_STATUS_EQUAL(status,
NT_STATUS_OBJECT_NAME_COLLISION)) {
num_collision += 1;
}
requests[i] = NULL;
}
if (!unreplied) {
break;
}
if (tevent_loop_once(tctx->ev) != 0) {
torture_comment(tctx, "tevent_loop_once failed\n");
ret = false;
goto done;
}
}
if ((num_ok != 1) || (num_ok + num_collision != num_files)) {
ret = false;
}
done:
smb2_deltree(tree, fname);
return ret;
}
/*
main program
*/
int main(int argc, const char *argv[])
{
struct ctdb_context *ctdb;
struct ctdb_db_context *ctdb_db;
struct tevent_context *ev;
TDB_DATA key;
struct poptOption popt_options[] = {
POPT_AUTOHELP
{ "record", 'r', POPT_ARG_STRING, &TESTKEY, 0, "record", "string" },
POPT_TABLEEND
};
int opt;
const char **extra_argv;
int extra_argc = 0;
poptContext pc;
pc = poptGetContext(argv[0], argc, argv, popt_options, POPT_CONTEXT_KEEP_FIRST);
while ((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
default:
fprintf(stderr, "Invalid option %s: %s\n",
poptBadOption(pc, 0), poptStrerror(opt));
exit(1);
}
}
/* setup the remaining options for the main program to use */
extra_argv = poptGetArgs(pc);
if (extra_argv) {
extra_argv++;
while (extra_argv[extra_argc]) extra_argc++;
}
ev = tevent_context_init(NULL);
ctdb = ctdb_cmdline_client(ev, timeval_current_ofs(3, 0));
if (ctdb == NULL) {
printf("failed to connect to ctdb daemon.\n");
exit(1);
}
key.dptr = discard_const(TESTKEY);
key.dsize = strlen(TESTKEY);
/* attach to a specific database */
ctdb_db = ctdb_attach(ctdb, timeval_current_ofs(3, 0), "test.tdb",
false, 0);
if (!ctdb_db) {
fprintf(stderr, "ctdb_attach failed - %s\n", ctdb_errstr(ctdb));
exit(10);
}
printf("Waiting for cluster\n");
while (1) {
uint32_t recmode=1;
ctdb_ctrl_getrecmode(ctdb, ctdb, timeval_zero(), CTDB_CURRENT_NODE, &recmode);
if (recmode == 0) break;
tevent_loop_once(ev);
}
fetch_readonly_once(ctdb, ctdb_db, key);
return 0;
}
/*
test the TestSleep interface
*/
static bool test_sleep(struct torture_context *tctx,
struct dcerpc_pipe *p)
{
int i;
#define ASYNC_COUNT 3
struct tevent_req *req[ASYNC_COUNT];
struct echo_TestSleep r[ASYNC_COUNT];
bool done1[ASYNC_COUNT];
bool done2[ASYNC_COUNT];
struct timeval snd[ASYNC_COUNT];
struct timeval rcv[ASYNC_COUNT];
struct timeval diff[ASYNC_COUNT];
int total_done = 0;
struct dcerpc_binding_handle *b = p->binding_handle;
enum dcerpc_transport_t transport;
uint32_t assoc_group_id;
struct dcerpc_pipe *p2 = NULL;
NTSTATUS status;
if (torture_setting_bool(tctx, "quick", false)) {
torture_skip(tctx, "TestSleep disabled - use \"torture:quick=no\" to enable\n");
}
torture_comment(tctx, "Testing TestSleep - use \"torture:quick=yes\" to disable\n");
transport = dcerpc_binding_get_transport(p->binding);
assoc_group_id = dcerpc_binding_get_assoc_group_id(p->binding);
torture_comment(tctx, "connect echo connection 2 with "
"DCERPC_CONCURRENT_MULTIPLEX\n");
status = torture_rpc_connection_transport(tctx, &p2,
&ndr_table_rpcecho,
transport,
assoc_group_id,
DCERPC_CONCURRENT_MULTIPLEX);
torture_assert_ntstatus_ok(tctx, status, "opening echo connection 2");
b = p2->binding_handle;
for (i=0;i<ASYNC_COUNT;i++) {
done1[i] = false;
done2[i] = false;
snd[i] = timeval_current();
rcv[i] = timeval_zero();
r[i].in.seconds = ASYNC_COUNT-i;
req[i] = dcerpc_echo_TestSleep_r_send(tctx, tctx->ev, b, &r[i]);
torture_assert(tctx, req[i], "Failed to send async sleep request\n");
tevent_req_set_callback(req[i], test_sleep_done, &done1[i]);
}
while (total_done < ASYNC_COUNT) {
torture_assert(tctx, tevent_loop_once(tctx->ev) == 0,
"Event context loop failed");
for (i=0;i<ASYNC_COUNT;i++) {
if (done2[i] == false && done1[i] == true) {
int rounded_tdiff;
total_done++;
done2[i] = true;
rcv[i] = timeval_current();
diff[i] = timeval_until(&snd[i], &rcv[i]);
rounded_tdiff = (int)(0.5 + diff[i].tv_sec + (1.0e-6*diff[i].tv_usec));
torture_comment(tctx, "rounded_tdiff=%d\n", rounded_tdiff);
torture_assert_ntstatus_ok(tctx,
dcerpc_echo_TestSleep_r_recv(req[i], tctx),
talloc_asprintf(tctx, "TestSleep(%d) failed", i));
torture_assert(tctx, r[i].out.result == r[i].in.seconds,
talloc_asprintf(tctx, "Failed - Asked to sleep for %u seconds (server replied with %u seconds and the reply takes only %u seconds)",
r[i].out.result, r[i].in.seconds, (unsigned int)diff[i].tv_sec));
torture_assert(tctx, r[i].out.result <= rounded_tdiff,
talloc_asprintf(tctx, "Failed - Slept for %u seconds (but reply takes only %u.%06u seconds)",
r[i].out.result, (unsigned int)diff[i].tv_sec, (unsigned int)diff[i].tv_usec));
if (r[i].out.result+1 == rounded_tdiff) {
torture_comment(tctx, "Slept for %u seconds (but reply takes %u.%06u seconds - busy server?)\n",
r[i].out.result, (unsigned int)diff[i].tv_sec, (unsigned int)diff[i].tv_usec);
} else if (r[i].out.result == rounded_tdiff) {
torture_comment(tctx, "Slept for %u seconds (reply takes %u.%06u seconds - ok)\n",
r[i].out.result, (unsigned int)diff[i].tv_sec, (unsigned int)diff[i].tv_usec);
} else {
torture_fail(tctx, talloc_asprintf(tctx,
"(Failed) - Not async - Slept for %u seconds (but reply takes %u.%06u seconds)\n",
r[i].out.result, (unsigned int)diff[i].tv_sec, (unsigned int)diff[i].tv_usec));
}
}
}
}
torture_comment(tctx, "\n");
return true;
}
krb5_error_code smb_krb5_send_and_recv_func(krb5_context context,
void *data,
krb5_krbhst_info *hi,
time_t timeout,
const krb5_data *send_buf,
krb5_data *recv_buf)
{
krb5_error_code ret;
NTSTATUS status;
const char *name;
struct addrinfo *ai, *a;
struct smb_krb5_socket *smb_krb5;
DATA_BLOB send_blob;
struct tevent_context *ev;
TALLOC_CTX *tmp_ctx = talloc_new(NULL);
if (!tmp_ctx) {
return ENOMEM;
}
if (!data) {
/* If no event context was available, then create one for this loop */
ev = samba_tevent_context_init(tmp_ctx);
if (!ev) {
talloc_free(tmp_ctx);
return ENOMEM;
}
} else {
ev = talloc_get_type_abort(data, struct tevent_context);
}
send_blob = data_blob_const(send_buf->data, send_buf->length);
ret = krb5_krbhst_get_addrinfo(context, hi, &ai);
if (ret) {
talloc_free(tmp_ctx);
return ret;
}
for (a = ai; a; a = a->ai_next) {
struct socket_address *remote_addr;
smb_krb5 = talloc(tmp_ctx, struct smb_krb5_socket);
if (!smb_krb5) {
talloc_free(tmp_ctx);
return ENOMEM;
}
smb_krb5->hi = hi;
switch (a->ai_family) {
case PF_INET:
name = "ipv4";
break;
#ifdef HAVE_IPV6
case PF_INET6:
name = "ipv6";
break;
#endif
default:
talloc_free(tmp_ctx);
return EINVAL;
}
status = NT_STATUS_INVALID_PARAMETER;
switch (hi->proto) {
case KRB5_KRBHST_UDP:
status = socket_create(name, SOCKET_TYPE_DGRAM, &smb_krb5->sock, 0);
break;
case KRB5_KRBHST_TCP:
status = socket_create(name, SOCKET_TYPE_STREAM, &smb_krb5->sock, 0);
break;
case KRB5_KRBHST_HTTP:
talloc_free(tmp_ctx);
return EINVAL;
}
if (!NT_STATUS_IS_OK(status)) {
talloc_free(smb_krb5);
continue;
}
talloc_steal(smb_krb5, smb_krb5->sock);
remote_addr = socket_address_from_sockaddr(smb_krb5, a->ai_addr, a->ai_addrlen);
if (!remote_addr) {
talloc_free(smb_krb5);
continue;
}
status = socket_connect_ev(smb_krb5->sock, NULL, remote_addr, 0, ev);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(smb_krb5);
continue;
}
/* Setup the FDE, start listening for read events
* from the start (otherwise we may miss a socket
* drop) and mark as AUTOCLOSE along with the fde */
/* Ths is equivilant to EVENT_FD_READABLE(smb_krb5->fde) */
smb_krb5->fde = tevent_add_fd(ev, smb_krb5->sock,
socket_get_fd(smb_krb5->sock),
TEVENT_FD_READ,
smb_krb5_socket_handler, smb_krb5);
/* its now the job of the event layer to close the socket */
tevent_fd_set_close_fn(smb_krb5->fde, socket_tevent_fd_close_fn);
socket_set_flags(smb_krb5->sock, SOCKET_FLAG_NOCLOSE);
tevent_add_timer(ev, smb_krb5,
timeval_current_ofs(timeout, 0),
smb_krb5_request_timeout, smb_krb5);
smb_krb5->status = NT_STATUS_OK;
smb_krb5->reply = data_blob(NULL, 0);
switch (hi->proto) {
case KRB5_KRBHST_UDP:
TEVENT_FD_WRITEABLE(smb_krb5->fde);
smb_krb5->request = send_blob;
break;
case KRB5_KRBHST_TCP:
smb_krb5->packet = packet_init(smb_krb5);
if (smb_krb5->packet == NULL) {
talloc_free(smb_krb5);
return ENOMEM;
}
packet_set_private(smb_krb5->packet, smb_krb5);
packet_set_socket(smb_krb5->packet, smb_krb5->sock);
packet_set_callback(smb_krb5->packet, smb_krb5_full_packet);
packet_set_full_request(smb_krb5->packet, packet_full_request_u32);
packet_set_error_handler(smb_krb5->packet, smb_krb5_error_handler);
packet_set_event_context(smb_krb5->packet, ev);
packet_set_fde(smb_krb5->packet, smb_krb5->fde);
smb_krb5->request = data_blob_talloc(smb_krb5, NULL, send_blob.length + 4);
RSIVAL(smb_krb5->request.data, 0, send_blob.length);
memcpy(smb_krb5->request.data+4, send_blob.data, send_blob.length);
packet_send(smb_krb5->packet, smb_krb5->request);
break;
case KRB5_KRBHST_HTTP:
talloc_free(tmp_ctx);
return EINVAL;
}
while ((NT_STATUS_IS_OK(smb_krb5->status)) && !smb_krb5->reply.length) {
if (tevent_loop_once(ev) != 0) {
talloc_free(tmp_ctx);
return EINVAL;
}
/* After each and every event loop, reset the
* send_to_kdc pointers to what they were when
* we entered this loop. That way, if a
* nested event has invalidated them, we put
* it back before we return to the heimdal
* code */
ret = krb5_set_send_to_kdc_func(context,
smb_krb5_send_and_recv_func,
data);
if (ret != 0) {
talloc_free(tmp_ctx);
return ret;
}
}
if (NT_STATUS_EQUAL(smb_krb5->status, NT_STATUS_IO_TIMEOUT)) {
talloc_free(smb_krb5);
continue;
}
if (!NT_STATUS_IS_OK(smb_krb5->status)) {
struct tsocket_address *addr = socket_address_to_tsocket_address(smb_krb5, remote_addr);
const char *addr_string = NULL;
if (addr) {
addr_string = tsocket_address_inet_addr_string(addr, smb_krb5);
} else {
addr_string = NULL;
}
DEBUG(2,("Error reading smb_krb5 reply packet: %s from %s\n", nt_errstr(smb_krb5->status),
addr_string));
talloc_free(smb_krb5);
continue;
}
ret = krb5_data_copy(recv_buf, smb_krb5->reply.data, smb_krb5->reply.length);
if (ret) {
talloc_free(tmp_ctx);
return ret;
}
talloc_free(smb_krb5);
break;
}
talloc_free(tmp_ctx);
if (a) {
return 0;
}
return KRB5_KDC_UNREACH;
}
bool torture_samba3_posixtimedlock(struct torture_context *tctx, struct smbcli_state *cli)
{
NTSTATUS status;
bool ret = true;
const char *dirname = "posixlock";
const char *fname = "locked";
const char *fpath;
const char *localdir;
const char *localname;
int fnum = -1;
int fd = -1;
struct flock posix_lock;
union smb_lock io;
struct smb_lock_entry lock_entry;
struct smbcli_request *req;
struct lock_result_state lock_result;
struct tevent_timer *te;
torture_assert(tctx, torture_setup_dir(cli, dirname), "creating test directory");
if (!(fpath = talloc_asprintf(tctx, "%s\\%s", dirname, fname))) {
torture_warning(tctx, "talloc failed\n");
ret = false;
goto done;
}
fnum = smbcli_open(cli->tree, fpath, O_RDWR | O_CREAT, DENY_NONE);
if (fnum == -1) {
torture_warning(tctx, "Could not create file %s: %s\n", fpath,
smbcli_errstr(cli->tree));
ret = false;
goto done;
}
if (!(localdir = torture_setting_string(tctx, "localdir", NULL))) {
torture_warning(tctx, "Need 'localdir' setting\n");
ret = false;
goto done;
}
if (!(localname = talloc_asprintf(tctx, "%s/%s/%s", localdir, dirname,
fname))) {
torture_warning(tctx, "talloc failed\n");
ret = false;
goto done;
}
/*
* Lock a byte range from posix
*/
fd = open(localname, O_RDWR);
if (fd == -1) {
torture_warning(tctx, "open(%s) failed: %s\n",
localname, strerror(errno));
goto done;
}
posix_lock.l_type = F_WRLCK;
posix_lock.l_whence = SEEK_SET;
posix_lock.l_start = 0;
posix_lock.l_len = 1;
if (fcntl(fd, F_SETLK, &posix_lock) == -1) {
torture_warning(tctx, "fcntl failed: %s\n", strerror(errno));
ret = false;
goto done;
}
/*
* Try a cifs brlock without timeout to see if posix locking = yes
*/
io.lockx.in.ulock_cnt = 0;
io.lockx.in.lock_cnt = 1;
lock_entry.count = 1;
lock_entry.offset = 0;
lock_entry.pid = cli->tree->session->pid;
io.lockx.level = RAW_LOCK_LOCKX;
io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
io.lockx.in.timeout = 0;
io.lockx.in.locks = &lock_entry;
io.lockx.in.file.fnum = fnum;
status = smb_raw_lock(cli->tree, &io);
ret = true;
CHECK_STATUS(tctx, status, NT_STATUS_FILE_LOCK_CONFLICT);
if (!ret) {
goto done;
}
/*
* Now fire off a timed brlock, unlock the posix lock and see if the
* timed lock gets through.
*/
io.lockx.in.timeout = 5000;
req = smb_raw_lock_send(cli->tree, &io);
if (req == NULL) {
torture_warning(tctx, "smb_raw_lock_send failed\n");
ret = false;
goto done;
}
lock_result.done = false;
req->async.fn = receive_lock_result;
req->async.private_data = &lock_result;
te = tevent_add_timer(tctx->ev,
tctx, timeval_current_ofs(1, 0),
close_locked_file, &fd);
if (te == NULL) {
torture_warning(tctx, "tevent_add_timer failed\n");
ret = false;
goto done;
}
while ((fd != -1) || (!lock_result.done)) {
if (tevent_loop_once(tctx->ev) == -1) {
torture_warning(tctx, "tevent_loop_once failed: %s\n",
strerror(errno));
ret = false;
goto done;
}
}
CHECK_STATUS(tctx, lock_result.status, NT_STATUS_OK);
done:
if (fnum != -1) {
smbcli_close(cli->tree, fnum);
}
if (fd != -1) {
close(fd);
}
smbcli_deltree(cli->tree, dirname);
return ret;
}
static bool test_event_fd2(struct torture_context *tctx,
const void *test_data)
{
struct test_event_fd2_state state;
int sock[2];
uint8_t c = 0;
ZERO_STRUCT(state);
state.tctx = tctx;
state.backend = (const char *)test_data;
state.ev = tevent_context_init_byname(tctx, state.backend);
if (state.ev == NULL) {
torture_skip(tctx, talloc_asprintf(tctx,
"event backend '%s' not supported\n",
state.backend));
return true;
}
tevent_set_debug_stderr(state.ev);
torture_comment(tctx, "backend '%s' - %s\n",
state.backend, __FUNCTION__);
/*
* This tests the following
*
* - We write 1 byte to each socket
* - We wait for TEVENT_FD_READ/WRITE on both sockets
* - When we get TEVENT_FD_WRITE we write 1 byte
* until both socket buffers are full, which
* means both sockets only get TEVENT_FD_READ.
* - Then we read 1 byte until we have consumed
* all bytes the other end has written.
*/
sock[0] = -1;
sock[1] = -1;
socketpair(AF_UNIX, SOCK_STREAM, 0, sock);
/*
* the timer should never expire
*/
state.te = tevent_add_timer(state.ev, state.ev,
timeval_current_ofs(600, 0),
test_event_fd2_finished, &state);
state.sock0.state = &state;
state.sock0.fd = sock[0];
state.sock0.fde = tevent_add_fd(state.ev, state.ev,
state.sock0.fd,
TEVENT_FD_READ | TEVENT_FD_WRITE,
test_event_fd2_sock_handler,
&state.sock0);
state.sock1.state = &state;
state.sock1.fd = sock[1];
state.sock1.fde = tevent_add_fd(state.ev, state.ev,
state.sock1.fd,
TEVENT_FD_READ | TEVENT_FD_WRITE,
test_event_fd2_sock_handler,
&state.sock1);
tevent_fd_set_auto_close(state.sock0.fde);
tevent_fd_set_auto_close(state.sock1.fde);
write(state.sock0.fd, &c, 1);
state.sock0.num_written++;
write(state.sock1.fd, &c, 1);
state.sock1.num_written++;
while (!state.finished) {
errno = 0;
if (tevent_loop_once(state.ev) == -1) {
talloc_free(state.ev);
torture_fail(tctx, talloc_asprintf(tctx,
"Failed event loop %s\n",
strerror(errno)));
}
}
talloc_free(state.ev);
torture_assert(tctx, state.error == NULL, talloc_asprintf(tctx,
"%s", state.error));
return true;
}
static bool test_event_fd1(struct torture_context *tctx,
const void *test_data)
{
struct test_event_fd1_state state;
ZERO_STRUCT(state);
state.tctx = tctx;
state.backend = (const char *)test_data;
state.ev = tevent_context_init_byname(tctx, state.backend);
if (state.ev == NULL) {
torture_skip(tctx, talloc_asprintf(tctx,
"event backend '%s' not supported\n",
state.backend));
return true;
}
tevent_set_debug_stderr(state.ev);
torture_comment(tctx, "backend '%s' - %s\n",
state.backend, __FUNCTION__);
/*
* This tests the following:
*
* It monitors the state of state.sock[0]
* with tevent_fd, but we never read/write on state.sock[0]
* while state.sock[1] * is only used to write a few bytes.
*
* We have a loop:
* - we wait only for TEVENT_FD_WRITE on state.sock[0]
* - we write 1 byte to state.sock[1]
* - we wait only for TEVENT_FD_READ on state.sock[0]
* - we disable events on state.sock[0]
* - the timer event restarts the loop
* Then we close state.sock[1]
* We have a loop:
* - we wait for TEVENT_FD_READ/WRITE on state.sock[0]
* - we try to read 1 byte
* - if the read gets an error of returns 0
* we disable the event handler
* - the timer finishes the test
*/
state.sock[0] = -1;
state.sock[1] = -1;
socketpair(AF_UNIX, SOCK_STREAM, 0, state.sock);
state.te = tevent_add_timer(state.ev, state.ev,
timeval_current_ofs(0,1000),
test_event_fd1_finished, &state);
state.fde0 = tevent_add_fd(state.ev, state.ev,
state.sock[0], TEVENT_FD_WRITE,
test_event_fd1_fde_handler, &state);
/* state.fde1 is only used to auto close */
state.fde1 = tevent_add_fd(state.ev, state.ev,
state.sock[1], 0,
test_event_fd1_fde_handler, &state);
tevent_fd_set_auto_close(state.fde0);
tevent_fd_set_auto_close(state.fde1);
while (!state.finished) {
errno = 0;
if (tevent_loop_once(state.ev) == -1) {
talloc_free(state.ev);
torture_fail(tctx, talloc_asprintf(tctx,
"Failed event loop %s\n",
strerror(errno)));
}
}
talloc_free(state.ev);
torture_assert(tctx, state.error == NULL, talloc_asprintf(tctx,
"%s", state.error));
return true;
}
/*
test ping speed
*/
static bool test_ping_speed(struct torture_context *tctx)
{
struct tevent_context *ev;
struct imessaging_context *msg_client_ctx;
struct imessaging_context *msg_server_ctx;
int ping_count = 0;
int pong_count = 0;
struct timeval tv;
int timelimit = torture_setting_int(tctx, "timelimit", 10);
uint32_t msg_ping, msg_exit;
lpcfg_set_cmdline(tctx->lp_ctx, "pid directory", "piddir.tmp");
ev = tctx->ev;
msg_server_ctx = imessaging_init(tctx,
tctx->lp_ctx, cluster_id(0, 1),
ev, true);
torture_assert(tctx, msg_server_ctx != NULL, "Failed to init ping messaging context");
imessaging_register_tmp(msg_server_ctx, NULL, ping_message, &msg_ping);
imessaging_register_tmp(msg_server_ctx, tctx, exit_message, &msg_exit);
msg_client_ctx = imessaging_init(tctx,
tctx->lp_ctx,
cluster_id(0, 2),
ev, true);
torture_assert(tctx, msg_client_ctx != NULL,
"msg_client_ctx imessaging_init() failed");
imessaging_register_tmp(msg_client_ctx, &pong_count, pong_message, &msg_pong);
tv = timeval_current();
torture_comment(tctx, "Sending pings for %d seconds\n", timelimit);
while (timeval_elapsed(&tv) < timelimit) {
DATA_BLOB data;
NTSTATUS status1, status2;
data.data = discard_const_p(uint8_t, "testing");
data.length = strlen((const char *)data.data);
status1 = imessaging_send(msg_client_ctx, cluster_id(0, 1), msg_ping, &data);
status2 = imessaging_send(msg_client_ctx, cluster_id(0, 1), msg_ping, NULL);
torture_assert_ntstatus_ok(tctx, status1, "msg1 failed");
ping_count++;
torture_assert_ntstatus_ok(tctx, status2, "msg2 failed");
ping_count++;
while (ping_count > pong_count + 20) {
tevent_loop_once(ev);
}
}
torture_comment(tctx, "waiting for %d remaining replies (done %d)\n",
ping_count - pong_count, pong_count);
while (timeval_elapsed(&tv) < 30 && pong_count < ping_count) {
tevent_loop_once(ev);
}
torture_comment(tctx, "sending exit\n");
imessaging_send(msg_client_ctx, cluster_id(0, 1), msg_exit, NULL);
torture_assert_int_equal(tctx, ping_count, pong_count, "ping test failed");
torture_comment(tctx, "ping rate of %.0f messages/sec\n",
(ping_count+pong_count)/timeval_elapsed(&tv));
talloc_free(msg_client_ctx);
talloc_free(msg_server_ctx);
return true;
}
/* test UDP/138 ntlogon requests */
static bool nbt_test_ntlogon(struct torture_context *tctx)
{
struct dgram_mailslot_handler *dgmslot;
struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev);
struct socket_address *dest;
struct test_join *join_ctx;
const struct dom_sid *dom_sid;
struct cli_credentials *machine_credentials;
const char *myaddress;
struct nbt_netlogon_packet logon;
struct nbt_netlogon_response *response;
struct nbt_name myname;
NTSTATUS status;
struct timeval tv = timeval_current();
struct socket_address *socket_address;
const char *address;
struct nbt_name name;
struct interface *ifaces;
name.name = lpcfg_workgroup(tctx->lp_ctx);
name.type = NBT_NAME_LOGON;
name.scope = NULL;
/* do an initial name resolution to find its IP */
torture_assert_ntstatus_ok(tctx,
resolve_name_ex(lpcfg_resolve_context(tctx->lp_ctx),
0, 0, &name, tctx, &address, tctx->ev),
talloc_asprintf(tctx, "Failed to resolve %s", name.name));
load_interface_list(tctx, tctx->lp_ctx, &ifaces);
myaddress = talloc_strdup(dgmsock, iface_list_best_ip(ifaces, address));
socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
myaddress, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, socket_address != NULL, "Error getting address");
/* try receiving replies on port 138 first, which will only
work if we are root and smbd/nmbd are not running - fall
back to listening on any port, which means replies from
most windows versions won't be seen */
status = socket_listen(dgmsock->sock, socket_address, 0, 0);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(socket_address);
socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
myaddress, 0);
torture_assert(tctx, socket_address != NULL, "Error getting address");
socket_listen(dgmsock->sock, socket_address, 0, 0);
}
join_ctx = torture_join_domain(tctx, TEST_NAME,
ACB_WSTRUST, &machine_credentials);
torture_assert(tctx, join_ctx != NULL,
talloc_asprintf(tctx, "Failed to join domain %s as %s\n",
lpcfg_workgroup(tctx->lp_ctx), TEST_NAME));
dom_sid = torture_join_sid(join_ctx);
/* setup a temporary mailslot listener for replies */
dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
netlogon_handler, NULL);
torture_assert(tctx, dgmslot != NULL, "Error temporary mailslot for GetDC");
ZERO_STRUCT(logon);
logon.command = LOGON_SAM_LOGON_REQUEST;
logon.req.logon.request_count = 0;
logon.req.logon.computer_name = TEST_NAME;
logon.req.logon.user_name = TEST_NAME"$";
logon.req.logon.mailslot_name = dgmslot->mailslot_name;
logon.req.logon.acct_control = ACB_WSTRUST;
/* Try with a SID this time */
logon.req.logon.sid = *dom_sid;
logon.req.logon.nt_version = 1;
logon.req.logon.lmnt_token = 0xFFFF;
logon.req.logon.lm20_token = 0xFFFF;
make_nbt_name_client(&myname, TEST_NAME);
dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
address, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, dest != NULL, "Error getting address");
status = dgram_mailslot_netlogon_send(dgmsock,
&name, dest,
NBT_MAILSLOT_NTLOGON,
&myname, &logon);
torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
tevent_loop_once(dgmsock->event_ctx);
}
response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
map_netlogon_samlogon_response(&response->data.samlogon);
torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
torture_assert_str_equal(tctx, response->data.samlogon.data.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response");
torture_assert(tctx,
strstr(response->data.samlogon.data.nt5_ex.pdc_name, "\\\\") != NULL,
"PDC name should be in UNC form");
/* setup a temporary mailslot listener for replies */
dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
netlogon_handler, NULL);
torture_assert(tctx, dgmslot != NULL, "Error temporary mailslot for GetDC");
ZERO_STRUCT(logon);
logon.command = LOGON_SAM_LOGON_REQUEST;
logon.req.logon.request_count = 0;
logon.req.logon.computer_name = TEST_NAME;
logon.req.logon.user_name = TEST_NAME"$";
logon.req.logon.mailslot_name = dgmslot->mailslot_name;
logon.req.logon.acct_control = ACB_WSTRUST;
/* Leave sid as all zero */
logon.req.logon.nt_version = 1;
logon.req.logon.lmnt_token = 0xFFFF;
logon.req.logon.lm20_token = 0xFFFF;
make_nbt_name_client(&myname, TEST_NAME);
dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
address, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, dest != NULL, "Error getting address");
status = dgram_mailslot_netlogon_send(dgmsock,
&name, dest,
NBT_MAILSLOT_NTLOGON,
&myname, &logon);
torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
tevent_loop_once(dgmsock->event_ctx);
}
response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
map_netlogon_samlogon_response(&response->data.samlogon);
torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
torture_assert_str_equal(tctx, response->data.samlogon.data.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response");
torture_assert(tctx,
strstr(response->data.samlogon.data.nt5_ex.pdc_name, "\\\\") != NULL,
"PDC name should be in UNC form");
/* setup (another) temporary mailslot listener for replies */
dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
netlogon_handler, NULL);
torture_assert(tctx, dgmslot != NULL, "Error temporary mailslot for GetDC");
ZERO_STRUCT(logon);
logon.command = LOGON_PRIMARY_QUERY;
logon.req.pdc.computer_name = TEST_NAME;
logon.req.pdc.mailslot_name = dgmslot->mailslot_name;
logon.req.pdc.unicode_name = TEST_NAME;
logon.req.pdc.nt_version = 1;
logon.req.pdc.lmnt_token = 0xFFFF;
logon.req.pdc.lm20_token = 0xFFFF;
make_nbt_name_client(&myname, TEST_NAME);
dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
address, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, dest != NULL, "Error getting address");
status = dgram_mailslot_netlogon_send(dgmsock,
&name, dest,
NBT_MAILSLOT_NTLOGON,
&myname, &logon);
torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
while (timeval_elapsed(&tv) < 5 && !dgmslot->private_data) {
tevent_loop_once(dgmsock->event_ctx);
}
response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
torture_assert_int_equal(tctx, response->response_type, NETLOGON_GET_PDC, "Got incorrect type of ntlogon response");
torture_assert_int_equal(tctx, response->data.get_pdc.command, NETLOGON_RESPONSE_FROM_PDC, "Got incorrect ntlogon response command");
torture_leave_domain(tctx, join_ctx);
/* setup (another) temporary mailslot listener for replies */
dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
netlogon_handler, NULL);
torture_assert(tctx, dgmslot != NULL, "Error temporary mailslot for GetDC");
ZERO_STRUCT(logon);
logon.command = LOGON_PRIMARY_QUERY;
logon.req.pdc.computer_name = TEST_NAME;
logon.req.pdc.mailslot_name = dgmslot->mailslot_name;
logon.req.pdc.unicode_name = TEST_NAME;
logon.req.pdc.nt_version = 1;
logon.req.pdc.lmnt_token = 0xFFFF;
logon.req.pdc.lm20_token = 0xFFFF;
make_nbt_name_client(&myname, TEST_NAME);
dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
address, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, dest != NULL, "Error getting address");
status = dgram_mailslot_netlogon_send(dgmsock,
&name, dest,
NBT_MAILSLOT_NTLOGON,
&myname, &logon);
torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
while (timeval_elapsed(&tv) < 5 && !dgmslot->private_data) {
tevent_loop_once(dgmsock->event_ctx);
}
response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
torture_assert_int_equal(tctx, response->response_type, NETLOGON_GET_PDC, "Got incorrect type of ntlogon response");
torture_assert_int_equal(tctx, response->data.get_pdc.command, NETLOGON_RESPONSE_FROM_PDC, "Got incorrect ntlogon response command");
return true;
}
krb5_error_code smb_krb5_send_and_recv_func(krb5_context context,
void *data,
krb5_krbhst_info *hi,
time_t timeout,
const krb5_data *send_buf,
krb5_data *recv_buf)
{
krb5_error_code ret;
NTSTATUS status;
struct socket_address *remote_addr;
const char *name;
struct addrinfo *ai, *a;
struct smb_krb5_socket *smb_krb5;
struct tevent_context *ev = talloc_get_type(data, struct tevent_context);
DATA_BLOB send_blob = data_blob_const(send_buf->data, send_buf->length);
ret = krb5_krbhst_get_addrinfo(context, hi, &ai);
if (ret) {
return ret;
}
for (a = ai; a; a = ai->ai_next) {
smb_krb5 = talloc(NULL, struct smb_krb5_socket);
if (!smb_krb5) {
return ENOMEM;
}
smb_krb5->hi = hi;
switch (a->ai_family) {
case PF_INET:
name = "ipv4";
break;
#ifdef HAVE_IPV6
case PF_INET6:
name = "ipv6";
break;
#endif
default:
talloc_free(smb_krb5);
return EINVAL;
}
status = NT_STATUS_INVALID_PARAMETER;
switch (hi->proto) {
case KRB5_KRBHST_UDP:
status = socket_create(name, SOCKET_TYPE_DGRAM, &smb_krb5->sock, 0);
break;
case KRB5_KRBHST_TCP:
status = socket_create(name, SOCKET_TYPE_STREAM, &smb_krb5->sock, 0);
break;
case KRB5_KRBHST_HTTP:
talloc_free(smb_krb5);
return EINVAL;
}
if (!NT_STATUS_IS_OK(status)) {
talloc_free(smb_krb5);
continue;
}
talloc_steal(smb_krb5, smb_krb5->sock);
remote_addr = socket_address_from_sockaddr(smb_krb5, a->ai_addr, a->ai_addrlen);
if (!remote_addr) {
talloc_free(smb_krb5);
continue;
}
status = socket_connect_ev(smb_krb5->sock, NULL, remote_addr, 0, ev);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(smb_krb5);
continue;
}
talloc_free(remote_addr);
/* Setup the FDE, start listening for read events
* from the start (otherwise we may miss a socket
* drop) and mark as AUTOCLOSE along with the fde */
/* Ths is equivilant to EVENT_FD_READABLE(smb_krb5->fde) */
smb_krb5->fde = tevent_add_fd(ev, smb_krb5->sock,
socket_get_fd(smb_krb5->sock),
TEVENT_FD_READ,
smb_krb5_socket_handler, smb_krb5);
/* its now the job of the event layer to close the socket */
tevent_fd_set_close_fn(smb_krb5->fde, socket_tevent_fd_close_fn);
socket_set_flags(smb_krb5->sock, SOCKET_FLAG_NOCLOSE);
tevent_add_timer(ev, smb_krb5,
timeval_current_ofs(timeout, 0),
smb_krb5_request_timeout, smb_krb5);
smb_krb5->status = NT_STATUS_OK;
smb_krb5->reply = data_blob(NULL, 0);
switch (hi->proto) {
case KRB5_KRBHST_UDP:
TEVENT_FD_WRITEABLE(smb_krb5->fde);
smb_krb5->request = send_blob;
break;
case KRB5_KRBHST_TCP:
smb_krb5->packet = packet_init(smb_krb5);
if (smb_krb5->packet == NULL) {
talloc_free(smb_krb5);
return ENOMEM;
}
packet_set_private(smb_krb5->packet, smb_krb5);
packet_set_socket(smb_krb5->packet, smb_krb5->sock);
packet_set_callback(smb_krb5->packet, smb_krb5_full_packet);
packet_set_full_request(smb_krb5->packet, packet_full_request_u32);
packet_set_error_handler(smb_krb5->packet, smb_krb5_error_handler);
packet_set_event_context(smb_krb5->packet, ev);
packet_set_fde(smb_krb5->packet, smb_krb5->fde);
smb_krb5->request = data_blob_talloc(smb_krb5, NULL, send_blob.length + 4);
RSIVAL(smb_krb5->request.data, 0, send_blob.length);
memcpy(smb_krb5->request.data+4, send_blob.data, send_blob.length);
packet_send(smb_krb5->packet, smb_krb5->request);
break;
case KRB5_KRBHST_HTTP:
talloc_free(smb_krb5);
return EINVAL;
}
while ((NT_STATUS_IS_OK(smb_krb5->status)) && !smb_krb5->reply.length) {
if (tevent_loop_once(ev) != 0) {
talloc_free(smb_krb5);
return EINVAL;
}
}
if (NT_STATUS_EQUAL(smb_krb5->status, NT_STATUS_IO_TIMEOUT)) {
talloc_free(smb_krb5);
continue;
}
if (!NT_STATUS_IS_OK(smb_krb5->status)) {
DEBUG(2,("Error reading smb_krb5 reply packet: %s\n", nt_errstr(smb_krb5->status)));
talloc_free(smb_krb5);
continue;
}
ret = krb5_data_copy(recv_buf, smb_krb5->reply.data, smb_krb5->reply.length);
if (ret) {
talloc_free(smb_krb5);
return ret;
}
talloc_free(smb_krb5);
break;
}
if (a) {
return 0;
}
return KRB5_KDC_UNREACH;
}
static bool fdpass2_parent(pid_t child_pid, int ready_fd)
{
struct tevent_context *ev = NULL;
struct messaging_context *msg_ctx = NULL;
bool retval = false;
int up_pipe[2];
int down_pipe[2];
int pass_fds[2] = { 0 };
int ret;
NTSTATUS status;
struct server_id dst;
TALLOC_CTX *frame = talloc_stackframe();
uint8_t c1 = 1, c2, c;
ssize_t bytes;
struct iovec iov;
DATA_BLOB blob;
struct tevent_fd *child_done_fde;
struct child_done_state child_state;
ev = samba_tevent_context_init(frame);
if (ev == NULL) {
fprintf(stderr, "parent: tevent_context_init failed\n");
goto done;
}
msg_ctx = messaging_init(ev, ev);
if (msg_ctx == NULL) {
fprintf(stderr, "parent: messaging_init failed\n");
goto done;
}
/* wait util the child is ready to receive messages */
bytes = read(ready_fd, &c, 1);
if (bytes != 1) {
perror("parent: read from ready_fd failed");
goto done;
}
ret = pipe(up_pipe);
if (ret != 0) {
perror("parent: pipe failed for up_pipe");
goto done;
}
ret = pipe(down_pipe);
if (ret != 0) {
perror("parent: pipe failed for down_pipe");
goto done;
}
child_state.fd = ready_fd;
child_state.done = false;
child_done_fde = tevent_add_fd(ev, ev, ready_fd, TEVENT_FD_READ,
child_done_cb, &child_state);
if (child_done_fde == NULL) {
fprintf(stderr,
"parent: failed tevent_add_fd for child done\n");
goto done;
}
pass_fds[0] = up_pipe[0];
pass_fds[1] = down_pipe[1];
dst = messaging_server_id(msg_ctx);
dst.pid = child_pid;
/*
* Send a certain payload with the fds, to test to test
* that fd-passing works when we have fragmentation and
* re-assembly of the datagrams.
*/
blob = data_blob_talloc_zero(frame, 1000*1000);
iov.iov_base = blob.data;
iov.iov_len = blob.length;
status = messaging_send_iov(msg_ctx, dst, MSG_TORTURE_FDPASS2, &iov, 1,
pass_fds, 2);
if (!NT_STATUS_IS_OK(status)) {
fprintf(stderr, "parent: messaging_send_iov failed: %s\n",
nt_errstr(status));
goto done;
}
printf("parent: waiting for child to confirm\n");
while (!child_state.done) {
ret = tevent_loop_once(ev);
if (ret != 0) {
fprintf(stderr, "parent: tevent_loop_once failed\n");
goto done;
}
}
printf("parent: child confirmed\n");
close(up_pipe[0]);
close(down_pipe[1]);
bytes = write(up_pipe[1], &c1, 1);
if (bytes != 1) {
perror("parent: write to up pipe failed");
goto done;
}
bytes = read(down_pipe[0], &c2, 1);
if (bytes != 1) {
perror("parent: read from down pipe failed");
goto done;
}
if (c1 != c2) {
fprintf(stderr, "parent: c1[%d] != c2[%d]\n", c1, c2);
goto done;
}
ret = waitpid(child_pid, NULL, 0);
if (ret == -1) {
perror("parent: waitpid failed");
goto done;
}
retval = true;
done:
TALLOC_FREE(frame);
return retval;
}
static bool test_messaging_overflow(struct torture_context *tctx)
{
struct imessaging_context *msg_ctx;
ssize_t nwritten, nread;
pid_t child;
char c = 0;
int up_pipe[2], down_pipe[2];
int i, ret, child_status;
ret = pipe(up_pipe);
torture_assert(tctx, ret == 0, "pipe failed");
ret = pipe(down_pipe);
torture_assert(tctx, ret == 0, "pipe failed");
child = fork();
if (child < 0) {
torture_fail(tctx, "fork failed");
}
if (child == 0) {
ret = tevent_re_initialise(tctx->ev);
torture_assert(tctx, ret == 0, "tevent_re_initialise failed");
msg_ctx = imessaging_init(tctx, tctx->lp_ctx,
cluster_id(getpid(), 0),
tctx->ev);
torture_assert(tctx, msg_ctx != NULL,
"imessaging_init failed");
do {
nwritten = write(up_pipe[1], &c, 1);
} while ((nwritten == -1) && (errno == EINTR));
ret = close(down_pipe[1]);
torture_assert(tctx, ret == 0, "close failed");
do {
nread = read(down_pipe[0], &c, 1);
} while ((nread == -1) && (errno == EINTR));
exit(0);
}
do {
nread = read(up_pipe[0], &c, 1);
} while ((nread == -1) && (errno == EINTR));
msg_ctx = imessaging_init(tctx, tctx->lp_ctx, cluster_id(getpid(), 0),
tctx->ev);
torture_assert(tctx, msg_ctx != NULL, "imessaging_init failed");
for (i=0; i<1000; i++) {
NTSTATUS status;
status = imessaging_send(msg_ctx, cluster_id(child, 0),
MSG_PING, NULL);
torture_assert_ntstatus_ok(tctx, status,
"imessaging_send failed");
}
tevent_loop_once(tctx->ev);
talloc_free(msg_ctx);
ret = close(down_pipe[1]);
torture_assert(tctx, ret == 0, "close failed");
ret = waitpid(child, &child_status, 0);
torture_assert(tctx, ret == child, "wrong child exited");
torture_assert(tctx, child_status == 0, "child failed");
poll(NULL, 0, 500);
return true;
}
