/** 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);
}
void
mongoc_client_pool_destroy (mongoc_client_pool_t *pool)
{
mongoc_client_t *client;
ENTRY;
BSON_ASSERT (pool);
while ((client = (mongoc_client_t *)_mongoc_queue_pop_head(&pool->queue))) {
mongoc_client_destroy(client);
}
mongoc_topology_destroy (pool->topology);
mongoc_uri_destroy(pool->uri);
mongoc_mutex_destroy(&pool->mutex);
mongoc_cond_destroy(&pool->cond);
bson_free(pool);
mongoc_counter_client_pools_active_dec();
mongoc_counter_client_pools_disposed_inc();
EXIT;
}
void
mongoc_client_pool_destroy (mongoc_client_pool_t *pool)
{
mongoc_client_t *client;
ENTRY;
BSON_ASSERT (pool);
while ((client = (mongoc_client_t *)_mongoc_queue_pop_head(&pool->queue))) {
mongoc_client_destroy(client);
}
mongoc_topology_destroy (pool->topology);
mongoc_uri_destroy(pool->uri);
mongoc_mutex_destroy(&pool->mutex);
mongoc_cond_destroy(&pool->cond);
#ifdef MONGOC_ENABLE_SSL
_mongoc_ssl_opts_cleanup (&pool->ssl_opts);
#endif
bson_free(pool);
mongoc_counter_client_pools_active_dec();
mongoc_counter_client_pools_disposed_inc();
EXIT;
}
void
mock_server_destroy (mock_server_t *server)
{
if (server) {
mongoc_cond_destroy (&server->cond);
mongoc_mutex_destroy (&server->mutex);
bson_free(server);
}
}
void
future_destroy (future_t *future)
{
assert (future->awaited);
bson_free (future->argv);
mongoc_cond_destroy (&future->cond);
mongoc_mutex_destroy (&future->mutex);
bson_free (future);
}
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);
}
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);
}
void
mock_server_destroy (mock_server_t *server)
{
size_t i;
autoresponder_handle_t *handle;
int64_t deadline = bson_get_monotonic_time () + 10 * 1000 * 1000;
request_t *request;
mongoc_mutex_lock (&server->mutex);
if (server->running) {
server->stopped = true;
}
mongoc_mutex_unlock (&server->mutex);
while (bson_get_monotonic_time () <= deadline) {
/* wait 10 seconds */
mongoc_mutex_lock (&server->mutex);
if (!server->running) {
mongoc_mutex_unlock (&server->mutex);
break;
}
mongoc_mutex_unlock (&server->mutex);
_mongoc_usleep (1000);
}
mongoc_mutex_lock (&server->mutex);
if (server->running) {
fprintf (stderr, "server still running after timeout\n");
fflush (stderr);
abort ();
}
mongoc_mutex_unlock (&server->mutex);
mongoc_thread_join (server->main_thread);
_mongoc_array_destroy (&server->worker_threads);
for (i = 0; i < server->autoresponders.len; i++) {
handle = &_mongoc_array_index (&server->autoresponders,
autoresponder_handle_t,
i);
autoresponder_handle_destroy (handle);
}
_mongoc_array_destroy (&server->autoresponders);
mongoc_cond_destroy (&server->cond);
mongoc_mutex_unlock (&server->mutex);
mongoc_mutex_destroy (&server->mutex);
mongoc_socket_destroy (server->sock);
bson_free (server->uri_str);
mongoc_uri_destroy (server->uri);
while ((request = (request_t *) q_get_nowait (server->q))) {
request_destroy (request);
}
q_destroy (server->q);
bson_free (server);
}