mongoc_stream_t *
mongoc_stream_buffered_new (mongoc_stream_t *base_stream, /* IN */
size_t buffer_size) /* IN */
{
mongoc_stream_buffered_t *stream;
void *buffer;
bson_return_val_if_fail(base_stream, NULL);
stream = bson_malloc0(sizeof *stream);
stream->stream.destroy = mongoc_stream_buffered_destroy;
stream->stream.close = mongoc_stream_buffered_close;
stream->stream.flush = mongoc_stream_buffered_flush;
stream->stream.writev = mongoc_stream_buffered_writev;
stream->stream.readv = mongoc_stream_buffered_readv;
stream->stream.cork = mongoc_stream_buffered_cork;
stream->stream.uncork = mongoc_stream_buffered_uncork;
stream->base_stream = base_stream;
buffer = bson_malloc0(buffer_size);
_mongoc_buffer_init (&stream->buffer, buffer, buffer_size, bson_realloc);
mongoc_counter_streams_active_inc();
return (mongoc_stream_t *)stream;
}
mongoc_stream_t *
mongoc_stream_socket_new (mongoc_socket_t *sock) /* IN */
{
mongoc_stream_socket_t *stream;
BSON_ASSERT (sock);
stream = (mongoc_stream_socket_t *) bson_malloc0 (sizeof *stream);
stream->vtable.type = MONGOC_STREAM_SOCKET;
stream->vtable.close = _mongoc_stream_socket_close;
stream->vtable.destroy = _mongoc_stream_socket_destroy;
stream->vtable.failed = _mongoc_stream_socket_failed;
stream->vtable.flush = _mongoc_stream_socket_flush;
stream->vtable.readv = _mongoc_stream_socket_readv;
stream->vtable.writev = _mongoc_stream_socket_writev;
stream->vtable.setsockopt = _mongoc_stream_socket_setsockopt;
stream->vtable.check_closed = _mongoc_stream_socket_check_closed;
stream->vtable.timed_out = _mongoc_stream_socket_timed_out;
stream->vtable.should_retry = _mongoc_stream_socket_should_retry;
stream->vtable.poll = _mongoc_stream_socket_poll;
stream->sock = sock;
mongoc_counter_streams_active_inc ();
return (mongoc_stream_t *) stream;
}
mongoc_stream_t *
mongoc_stream_tls_new (mongoc_stream_t *base_stream,
mongoc_ssl_opt_t *opt,
int client)
{
mongoc_stream_tls_t *tls;
SSL_CTX *ssl_ctx = NULL;
BIO *bio_ssl = NULL;
BIO *bio_mongoc_shim = NULL;
BSON_ASSERT(base_stream);
BSON_ASSERT(opt);
ssl_ctx = _mongoc_ssl_ctx_new (opt);
if (!ssl_ctx) {
return NULL;
}
bio_ssl = BIO_new_ssl (ssl_ctx, client);
bio_mongoc_shim = BIO_new (&gMongocStreamTlsRawMethods);
BIO_push (bio_ssl, bio_mongoc_shim);
tls = bson_malloc0 (sizeof *tls);
tls->base_stream = base_stream;
tls->parent.type = MONGOC_STREAM_TLS;
tls->parent.destroy = _mongoc_stream_tls_destroy;
tls->parent.close = _mongoc_stream_tls_close;
tls->parent.flush = _mongoc_stream_tls_flush;
tls->parent.writev = _mongoc_stream_tls_writev;
tls->parent.readv = _mongoc_stream_tls_readv;
tls->parent.cork = _mongoc_stream_tls_cork;
tls->parent.uncork = _mongoc_stream_tls_uncork;
tls->parent.setsockopt = _mongoc_stream_tls_setsockopt;
tls->parent.get_base_stream = _mongoc_stream_tls_get_base_stream;
tls->weak_cert_validation = opt->weak_cert_validation;
tls->bio = bio_ssl;
tls->ctx = ssl_ctx;
tls->timeout = -1;
bio_mongoc_shim->ptr = tls;
mongoc_counter_streams_active_inc();
return (mongoc_stream_t *)tls;
}
mongoc_stream_t *
mongoc_stream_gridfs_new (mongoc_gridfs_file_t *file)
{
mongoc_stream_gridfs_t *stream;
ENTRY;
BSON_ASSERT (file);
stream = bson_malloc0 (sizeof *stream);
stream->file = file;
stream->stream.destroy = _mongoc_stream_gridfs_destroy;
stream->stream.close = _mongoc_stream_gridfs_close;
stream->stream.flush = _mongoc_stream_gridfs_flush;
stream->stream.writev = _mongoc_stream_gridfs_writev;
stream->stream.readv = _mongoc_stream_gridfs_readv;
mongoc_counter_streams_active_inc ();
RETURN ((mongoc_stream_t *)stream);
}
mongoc_stream_t *
mongoc_stream_gridfs_new (mongoc_gridfs_file_t *file)
{
mongoc_stream_gridfs_t *stream;
ENTRY;
BSON_ASSERT (file);
stream = (mongoc_stream_gridfs_t *) bson_malloc0 (sizeof *stream);
stream->file = file;
stream->stream.type = MONGOC_STREAM_GRIDFS;
stream->stream.destroy = _mongoc_stream_gridfs_destroy;
stream->stream.failed = _mongoc_stream_gridfs_failed;
stream->stream.close = _mongoc_stream_gridfs_close;
stream->stream.flush = _mongoc_stream_gridfs_flush;
stream->stream.writev = _mongoc_stream_gridfs_writev;
stream->stream.readv = _mongoc_stream_gridfs_readv;
stream->stream.check_closed = _mongoc_stream_gridfs_check_closed;
mongoc_counter_streams_active_inc ();
RETURN ((mongoc_stream_t *) stream);
}
mongoc_stream_t *
mongoc_stream_tls_secure_transport_new (mongoc_stream_t *base_stream,
const char *host,
mongoc_ssl_opt_t *opt,
int client)
{
mongoc_stream_tls_t *tls;
mongoc_stream_tls_secure_transport_t *secure_transport;
ENTRY;
BSON_ASSERT (base_stream);
BSON_ASSERT (opt);
if (opt->ca_dir) {
MONGOC_ERROR ("Setting mongoc_ssl_opt_t.ca_dir has no effect when built "
"against Secure Transport");
RETURN (NULL);
}
if (opt->crl_file) {
MONGOC_ERROR (
"Setting mongoc_ssl_opt_t.crl_file has no effect when built "
"against Secure Transport");
RETURN (NULL);
}
secure_transport = (mongoc_stream_tls_secure_transport_t *) bson_malloc0 (
sizeof *secure_transport);
tls = (mongoc_stream_tls_t *) bson_malloc0 (sizeof *tls);
tls->parent.type = MONGOC_STREAM_TLS;
tls->parent.destroy = _mongoc_stream_tls_secure_transport_destroy;
tls->parent.failed = _mongoc_stream_tls_secure_transport_failed;
tls->parent.close = _mongoc_stream_tls_secure_transport_close;
tls->parent.flush = _mongoc_stream_tls_secure_transport_flush;
tls->parent.writev = _mongoc_stream_tls_secure_transport_writev;
tls->parent.readv = _mongoc_stream_tls_secure_transport_readv;
tls->parent.setsockopt = _mongoc_stream_tls_secure_transport_setsockopt;
tls->parent.get_base_stream =
_mongoc_stream_tls_secure_transport_get_base_stream;
tls->parent.check_closed = _mongoc_stream_tls_secure_transport_check_closed;
tls->parent.timed_out = _mongoc_stream_tls_secure_channel_timed_out;
memcpy (&tls->ssl_opts, opt, sizeof tls->ssl_opts);
tls->handshake = mongoc_stream_tls_secure_transport_handshake;
tls->ctx = (void *) secure_transport;
tls->timeout_msec = -1;
secure_transport->ssl_ctx_ref =
SSLCreateContext (kCFAllocatorDefault,
client ? kSSLClientSide : kSSLServerSide,
kSSLStreamType);
SSLSetIOFuncs (secure_transport->ssl_ctx_ref,
mongoc_secure_transport_read,
mongoc_secure_transport_write);
SSLSetProtocolVersionMin (secure_transport->ssl_ctx_ref, kTLSProtocol1);
if (opt->pem_file &&
!mongoc_secure_transport_setup_certificate (secure_transport, opt)) {
mongoc_stream_destroy ((mongoc_stream_t *) tls);
RETURN (NULL);
}
if (opt->ca_file &&
!mongoc_secure_transport_setup_ca (secure_transport, opt)) {
mongoc_stream_destroy ((mongoc_stream_t *) tls);
RETURN (NULL);
}
/* don't link base_stream to tls until we're sure we won't destroy tls */
tls->base_stream = base_stream;
if (client) {
SSLSetSessionOption (secure_transport->ssl_ctx_ref,
kSSLSessionOptionBreakOnServerAuth,
opt->weak_cert_validation);
} else if (!opt->allow_invalid_hostname) {
/* used only in mock_server_t tests */
SSLSetClientSideAuthenticate (secure_transport->ssl_ctx_ref,
kAlwaysAuthenticate);
}
if (!opt->allow_invalid_hostname) {
SSLSetPeerDomainName (secure_transport->ssl_ctx_ref, host, strlen (host));
}
SSLSetConnection (secure_transport->ssl_ctx_ref, tls);
mongoc_counter_streams_active_inc ();
RETURN ((mongoc_stream_t *) tls);
}