static void
do_shutdown (DskWebsocket *websocket)
{
websocket->is_shutdown = DSK_TRUE;
if (websocket->read_trap)
{
dsk_hook_trap_destroy (websocket->read_trap);
websocket->read_trap = NULL;
}
if (websocket->write_trap)
{
dsk_hook_trap_destroy (websocket->write_trap);
websocket->write_trap = NULL;
}
if (websocket->source)
{
dsk_octet_source_shutdown (websocket->source);
dsk_object_unref (websocket->source);
websocket->source = NULL;
}
if (websocket->sink)
{
dsk_octet_sink_shutdown (websocket->sink);
dsk_object_unref (websocket->sink);
websocket->sink = NULL;
}
}
static void dsk_ssl_stream_finalize (DskSslStream *stream)
{
dsk_assert (stream->ssl);
SSL_free (stream->ssl);
stream->ssl = NULL;
if (stream->underlying_read)
dsk_hook_trap_free (stream->underlying_read);
if (stream->underlying_write)
dsk_hook_trap_free (stream->underlying_write);
if (stream->underlying_sink)
dsk_object_unref (stream->underlying_sink);
if (stream->underlying_source)
dsk_object_unref (stream->underlying_source);
dsk_object_unref (stream->context);
}
static void
dsk_websocket_finalize (DskWebsocket *websocket)
{
if (websocket->read_trap)
dsk_hook_trap_destroy (websocket->read_trap);
if (websocket->write_trap)
dsk_hook_trap_destroy (websocket->write_trap);
if (websocket->source)
dsk_object_unref (websocket->source);
if (websocket->sink)
dsk_object_unref (websocket->sink);
dsk_buffer_clear (&websocket->incoming);
dsk_buffer_clear (&websocket->outgoing);
dsk_hook_clear (&websocket->readable);
}
DskOctetFilter *dsk_bz2lib_decompressor_new (void)
{
DskBz2libDecompressor *rv = dsk_object_new (&dsk_bz2lib_decompressor_class);
int zrv;
zrv = BZ2_bzDecompressInit (&rv->bz2lib, DSK_FALSE, DSK_FALSE);
if (zrv != BZ_OK)
{
dsk_warning ("BZ2_bzDecompressInit returned error");
dsk_object_unref (rv);
return NULL;
}
rv->initialized = DSK_TRUE;
return DSK_OCTET_FILTER (rv);
}
DskOctetFilter *dsk_bz2lib_compressor_new (unsigned level)
{
DskBz2libCompressor *rv = dsk_object_new (&dsk_bz2lib_compressor_class);
int zrv;
zrv = BZ2_bzCompressInit (&rv->bz2lib, level, DSK_FALSE, 0);
if (zrv != BZ_OK)
{
dsk_warning ("deflateInit2 returned error: %s", bzrv_to_string (zrv));
dsk_object_unref (rv);
return NULL;
}
rv->initialized = DSK_TRUE;
return DSK_OCTET_FILTER (rv);
}
dsk_boolean dsk_filter_to_buffer (unsigned length,
const uint8_t *data,
DskOctetFilter *filter,
DskBuffer *output,
DskError **error)
{
if (!dsk_octet_filter_process (filter, output, length, data, error)
|| !dsk_octet_filter_finish (filter, output, error))
{
return DSK_FALSE;
}
dsk_object_unref (filter);
return DSK_TRUE;
}
DskSslContext *
dsk_ssl_context_new (DskSslContextOptions *options,
DskError **error)
{
const SSL_METHOD *method = SSLv3_method ();
SSL_CTX *ctx = SSL_CTX_new (method);
DskSslContext *rv = dsk_object_new (&dsk_ssl_context_class);
rv->ctx = ctx;
if (options->password)
{
rv->password = dsk_strdup (options->password);
SSL_CTX_set_default_passwd_cb (ctx, set_password_cb);
SSL_CTX_set_default_passwd_cb_userdata (ctx, rv);
}
if (options->cert_filename)
{
if (SSL_CTX_use_certificate_file (ctx, options->cert_filename,
SSL_FILETYPE_PEM) != 1)
{
dsk_set_error (error, "error using certificate file %s",
options->cert_filename);
dsk_object_unref (rv);
return NULL;
}
}
if (options->key_filename)
{
if (SSL_CTX_use_PrivateKey_file (ctx, options->key_filename, SSL_FILETYPE_PEM) != 1)
{
dsk_set_error (error, "error using key file %s",
options->key_filename);
dsk_object_unref (rv);
return NULL;
}
}
return rv;
}
dsk_boolean
dsk_ssl_stream_new (DskSslStreamOptions *options,
DskSslStream **stream_out,
DskOctetSource **source_out,
DskOctetSink **sink_out,
DskError **error)
{
DskSslStream *stream;
DskSslSink *sink;
DskSslSource *source;
if (sink_out == NULL || source_out == NULL)
{
dsk_set_error (error, "dsk_ssl_stream_new: sink/source");
return DSK_FALSE;
}
sink = dsk_object_new (&dsk_ssl_sink_class);
source = dsk_object_new (&dsk_ssl_source_class);
stream = dsk_object_new (&dsk_ssl_stream_class);
BIO *bio;
bio = BIO_new (&bio_method__ssl_underlying_stream);
bio->ptr = stream;
bio->init = 1; /// HMM...
stream->ssl = SSL_new (options->context->ctx);
stream->context = dsk_object_ref (options->context);
SSL_set_bio (stream->ssl, bio, bio);
stream->base_instance.sink = DSK_OCTET_SINK (sink); /* does not own */
stream->base_instance.source = DSK_OCTET_SOURCE (source); /* does not own */
stream->is_client = options->is_client ? 1 : 0;
stream->handshaking = DSK_TRUE;
sink->base_instance.stream = dsk_object_ref (stream);
source->base_instance.stream = dsk_object_ref (stream);
if (stream->is_client)
SSL_set_connect_state (stream->ssl);
else
SSL_set_accept_state (stream->ssl);
*sink_out = DSK_OCTET_SINK (sink);
*source_out = DSK_OCTET_SOURCE (source);
if (stream_out != NULL)
*stream_out = stream;
else
dsk_object_unref (stream);
return DSK_TRUE;
}
static void
test_parse_request_0 (void)
{
DskHttpRequest *r;
r = parse_request_from_string ("GET /f HTTP/1.0\r\n"
"Host: example.com\r\n");
dsk_assert (r->verb == DSK_HTTP_VERB_GET);
dsk_assert (strcmp (r->path, "/f") == 0);
dsk_assert (strcmp (r->host, "example.com") == 0);
dsk_assert (strcmp (dsk_http_request_get (r, "host"), "example.com") == 0);
dsk_assert (strcmp (dsk_http_request_get (r, "path"), "/f") == 0);
dsk_object_unref (r);
}
static void
handle_dns_done (DskDnsLookupResult *result,
void *callback_data)
{
DskClientStream *stream = callback_data;
stream->is_resolving_name = 0;
switch (result->type)
{
case DSK_DNS_LOOKUP_RESULT_FOUND:
{
struct sockaddr_storage addr;
unsigned addr_len;
dsk_ip_address_to_sockaddr (result->addr, stream->port, &addr, &addr_len);
begin_connecting_sockaddr (stream, addr_len, (struct sockaddr *) &addr);
}
break;
case DSK_DNS_LOOKUP_RESULT_NOT_FOUND:
dsk_octet_stream_set_last_error (&stream->base_instance,
"dns entry for %s not found",
stream->name);
maybe_set_autoreconnect_timer (stream);
break;
case DSK_DNS_LOOKUP_RESULT_TIMEOUT:
dsk_octet_stream_set_last_error (&stream->base_instance,
"dns lookup for %s timed out",
stream->name);
maybe_set_autoreconnect_timer (stream);
break;
case DSK_DNS_LOOKUP_RESULT_BAD_RESPONSE:
dsk_octet_stream_set_last_error (&stream->base_instance,
"dns lookup for %s failed: %s",
stream->name, result->message);
maybe_set_autoreconnect_timer (stream);
break;
default:
dsk_assert_not_reached ();
}
dsk_object_unref (stream);
}
dsk_boolean
dsk_client_stream_new (DskClientStreamOptions *options,
DskClientStream **stream_out,
DskOctetSink **sink_out,
DskOctetSource **source_out,
DskError **error)
{
DskClientStream *rv;
dsk_boolean has_address = !ip_address_is_default (&options->address);
/* check trivial usage considerations */
dsk_warn_if_fail (!(options->hostname != NULL && has_address),
"ignoring ip-address because symbolic name given");
if (options->hostname != NULL || has_address)
{
if (options->port == 0)
{
dsk_set_error (error,
"port must be non-zero for client (hostname is '%s')",
options->hostname);
return DSK_FALSE;
}
dsk_warn_if_fail (options->path == NULL,
"cannot decide between tcp and local client");
}
rv = dsk_object_new (&dsk_client_stream_class);
rv->base_instance.sink = dsk_object_new (&dsk_client_stream_sink_class);
rv->base_instance.source = dsk_object_new (&dsk_client_stream_source_class);
rv->base_instance.sink->stream = dsk_object_ref (rv);
rv->base_instance.source->stream = dsk_object_ref (rv);
rv->reconnect_time_ms = -1;
rv->idle_disconnect_time_ms = -1;
rv->fd = -1;
if (options->hostname != NULL)
{
if (dsk_hostname_looks_numeric (options->hostname))
rv->is_numeric_name = 1;
rv->name = dsk_strdup (options->hostname);
rv->port = options->port;
}
else if (has_address)
{
rv->is_numeric_name = 1;
rv->name = dsk_ip_address_to_string (&options->address);
rv->port = options->port;
}
else if (options->path != NULL)
{
rv->is_local_socket = 1;
rv->name = dsk_strdup (options->path);
}
rv->idle_disconnect_time_ms = options->idle_disconnect_time;
rv->reconnect_time_ms = options->reconnect_time;
begin_connecting (rv);
if (options->idle_disconnect_time >= 0)
dsk_client_stream_set_max_idle_time (rv, options->idle_disconnect_time);
if (options->reconnect_time >= 0)
dsk_client_stream_set_reconnect_time (rv, options->reconnect_time);
if (source_out)
*source_out = rv->base_instance.source;
else if (rv->base_instance.source)
dsk_object_unref (rv->base_instance.source);
if (sink_out)
*sink_out = rv->base_instance.sink;
else if (rv->base_instance.sink)
dsk_object_unref (rv->base_instance.sink);
if (stream_out)
*stream_out = rv;
else
dsk_object_unref (rv);
return DSK_TRUE;
}
