mock_server_t *
mock_server_new (const char *address,
uint16_t port,
mock_server_handler_t handler,
void *handler_data)
{
mock_server_t *server;
if (!address) {
address = "127.0.0.1";
}
if (!port) {
port = 27017;
}
server = bson_malloc0(sizeof *server);
server->handler = handler ? handler : dummy_handler;
server->handler_data = handler_data;
server->sock = NULL;
server->address = address;
server->port = port;
server->minWireVersion = 0;
server->maxWireVersion = 0;
server->isMaster = true;
server->maxBsonObjectSize = 16777216;
server->maxMessageSizeBytes = 48000000;
mongoc_mutex_init (&server->mutex);
mongoc_cond_init (&server->cond);
return server;
}
/** This is the testing function for the ssl-test lib
*
* The basic idea is that you spin up a client and server, which will
* communicate over a mongoc-stream-tls, with varying mongoc_ssl_opt's. The
* client and server speak a simple echo protocol, so all we're really testing
* here is that any given configuration succeeds or fails as it should
*/
void
ssl_test (mongoc_ssl_opt_t *client,
mongoc_ssl_opt_t *server,
const char *host,
ssl_test_result_t *client_result,
ssl_test_result_t *server_result)
{
ssl_test_data_t data = {0};
mongoc_thread_t threads[2];
int i, r;
data.server = server;
data.client = client;
data.client_result = client_result;
data.server_result = server_result;
data.host = host;
mongoc_mutex_init (&data.cond_mutex);
mongoc_cond_init (&data.cond);
r = mongoc_thread_create (threads, &ssl_test_server, &data);
BSON_ASSERT (r == 0);
r = mongoc_thread_create (threads + 1, &ssl_test_client, &data);
BSON_ASSERT (r == 0);
for (i = 0; i < 2; i++) {
r = mongoc_thread_join (threads[i]);
BSON_ASSERT (r == 0);
}
mongoc_mutex_destroy (&data.cond_mutex);
mongoc_cond_destroy (&data.cond);
}
future_t *
future_new (future_value_type_t return_type, int argc)
{
future_t *future;
future = (future_t *)bson_malloc0 (sizeof *future);
future->return_value.type = return_type;
future->argc = argc;
future->argv = (future_value_t *)bson_malloc0 ((size_t) argc * sizeof(future_value_t));
mongoc_cond_init (&future->cond);
mongoc_mutex_init (&future->mutex);
return future;
}
mock_server_t *
mock_server_new ()
{
mock_server_t *server = (mock_server_t *)bson_malloc0 (sizeof (mock_server_t));
server->request_timeout_msec = get_future_timeout_ms ();
_mongoc_array_init (&server->autoresponders,
sizeof (autoresponder_handle_t));
_mongoc_array_init (&server->worker_threads,
sizeof (mongoc_thread_t));
mongoc_cond_init (&server->cond);
mongoc_mutex_init (&server->mutex);
server->q = q_new ();
server->start_time = bson_get_monotonic_time ();
return server;
}
static void
test_mongoc_tls_handshake_stall (void)
{
mongoc_ssl_opt_t sopt = { 0 };
mongoc_ssl_opt_t copt = { 0 };
ssl_test_result_t sr;
ssl_test_result_t cr;
ssl_test_data_t data = { 0 };
mongoc_thread_t threads[2];
int i, r;
sopt.pem_file = PEMFILE_NOPASS;
sopt.weak_cert_validation = 1;
copt.weak_cert_validation = 1;
data.server = &sopt;
data.client = &copt;
data.behavior = SSL_TEST_BEHAVIOR_STALL_BEFORE_HANDSHAKE;
data.handshake_stall_ms = 300;
data.server_result = &sr;
data.client_result = &cr;
data.host = "localhost";
mongoc_mutex_init (&data.cond_mutex);
mongoc_cond_init (&data.cond);
r = mongoc_thread_create (threads, &ssl_error_server, &data);
assert (r == 0);
r = mongoc_thread_create (threads + 1, &handshake_stall_client, &data);
assert (r == 0);
for (i = 0; i < 2; i++) {
r = mongoc_thread_join (threads[i]);
assert (r == 0);
}
mongoc_mutex_destroy (&data.cond_mutex);
mongoc_cond_destroy (&data.cond);
ASSERT (cr.result == SSL_TEST_SUCCESS);
ASSERT (sr.result == SSL_TEST_SUCCESS);
}
mock_server_t *
mock_server_new ()
{
mock_server_t *server = (mock_server_t *)bson_malloc0 (sizeof (mock_server_t));
server->request_timeout_msec = 10 * 1000;
_mongoc_array_init (&server->autoresponders,
sizeof (autoresponder_handle_t));
_mongoc_array_init (&server->worker_threads,
sizeof (mongoc_thread_t));
mongoc_cond_init (&server->cond);
mongoc_mutex_init (&server->mutex);
server->q = q_new ();
server->start_time = bson_get_monotonic_time ();
if (test_framework_getenv_bool ("MONGOC_TEST_SERVER_VERBOSE")) {
server->verbose = true;
}
return server;
}
static void
test_cond_wait (void)
{
int64_t start, duration_usec;
mongoc_mutex_t mutex;
mongoc_cond_t cond;
mongoc_mutex_init (&mutex);
mongoc_cond_init (&cond);
mongoc_mutex_lock (&mutex);
start = bson_get_monotonic_time ();
mongoc_cond_timedwait (&cond, &mutex, 100);
duration_usec = bson_get_monotonic_time () - start;
mongoc_mutex_unlock (&mutex);
if (!((50 * 1000 < duration_usec) && (150 * 1000 > duration_usec))) {
fprintf (
stderr, "expected to wait 100ms, waited %" PRId64 "\n", duration_usec);
}
mongoc_cond_destroy (&cond);
mongoc_mutex_destroy (&mutex);
}
static void
test_mongoc_socket_sendv (void)
{
socket_test_data_t data = { 0 };
mongoc_thread_t threads[2];
int i, r;
mongoc_mutex_init (&data.cond_mutex);
mongoc_cond_init (&data.cond);
r = mongoc_thread_create (threads, &sendv_test_server, &data);
assert (r == 0);
r = mongoc_thread_create (threads + 1, &sendv_test_client, &data);
assert (r == 0);
for (i = 0; i < 2; i++) {
r = mongoc_thread_join (threads[i]);
assert (r == 0);
}
mongoc_mutex_destroy (&data.cond_mutex);
mongoc_cond_destroy (&data.cond);
}
