/** 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); }
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; }
static void * mongoc_sasl_mutex_alloc (void) { mongoc_mutex_t *mutex; mutex = (mongoc_mutex_t *)bson_malloc0 (sizeof (mongoc_mutex_t)); mongoc_mutex_init (mutex); return (void *) mutex; }
mongoc_client_pool_t * mongoc_client_pool_new (const mongoc_uri_t *uri) { mongoc_topology_t *topology; mongoc_client_pool_t *pool; const bson_t *b; bson_iter_t iter; ENTRY; BSON_ASSERT (uri); #ifndef MONGOC_ENABLE_SSL if (mongoc_uri_get_ssl (uri)) { MONGOC_ERROR ("Can't create SSL client pool," " SSL not enabled in this build."); return NULL; } #endif pool = (mongoc_client_pool_t *)bson_malloc0(sizeof *pool); mongoc_mutex_init(&pool->mutex); _mongoc_queue_init(&pool->queue); pool->uri = mongoc_uri_copy(uri); pool->min_pool_size = 0; pool->max_pool_size = 100; pool->size = 0; pool->topology_scanner_started = false; topology = mongoc_topology_new(uri, false); pool->topology = topology; mongoc_client_metadata_init (&pool->topology->scanner->ismaster_metadata); pool->error_api_version = MONGOC_ERROR_API_VERSION_LEGACY; b = mongoc_uri_get_options(pool->uri); if (bson_iter_init_find_case(&iter, b, "minpoolsize")) { if (BSON_ITER_HOLDS_INT32(&iter)) { pool->min_pool_size = BSON_MAX(0, bson_iter_int32(&iter)); } } if (bson_iter_init_find_case(&iter, b, "maxpoolsize")) { if (BSON_ITER_HOLDS_INT32(&iter)) { pool->max_pool_size = BSON_MAX(1, bson_iter_int32(&iter)); } } mongoc_counter_client_pools_active_inc(); RETURN(pool); }
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; }
static void _mongoc_ssl_thread_startup (void) { int i; gMongocSslThreadLocks = OPENSSL_malloc (CRYPTO_num_locks () * sizeof (mongoc_mutex_t)); for (i = 0; i < CRYPTO_num_locks (); i++) { mongoc_mutex_init(&gMongocSslThreadLocks[i]); } CRYPTO_set_locking_callback (_mongoc_ssl_thread_locking_callback); CRYPTO_set_id_callback (_mongoc_ssl_thread_id_callback); }
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); }
mongoc_client_pool_t * mongoc_client_pool_new (const mongoc_uri_t *uri) { mongoc_topology_t *topology; mongoc_client_pool_t *pool; const bson_t *b; bson_iter_t iter; ENTRY; BSON_ASSERT (uri); pool = (mongoc_client_pool_t *)bson_malloc0(sizeof *pool); mongoc_mutex_init(&pool->mutex); _mongoc_queue_init(&pool->queue); pool->uri = mongoc_uri_copy(uri); pool->min_pool_size = 0; pool->max_pool_size = 100; pool->size = 0; topology = mongoc_topology_new(uri, false); pool->topology = topology; b = mongoc_uri_get_options(pool->uri); if (bson_iter_init_find_case(&iter, b, "minpoolsize")) { if (BSON_ITER_HOLDS_INT32(&iter)) { pool->min_pool_size = BSON_MAX(0, bson_iter_int32(&iter)); } } if (bson_iter_init_find_case(&iter, b, "maxpoolsize")) { if (BSON_ITER_HOLDS_INT32(&iter)) { pool->max_pool_size = BSON_MAX(1, bson_iter_int32(&iter)); } } mongoc_counter_client_pools_active_inc(); RETURN(pool); }
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); }
static MONGOC_ONCE_FUN( _mongoc_ensure_mutex_once) { mongoc_mutex_init(&gLogMutex); MONGOC_ONCE_RETURN; }