static int
_mongoc_stream_tls_bio_write (BIO *b,
const char *buf,
int len)
{
mongoc_stream_tls_t *tls;
mongoc_iovec_t iov;
int ret;
BSON_ASSERT (b);
BSON_ASSERT (buf);
if (!(tls = b->ptr)) {
return -1;
}
iov.iov_base = (void *)buf;
iov.iov_len = len;
errno = 0;
ret = (int)mongoc_stream_writev (tls->base_stream, &iov, 1,
tls->timeout_msec);
BIO_clear_retry_flags (b);
if ((ret < 0) && MONGOC_ERRNO_IS_AGAIN (errno)) {
BIO_set_retry_write (b);
}
return ret;
}
/** run as a child thread by test_mongoc_tls_hangup
*
* It:
* 1. spins up
* 2. waits on a condvar until the server is up
* 3. connects to the server's port
* 4. writes a byte
* 5. confirms that the server hangs up promptly
* 6. shuts down
*/
static void *
ssl_hangup_client (void *ptr)
{
ssl_test_data_t *data = (ssl_test_data_t *)ptr;
mongoc_stream_t *sock_stream;
mongoc_stream_t *ssl_stream;
mongoc_socket_t *conn_sock;
char buf = 'b';
ssize_t r;
mongoc_iovec_t riov;
mongoc_iovec_t wiov;
struct sockaddr_in server_addr = { 0 };
int64_t start_time;
bson_error_t error;
conn_sock = mongoc_socket_new (AF_INET, SOCK_STREAM, 0);
assert (conn_sock);
mongoc_mutex_lock (&data->cond_mutex);
while (!data->server_port) {
mongoc_cond_wait (&data->cond, &data->cond_mutex);
}
mongoc_mutex_unlock (&data->cond_mutex);
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons (data->server_port);
server_addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
r = mongoc_socket_connect (conn_sock, (struct sockaddr *)&server_addr,
sizeof (server_addr), -1);
assert (r == 0);
sock_stream = mongoc_stream_socket_new (conn_sock);
assert (sock_stream);
ssl_stream = mongoc_stream_tls_new (sock_stream, data->client, 1);
assert (ssl_stream);
r = mongoc_stream_tls_handshake_block (ssl_stream, data->host, TIMEOUT, &error);
assert (r);
wiov.iov_base = (void *)&buf;
wiov.iov_len = 1;
r = mongoc_stream_writev (ssl_stream, &wiov, 1, TIMEOUT);
assert (r == 1);
riov.iov_base = (void *)&buf;
riov.iov_len = 1;
/* we should notice promptly that the server hangs up */
start_time = bson_get_monotonic_time ();
r = mongoc_stream_readv (ssl_stream, &riov, 1, 1, TIMEOUT);
/* time is in microseconds */
assert (bson_get_monotonic_time () - start_time < 1000 * 1000);
assert (r == -1);
mongoc_stream_destroy (ssl_stream);
data->client_result->result = SSL_TEST_SUCCESS;
return NULL;
}
static ssize_t
_mongoc_stream_debug_writev (mongoc_stream_t *stream,
mongoc_iovec_t *iov,
size_t iovcnt,
int32_t timeout_msec)
{
return mongoc_stream_writev (
((mongoc_stream_debug_t *) stream)->wrapped, iov, iovcnt, timeout_msec);
}
bool
_mongoc_stream_writev_full (mongoc_stream_t *stream,
mongoc_iovec_t *iov,
size_t iovcnt,
int32_t timeout_msec,
bson_error_t *error)
{
size_t total_bytes = 0;
int i;
ssize_t r;
ENTRY;
for (i = 0; i < iovcnt; i++) {
total_bytes += iov[i].iov_len;
}
r = mongoc_stream_writev (stream, iov, iovcnt, timeout_msec);
TRACE ("writev returned: %ld", r);
if (r < 0) {
if (error) {
char buf[128];
char *errstr;
errstr = bson_strerror_r (errno, buf, sizeof (buf));
bson_set_error (error,
MONGOC_ERROR_STREAM,
MONGOC_ERROR_STREAM_SOCKET,
"Failure during socket delivery: %s (%d)",
errstr,
errno);
}
RETURN (false);
}
if (r != total_bytes) {
bson_set_error (error,
MONGOC_ERROR_STREAM,
MONGOC_ERROR_STREAM_SOCKET,
"Failure to send all requested bytes (only sent: %" PRIu64
"/%" PRId64 " in %dms) during socket delivery",
(uint64_t) r,
(int64_t) total_bytes,
timeout_msec);
RETURN (false);
}
RETURN (true);
}
/* TODO: merge with mock_server_reply? */
void
mock_server_reply_simple (mock_server_t *server,
mongoc_stream_t *client,
const mongoc_rpc_t *request,
mongoc_reply_flags_t flags,
const bson_t *doc,
int64_t cursor_id)
{
mongoc_iovec_t *iov;
mongoc_array_t ar;
mongoc_rpc_t r = {{ 0 }};
size_t expected = 0;
ssize_t n_written;
int iovcnt;
int i;
BSON_ASSERT (server);
BSON_ASSERT (request);
BSON_ASSERT (client);
BSON_ASSERT (doc);
_mongoc_array_init (&ar, sizeof (mongoc_iovec_t));
mongoc_mutex_lock (&server->mutex);
r.reply.request_id = ++server->last_response_id;
mongoc_mutex_unlock (&server->mutex);
r.reply.msg_len = 0;
r.reply.response_to = request->header.request_id;
r.reply.opcode = MONGOC_OPCODE_REPLY;
r.reply.flags = flags;
r.reply.cursor_id = cursor_id;
r.reply.start_from = 0;
r.reply.n_returned = 1;
r.reply.documents = bson_get_data (doc);
r.reply.documents_len = doc->len;
_mongoc_rpc_gather (&r, &ar);
_mongoc_rpc_swab_to_le (&r);
iov = (mongoc_iovec_t *)ar.data;
iovcnt = (int) ar.len;
for (i = 0; i < iovcnt; i++) {
expected += iov[i].iov_len;
}
n_written = mongoc_stream_writev (client, iov, (size_t) iovcnt, -1);
assert (n_written == expected);
_mongoc_array_destroy (&ar);
}
static ssize_t
mongoc_stream_buffered_writev (mongoc_stream_t *stream, /* IN */
struct iovec *iov, /* IN */
size_t iovcnt, /* IN */
int32_t timeout_msec) /* IN */
{
mongoc_stream_buffered_t *buffered = (mongoc_stream_buffered_t *)stream;
bson_return_val_if_fail(buffered, -1);
return mongoc_stream_writev(buffered->base_stream,
iov,
iovcnt,
timeout_msec);
}
static ssize_t
mongoc_stream_buffered_writev (mongoc_stream_t *stream,
struct iovec *iov,
size_t iovcnt,
bson_uint32_t timeout_msec)
{
mongoc_stream_buffered_t *buffered = (mongoc_stream_buffered_t *)stream;
bson_return_val_if_fail(buffered, -1);
/*
* TODO: Implement buffering.
*/
return mongoc_stream_writev(buffered->base_stream, iov, iovcnt, timeout_msec);
}
int
mongoc_stream_tls_openssl_bio_write (BIO *b,
const char *buf,
int len)
{
mongoc_stream_tls_t *tls;
mongoc_iovec_t iov;
int ret;
ENTRY;
BSON_ASSERT (b);
BSON_ASSERT (buf);
tls = (mongoc_stream_tls_t *)b->ptr;
if (!tls) {
RETURN (-1);
}
iov.iov_base = (void *)buf;
iov.iov_len = len;
errno = 0;
TRACE("mongoc_stream_writev is expected to write: %d", len);
ret = (int)mongoc_stream_writev (tls->base_stream, &iov, 1,
tls->timeout_msec);
BIO_clear_retry_flags (b);
if (len > ret) {
TRACE("Returned short write: %d of %d", ret, len);
} else {
TRACE("Completed the %d", ret);
}
if (ret <= 0 && MONGOC_ERRNO_IS_AGAIN (errno)) {
TRACE("%s", "Requesting a retry");
BIO_set_retry_write (b);
}
RETURN (ret);
}
/**
* mongoc_stream_write:
* @stream: A mongoc_stream_t.
* @buf: A buffer to write.
* @count: The number of bytes to write into @buf.
*
* Simplified access to mongoc_stream_writev(). Creates a single iovec
* with the buffer provided.
*
* Returns: -1 on failure, otherwise the number of bytes write.
*/
ssize_t
mongoc_stream_write (mongoc_stream_t *stream,
void *buf,
size_t count,
int32_t timeout_msec)
{
mongoc_iovec_t iov;
ssize_t ret;
ENTRY;
bson_return_val_if_fail (stream, -1);
bson_return_val_if_fail (buf, -1);
iov.iov_base = buf;
iov.iov_len = count;
BSON_ASSERT (stream->writev);
ret = mongoc_stream_writev (stream, &iov, 1, timeout_msec);
RETURN (ret);
}
static void *
sendv_test_client (void *data_)
{
socket_test_data_t *data = (socket_test_data_t *)data_;
mongoc_socket_t *conn_sock;
ssize_t r;
int i;
int amount = 0;
struct sockaddr_in server_addr = { 0 };
mongoc_stream_t *stream;
mongoc_iovec_t iov;
bool done = false;
char *buf = (char *)bson_malloc (gFourMB);
memset (buf, 'a', (gFourMB)- 1);
buf[gFourMB - 1] = '\0';
iov.iov_base = buf;
iov.iov_len = gFourMB;
conn_sock = mongoc_socket_new (AF_INET, SOCK_STREAM, 0);
assert (conn_sock);
mongoc_mutex_lock(&data->cond_mutex);
while (! data->server_port) {
mongoc_cond_wait(&data->cond, &data->cond_mutex);
}
mongoc_mutex_unlock(&data->cond_mutex);
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(data->server_port);
server_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
r = mongoc_socket_connect (conn_sock, (struct sockaddr *)&server_addr, sizeof(server_addr), -1);
assert (r == 0);
stream = mongoc_stream_socket_new (conn_sock);
for (i = 0; i < 5; i++)
{
r = mongoc_stream_writev (stream, &iov, 1, WAIT);
if (r > 0) {
amount += r;
}
if (r != gFourMB) {
if (MONGOC_ERRNO_IS_AGAIN(conn_sock->errno_)) {
if (!done) {
mongoc_mutex_lock(&data->cond_mutex);
data->amount = amount;
amount = 0;
mongoc_cond_signal(&data->cond);
mongoc_mutex_unlock(&data->cond_mutex);
done = true;
}
} else {
assert (r == gFourMB);
}
}
}
assert(true == done);
mongoc_mutex_lock(&data->cond_mutex);
data->amount = amount;
mongoc_cond_signal(&data->cond);
mongoc_mutex_unlock(&data->cond_mutex);
mongoc_stream_destroy (stream);
return NULL;
}
void
mock_server_reply_multi (request_t *request,
mongoc_reply_flags_t flags,
const bson_t *docs,
int n_docs,
int64_t cursor_id)
{
const mongoc_rpc_t *request_rpc;
mock_server_t *server;
mongoc_stream_t *client;
char *doc_json;
bson_string_t *docs_json;
mongoc_iovec_t *iov;
mongoc_array_t ar;
mongoc_rpc_t r = {{ 0 }};
size_t expected = 0;
ssize_t n_written;
int iovcnt;
int i;
uint8_t *buf;
uint8_t *ptr;
size_t len;
BSON_ASSERT (request);
BSON_ASSERT (docs);
request_rpc = &request->request_rpc;
server = request->server;
client = request->client;
docs_json = bson_string_new ("");
for (i = 0; i < n_docs; i++) {
doc_json = bson_as_json (&docs[i], NULL);
bson_string_append (docs_json, doc_json);
bson_free (doc_json);
if (i < n_docs - 1) {
bson_string_append (docs_json, ", ");
}
}
if (mock_server_get_verbose (request->server)) {
printf ("%5.2f %hu <- %hu \t%s\n",
mock_server_get_uptime_sec (request->server),
request->client_port,
mock_server_get_port (request->server),
docs_json->str);
fflush (stdout);
}
len = 0;
for (i = 0; i < n_docs; i++) {
len += docs[i].len;
}
ptr = buf = bson_malloc (len);
for (i = 0; i < n_docs; i++) {
memcpy (ptr, bson_get_data (&docs[i]), docs[i].len);
ptr += docs[i].len;
}
_mongoc_array_init (&ar, sizeof (mongoc_iovec_t));
if (!(request->opcode == MONGOC_OPCODE_QUERY &&
request_rpc->query.flags & MONGOC_QUERY_EXHAUST)) {
server->last_response_id++;
}
mongoc_mutex_lock (&server->mutex);
r.reply.request_id = server->last_response_id;
mongoc_mutex_unlock (&server->mutex);
r.reply.msg_len = 0;
r.reply.response_to = request_rpc->header.request_id;
r.reply.opcode = MONGOC_OPCODE_REPLY;
r.reply.flags = flags;
r.reply.cursor_id = cursor_id;
r.reply.start_from = 0;
r.reply.n_returned = 1;
r.reply.documents = buf;
r.reply.documents_len = (uint32_t)len;
_mongoc_rpc_gather (&r, &ar);
_mongoc_rpc_swab_to_le (&r);
iov = (mongoc_iovec_t *)ar.data;
iovcnt = (int) ar.len;
for (i = 0; i < iovcnt; i++) {
expected += iov[i].iov_len;
}
n_written = mongoc_stream_writev (client, iov, (size_t) iovcnt, -1);
assert (n_written == expected);
bson_string_free (docs_json, true);
_mongoc_array_destroy (&ar);
bson_free (buf);
}
/** this function is meant to be run from ssl_test as a child thread
*
* It:
* 1. spins up
* 2. binds and listens to a random port
* 3. notifies the client of it's port through a condvar
* 4. accepts a request
* 5. reads a 32 bit length
* 6. reads a string of that length
* 7. echos it back to the client
* 8. shuts down
*/
static void *
ssl_test_server (void * ptr)
{
ssl_test_data_t *data = (ssl_test_data_t *)ptr;
mongoc_stream_t *sock_stream;
mongoc_stream_t *ssl_stream;
mongoc_socket_t *listen_sock;
mongoc_socket_t *conn_sock;
socklen_t sock_len;
char buf[1024];
ssize_t r;
mongoc_iovec_t iov;
struct sockaddr_in server_addr = { 0 };
int len;
iov.iov_base = buf;
iov.iov_len = sizeof buf;
listen_sock = mongoc_socket_new (AF_INET, SOCK_STREAM, 0);
assert (listen_sock);
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl (INADDR_ANY);
server_addr.sin_port = htons (0);
r = mongoc_socket_bind (listen_sock,
(struct sockaddr *)&server_addr,
sizeof server_addr);
assert (r == 0);
sock_len = sizeof(server_addr);
r = mongoc_socket_getsockname (listen_sock, (struct sockaddr *)&server_addr, &sock_len);
assert(r == 0);
r = mongoc_socket_listen (listen_sock, 10);
assert(r == 0);
mongoc_mutex_lock(&data->cond_mutex);
data->server_port = ntohs(server_addr.sin_port);
mongoc_cond_signal(&data->cond);
mongoc_mutex_unlock(&data->cond_mutex);
conn_sock = mongoc_socket_accept (listen_sock, -1);
assert (conn_sock);
sock_stream = mongoc_stream_socket_new (conn_sock);
assert (sock_stream);
ssl_stream = mongoc_stream_tls_new(sock_stream, data->server, 0);
if (!ssl_stream) {
unsigned long err = ERR_get_error();
assert(err);
data->server_result->ssl_err = err;
data->server_result->result = SSL_TEST_SSL_INIT;
mongoc_stream_destroy (sock_stream);
mongoc_socket_destroy (listen_sock);
return NULL;
}
assert(ssl_stream);
r = mongoc_stream_tls_do_handshake (ssl_stream, TIMEOUT);
if (!r) {
unsigned long err = ERR_get_error();
assert(err);
data->server_result->ssl_err = err;
data->server_result->result = SSL_TEST_SSL_HANDSHAKE;
mongoc_socket_destroy (listen_sock);
mongoc_stream_destroy(ssl_stream);
return NULL;
}
r = mongoc_stream_readv(ssl_stream, &iov, 1, 4, TIMEOUT);
if (r < 0) {
#ifdef _WIN32
assert(errno == WSAETIMEDOUT);
#else
assert(errno == ETIMEDOUT);
#endif
data->server_result->err = errno;
data->server_result->result = SSL_TEST_TIMEOUT;
mongoc_stream_destroy(ssl_stream);
mongoc_socket_destroy (listen_sock);
return NULL;
}
assert(r == 4);
memcpy(&len, iov.iov_base, r);
r = mongoc_stream_readv(ssl_stream, &iov, 1, len, TIMEOUT);
assert(r == len);
iov.iov_len = r;
mongoc_stream_writev(ssl_stream, &iov, 1, TIMEOUT);
mongoc_stream_destroy(ssl_stream);
mongoc_socket_destroy (listen_sock);
data->server_result->result = SSL_TEST_SUCCESS;
return NULL;
}
/** this function is meant to be run from ssl_test as a child thread
*
* It:
* 1. spins up
* 2. waits on a condvar until the server is up
* 3. connects to the servers port
* 4. writes a 4 bytes length
* 5. writes a string of length size
* 6. reads a response back of the given length
* 7. confirms that its the same as what was written
* 8. shuts down
*/
static void *
ssl_test_client (void * ptr)
{
ssl_test_data_t *data = (ssl_test_data_t *)ptr;
mongoc_stream_t *sock_stream;
mongoc_stream_t *ssl_stream;
mongoc_socket_t *conn_sock;
char buf[1024];
ssize_t r;
mongoc_iovec_t riov;
mongoc_iovec_t wiov;
struct sockaddr_in server_addr = { 0 };
int len;
riov.iov_base = buf;
riov.iov_len = sizeof buf;
conn_sock = mongoc_socket_new (AF_INET, SOCK_STREAM, 0);
assert (conn_sock);
mongoc_mutex_lock(&data->cond_mutex);
while (! data->server_port) {
mongoc_cond_wait(&data->cond, &data->cond_mutex);
}
mongoc_mutex_unlock(&data->cond_mutex);
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(data->server_port);
r = inet_pton(AF_INET, LOCALHOST, &server_addr.sin_addr);
assert (r > 0);
r = mongoc_socket_connect (conn_sock, (struct sockaddr *)&server_addr, sizeof(server_addr), -1);
assert (r == 0);
sock_stream = mongoc_stream_socket_new (conn_sock);
assert(sock_stream);
ssl_stream = mongoc_stream_tls_new(sock_stream, data->client, 1);
if (! ssl_stream) {
unsigned long err = ERR_get_error();
assert(err);
data->client_result->ssl_err = err;
data->client_result->result = SSL_TEST_SSL_INIT;
mongoc_stream_destroy(sock_stream);
return NULL;
}
assert(ssl_stream);
errno = 0;
r = mongoc_stream_tls_do_handshake (ssl_stream, TIMEOUT);
if (! r) {
unsigned long err = ERR_get_error();
assert(err || errno);
if (err) {
data->client_result->ssl_err = err;
} else {
data->client_result->err = errno;
}
data->client_result->result = SSL_TEST_SSL_HANDSHAKE;
mongoc_stream_destroy(ssl_stream);
return NULL;
}
r = mongoc_stream_tls_check_cert (ssl_stream, data->host);
if (! r) {
data->client_result->result = SSL_TEST_SSL_VERIFY;
mongoc_stream_destroy(ssl_stream);
return NULL;
}
len = 4;
wiov.iov_base = (void *)&len;
wiov.iov_len = 4;
r = mongoc_stream_writev(ssl_stream, &wiov, 1, TIMEOUT);
assert(r == wiov.iov_len);
wiov.iov_base = "foo";
wiov.iov_len = 4;
r = mongoc_stream_writev(ssl_stream, &wiov, 1, TIMEOUT);
assert(r == wiov.iov_len);
r = mongoc_stream_readv(ssl_stream, &riov, 1, 4, TIMEOUT);
assert(r > 0);
assert(r == wiov.iov_len);
assert(strcmp(riov.iov_base, wiov.iov_base) == 0);
mongoc_stream_destroy(ssl_stream);
data->client_result->result = SSL_TEST_SUCCESS;
return NULL;
}
static void *
socket_test_client (void *data_)
{
socket_test_data_t *data = (socket_test_data_t *)data_;
mongoc_socket_t *conn_sock;
char buf[5];
ssize_t r;
bool closed;
struct sockaddr_in server_addr = { 0 };
mongoc_stream_t *stream;
mongoc_iovec_t iov;
iov.iov_base = buf;
iov.iov_len = sizeof (buf);
conn_sock = mongoc_socket_new (AF_INET, SOCK_STREAM, 0);
assert (conn_sock);
mongoc_mutex_lock(&data->cond_mutex);
while (! data->server_port) {
mongoc_cond_wait(&data->cond, &data->cond_mutex);
}
mongoc_mutex_unlock(&data->cond_mutex);
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(data->server_port);
server_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
r = mongoc_socket_connect (conn_sock, (struct sockaddr *)&server_addr, sizeof(server_addr), -1);
assert (r == 0);
stream = mongoc_stream_socket_new (conn_sock);
strcpy (buf, "ping");
closed = mongoc_stream_check_closed (stream);
assert (closed == false);
r = mongoc_stream_writev (stream, &iov, 1, TIMEOUT);
assert (r == 5);
closed = mongoc_stream_check_closed (stream);
assert (closed == false);
r = mongoc_stream_readv (stream, &iov, 1, 5, TIMEOUT);
assert (r == 5);
assert (strcmp (buf, "pong") == 0);
mongoc_mutex_lock(&data->cond_mutex);
while (! data->closed_socket) {
mongoc_cond_wait(&data->cond, &data->cond_mutex);
}
mongoc_mutex_unlock(&data->cond_mutex);
closed = mongoc_stream_check_closed (stream);
assert (closed == true);
mongoc_stream_destroy (stream);
return NULL;
}
mongoc_async_cmd_result_t
_mongoc_async_cmd_phase_send (mongoc_async_cmd_t *acmd)
{
size_t total_bytes = 0;
size_t offset;
ssize_t bytes;
int i;
/* if a continued write, then iovec will be set to a temporary copy */
bool used_temp_iovec = false;
mongoc_iovec_t *iovec = acmd->iovec;
size_t niovec = acmd->niovec;
for (i = 0; i < acmd->niovec; i++) {
total_bytes += acmd->iovec[i].iov_len;
}
if (acmd->bytes_written > 0) {
BSON_ASSERT (acmd->bytes_written < total_bytes);
/* if bytes have been written before, compute the offset in the next
* iovec entry to be written. */
offset = acmd->bytes_written;
/* subtract the lengths of all iovec entries written so far. */
for (i = 0; i < acmd->niovec; i++) {
if (offset < acmd->iovec[i].iov_len) {
break;
}
offset -= acmd->iovec[i].iov_len;
}
BSON_ASSERT (i < acmd->niovec);
/* create a new iovec with the remaining data to be written. */
niovec = acmd->niovec - i;
iovec = bson_malloc (niovec * sizeof (mongoc_iovec_t));
memcpy (iovec, acmd->iovec + i, niovec * sizeof (mongoc_iovec_t));
iovec[0].iov_base = (char *) iovec[0].iov_base + offset;
iovec[0].iov_len -= offset;
used_temp_iovec = true;
}
bytes = mongoc_stream_writev (acmd->stream, iovec, niovec, 0);
if (used_temp_iovec) {
bson_free (iovec);
}
if (bytes <= 0 && mongoc_stream_should_retry (acmd->stream)) {
return MONGOC_ASYNC_CMD_IN_PROGRESS;
}
if (bytes < 0) {
bson_set_error (&acmd->error,
MONGOC_ERROR_STREAM,
MONGOC_ERROR_STREAM_SOCKET,
"Failed to write rpc bytes.");
return MONGOC_ASYNC_CMD_ERROR;
}
acmd->bytes_written += bytes;
if (acmd->bytes_written < total_bytes) {
return MONGOC_ASYNC_CMD_IN_PROGRESS;
}
acmd->state = MONGOC_ASYNC_CMD_RECV_LEN;
acmd->bytes_to_read = 4;
acmd->events = POLLIN;
acmd->cmd_started = bson_get_monotonic_time ();
return MONGOC_ASYNC_CMD_IN_PROGRESS;
}
/** this function is meant to be run from ssl_test as a child thread
*
* It:
* 1. spins up
* 2. waits on a condvar until the server is up
* 3. connects to the server's port
* 4. writes a 4 bytes length
* 5. writes a string of length size
* 6. reads a response back of the given length
* 7. confirms that its the same as what was written
* 8. shuts down
*/
static void *
ssl_test_client (void *ptr)
{
ssl_test_data_t *data = (ssl_test_data_t *) ptr;
mongoc_stream_t *sock_stream;
mongoc_stream_t *ssl_stream;
mongoc_socket_t *conn_sock;
int i;
char buf[1024];
ssize_t r;
mongoc_iovec_t riov;
mongoc_iovec_t wiov;
mongoc_iovec_t wiov_many[NUM_IOVECS];
struct sockaddr_in server_addr = {0};
int len;
bson_error_t error;
riov.iov_base = buf;
riov.iov_len = sizeof buf;
conn_sock = mongoc_socket_new (AF_INET, SOCK_STREAM, 0);
BSON_ASSERT (conn_sock);
mongoc_mutex_lock (&data->cond_mutex);
while (!data->server_port) {
mongoc_cond_wait (&data->cond, &data->cond_mutex);
}
mongoc_mutex_unlock (&data->cond_mutex);
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons (data->server_port);
server_addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
r = mongoc_socket_connect (
conn_sock, (struct sockaddr *) &server_addr, sizeof (server_addr), -1);
if (r != 0) {
fprintf (stderr,
"mongoc_socket_connect returned %zd: \"%s\"",
r,
strerror (errno));
abort ();
}
sock_stream = mongoc_stream_socket_new (conn_sock);
BSON_ASSERT (sock_stream);
ssl_stream = mongoc_stream_tls_new_with_hostname (
sock_stream, data->host, data->client, 1);
if (!ssl_stream) {
#ifdef MONGOC_ENABLE_SSL_OPENSSL
unsigned long err = ERR_get_error ();
#else
unsigned long err = 44;
#endif
BSON_ASSERT (err);
data->client_result->ssl_err = err;
data->client_result->result = SSL_TEST_SSL_INIT;
MONGOC_ERROR ("ERRORED (line: %d): %s\n",
__LINE__,
"mongoc_stream_tls_new_with_hostname failed.");
mongoc_stream_destroy (sock_stream);
return NULL;
}
BSON_ASSERT (ssl_stream);
r = mongoc_stream_tls_handshake_block (
ssl_stream, data->host, TIMEOUT, &error);
if (!r) {
unsigned long err = 45;
data->client_result->ssl_err = err;
data->client_result->result = SSL_TEST_SSL_HANDSHAKE;
MONGOC_ERROR ("ERRORED (line: %d): %s\n", __LINE__, error.message);
mongoc_stream_destroy (ssl_stream);
return NULL;
}
len = 4 * NUM_IOVECS;
wiov.iov_base = (void *) &len;
wiov.iov_len = 4;
r = mongoc_stream_writev (ssl_stream, &wiov, 1, TIMEOUT);
BSON_ASSERT (r == wiov.iov_len);
for (i = 0; i < NUM_IOVECS; i++) {
wiov_many[i].iov_base = (void *) "foo";
wiov_many[i].iov_len = 4;
}
r = mongoc_stream_writev (ssl_stream, wiov_many, NUM_IOVECS, TIMEOUT);
BSON_ASSERT (r == wiov_many[0].iov_len * NUM_IOVECS);
riov.iov_len = 1;
r = mongoc_stream_readv (ssl_stream, &riov, 1, 1, TIMEOUT);
BSON_ASSERT (r == 1);
BSON_ASSERT (memcmp (riov.iov_base, "f", 1) == 0);
riov.iov_len = 3;
r = mongoc_stream_readv (ssl_stream, &riov, 1, 3, TIMEOUT);
BSON_ASSERT (r == 3);
BSON_ASSERT (memcmp (riov.iov_base, "oo", 3) == 0);
mongoc_stream_destroy (ssl_stream);
data->client_result->result = SSL_TEST_SUCCESS;
return NULL;
}
/** this function is meant to be run from ssl_test as a child thread
*
* It:
* 1. spins up
* 2. waits on a condvar until the server is up
* 3. connects to the servers port
* 4. writes a 4 bytes length
* 5. writes a string of length size
* 6. reads a response back of the given length
* 7. confirms that its the same as what was written
* 8. shuts down
*/
static void *
ssl_test_client (void * ptr)
{
ssl_test_data_t *data = (ssl_test_data_t *)ptr;
mongoc_stream_t *sock_stream;
mongoc_stream_t *ssl_stream;
mongoc_socket_t *conn_sock;
int i;
int errno_captured;
char buf[1024];
ssize_t r;
mongoc_iovec_t riov;
mongoc_iovec_t wiov;
mongoc_iovec_t wiov_many[NUM_IOVECS];
struct sockaddr_in server_addr = { 0 };
int len;
riov.iov_base = buf;
riov.iov_len = sizeof buf;
conn_sock = mongoc_socket_new (AF_INET, SOCK_STREAM, 0);
assert (conn_sock);
mongoc_mutex_lock(&data->cond_mutex);
while (! data->server_port) {
mongoc_cond_wait(&data->cond, &data->cond_mutex);
}
mongoc_mutex_unlock(&data->cond_mutex);
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(data->server_port);
server_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
r = mongoc_socket_connect (conn_sock, (struct sockaddr *)&server_addr, sizeof(server_addr), -1);
assert (r == 0);
sock_stream = mongoc_stream_socket_new (conn_sock);
assert(sock_stream);
ssl_stream = mongoc_stream_tls_new(sock_stream, data->client, 1);
if (! ssl_stream) {
unsigned long err = ERR_get_error();
assert(err);
data->client_result->ssl_err = err;
data->client_result->result = SSL_TEST_SSL_INIT;
mongoc_stream_destroy(sock_stream);
return NULL;
}
assert(ssl_stream);
errno = 0;
r = mongoc_stream_tls_do_handshake (ssl_stream, TIMEOUT);
errno_captured = errno;
if (! r) {
unsigned long err = ERR_get_error();
assert(err || errno_captured);
if (err) {
data->client_result->ssl_err = err;
} else {
data->client_result->err = errno_captured;
}
data->client_result->result = SSL_TEST_SSL_HANDSHAKE;
mongoc_stream_destroy(ssl_stream);
return NULL;
}
r = mongoc_stream_tls_check_cert (ssl_stream, data->host);
if (! r) {
data->client_result->result = SSL_TEST_SSL_VERIFY;
mongoc_stream_destroy(ssl_stream);
return NULL;
}
len = 4 * NUM_IOVECS;
wiov.iov_base = (void *)&len;
wiov.iov_len = 4;
r = mongoc_stream_writev(ssl_stream, &wiov, 1, TIMEOUT);
assert(r == wiov.iov_len);
for (i = 0; i < NUM_IOVECS; i++) {
wiov_many[i].iov_base = "foo";
wiov_many[i].iov_len = 4;
}
r = mongoc_stream_writev(ssl_stream, wiov_many, NUM_IOVECS, TIMEOUT);
assert(r == wiov_many[0].iov_len * NUM_IOVECS);
riov.iov_len = 1;
r = mongoc_stream_readv(ssl_stream, &riov, 1, 1, TIMEOUT);
assert(r == 1);
assert(memcmp(riov.iov_base, "f", 1) == 0);
riov.iov_len = 3;
r = mongoc_stream_readv(ssl_stream, &riov, 1, 3, TIMEOUT);
assert(r == 3);
assert(memcmp(riov.iov_base, "oo", 3) == 0);
mongoc_stream_destroy(ssl_stream);
data->client_result->result = SSL_TEST_SUCCESS;
return NULL;
}
/** this function is meant to be run from ssl_test as a child thread
*
* It:
* 1. spins up
* 2. binds and listens to a random port
* 3. notifies the client of its port through a condvar
* 4. accepts a request
* 5. reads a 32 bit length
* 6. reads a string of that length
* 7. echoes it back to the client
* 8. shuts down
*/
static void *
ssl_test_server (void *ptr)
{
ssl_test_data_t *data = (ssl_test_data_t *) ptr;
mongoc_stream_t *sock_stream;
mongoc_stream_t *ssl_stream;
mongoc_socket_t *listen_sock;
mongoc_socket_t *conn_sock;
mongoc_socklen_t sock_len;
char buf[4 * NUM_IOVECS];
ssize_t r;
bson_error_t error;
mongoc_iovec_t iov;
struct sockaddr_in server_addr = {0};
int len;
iov.iov_base = buf;
iov.iov_len = sizeof buf;
listen_sock = mongoc_socket_new (AF_INET, SOCK_STREAM, 0);
BSON_ASSERT (listen_sock);
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
server_addr.sin_port = htons (0);
r = mongoc_socket_bind (
listen_sock, (struct sockaddr *) &server_addr, sizeof server_addr);
BSON_ASSERT (r == 0);
sock_len = sizeof (server_addr);
r = mongoc_socket_getsockname (
listen_sock, (struct sockaddr *) &server_addr, &sock_len);
BSON_ASSERT (r == 0);
r = mongoc_socket_listen (listen_sock, 10);
BSON_ASSERT (r == 0);
mongoc_mutex_lock (&data->cond_mutex);
data->server_port = ntohs (server_addr.sin_port);
mongoc_cond_signal (&data->cond);
mongoc_mutex_unlock (&data->cond_mutex);
conn_sock = mongoc_socket_accept (listen_sock, -1);
BSON_ASSERT (conn_sock);
sock_stream = mongoc_stream_socket_new (conn_sock);
BSON_ASSERT (sock_stream);
ssl_stream =
mongoc_stream_tls_new_with_hostname (sock_stream, NULL, data->server, 0);
if (!ssl_stream) {
#ifdef MONGOC_ENABLE_SSL_OPENSSL
unsigned long err = ERR_get_error ();
#else
unsigned long err = 42;
#endif
BSON_ASSERT (err);
data->server_result->ssl_err = err;
data->server_result->result = SSL_TEST_SSL_INIT;
#ifdef MONGOC_ENABLE_SSL_OPENSSL
MONGOC_ERROR ("ERRORED (line: %d): %s\n",
__LINE__,
ERR_error_string (ERR_get_error (), NULL));
#endif
mongoc_stream_destroy (sock_stream);
mongoc_socket_destroy (listen_sock);
return NULL;
}
BSON_ASSERT (ssl_stream);
r = mongoc_stream_tls_handshake_block (
ssl_stream, data->host, TIMEOUT, &error);
if (!r) {
unsigned long err = 43;
MONGOC_ERROR ("ERRORED (line: %d): %s\n", __LINE__, error.message);
#ifdef MONGOC_ENABLE_SSL_OPENSSL
MONGOC_ERROR ("msg: %s\n", ERR_error_string (ERR_get_error (), NULL));
#endif
data->server_result->ssl_err = err;
data->server_result->result = SSL_TEST_SSL_HANDSHAKE;
mongoc_socket_destroy (listen_sock);
mongoc_stream_destroy (ssl_stream);
return NULL;
}
r = mongoc_stream_readv (ssl_stream, &iov, 1, 4, TIMEOUT);
if (r < 0) {
data->server_result->err = errno;
data->server_result->result = SSL_TEST_TIMEOUT;
MONGOC_ERROR (
"ERRORED (line: %d): %s\n", __LINE__, "mongoc_stream_readv failed.");
mongoc_stream_destroy (ssl_stream);
mongoc_socket_destroy (listen_sock);
return NULL;
}
BSON_ASSERT (r == 4);
memcpy (&len, iov.iov_base, r);
r = mongoc_stream_readv (ssl_stream, &iov, 1, len, TIMEOUT);
BSON_ASSERT (r == len);
iov.iov_len = r;
mongoc_stream_writev (ssl_stream, &iov, 1, TIMEOUT);
mongoc_stream_destroy (ssl_stream);
mongoc_socket_destroy (listen_sock);
data->server_result->result = SSL_TEST_SUCCESS;
return NULL;
}
static void *
socket_test_server (void *data_)
{
socket_test_data_t *data = (socket_test_data_t *)data_;
struct sockaddr_in server_addr = { 0 };
mongoc_socket_t *listen_sock;
mongoc_socket_t *conn_sock;
mongoc_stream_t *stream;
mongoc_iovec_t iov;
socklen_t sock_len;
ssize_t r;
char buf[5];
iov.iov_base = buf;
iov.iov_len = sizeof (buf);
listen_sock = mongoc_socket_new (AF_INET, SOCK_STREAM, 0);
assert (listen_sock);
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
server_addr.sin_port = htons (0);
r = mongoc_socket_bind (listen_sock,
(struct sockaddr *)&server_addr,
sizeof server_addr);
assert (r == 0);
sock_len = sizeof(server_addr);
r = mongoc_socket_getsockname (listen_sock, (struct sockaddr *)&server_addr, &sock_len);
assert(r == 0);
r = mongoc_socket_listen (listen_sock, 10);
assert(r == 0);
mongoc_mutex_lock(&data->cond_mutex);
data->server_port = ntohs(server_addr.sin_port);
mongoc_cond_signal(&data->cond);
mongoc_mutex_unlock(&data->cond_mutex);
conn_sock = mongoc_socket_accept (listen_sock, -1);
assert (conn_sock);
stream = mongoc_stream_socket_new (conn_sock);
assert (stream);
r = mongoc_stream_readv (stream, &iov, 1, 5, TIMEOUT);
assert (r == 5);
assert (strcmp (buf, "ping") == 0);
strcpy (buf, "pong");
r = mongoc_stream_writev (stream, &iov, 1, TIMEOUT);
assert (r == 5);
mongoc_stream_destroy (stream);
mongoc_mutex_lock(&data->cond_mutex);
data->closed_socket = true;
mongoc_cond_signal(&data->cond);
mongoc_mutex_unlock(&data->cond_mutex);
mongoc_socket_destroy (listen_sock);
return NULL;
}
