}
return DSK_TRUE;
}
static void
dsk_bz2lib_compressor_finalize (DskBz2libCompressor *compressor)
{
if (compressor->initialized)
BZ2_bzCompressEnd (&compressor->bz2lib);
}
DSK_OBJECT_CLASS_DEFINE_CACHE_DATA(DskBz2libCompressor);
static DskBz2libCompressorClass dsk_bz2lib_compressor_class =
{ {
DSK_OBJECT_CLASS_DEFINE(DskBz2libCompressor,
&dsk_octet_filter_class,
NULL,
dsk_bz2lib_compressor_finalize),
dsk_bz2lib_compressor_process,
dsk_bz2lib_compressor_finish
} };
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;
SSL_CTX *ctx;
char *password;
};
static void
dsk_ssl_context_finalize (DskSslContext *context)
{
if (context->ctx)
SSL_CTX_free (context->ctx);
dsk_free (context->password);
}
DSK_OBJECT_CLASS_DEFINE_CACHE_DATA(DskSslContext);
static DskSslContextClass dsk_ssl_context_class =
{
DSK_OBJECT_CLASS_DEFINE(DskSslContext, &dsk_object_class, NULL,
dsk_ssl_context_finalize)
};
static int
set_password_cb (char *buf, int size, int rwflag, void *userdata)
{
DskSslContext *ctx = userdata;
DSK_UNUSED (rwflag);
strncpy (buf, ctx->password, size);
return strlen (ctx->password);
}
DskSslContext *
dsk_ssl_context_new (DskSslContextOptions *options,
DskError **error)
{
#include "dsk.h"
DSK_OBJECT_CLASS_DEFINE_CACHE_DATA(DskOctetFilter);
const DskOctetFilterClass dsk_octet_filter_class =
{
DSK_OBJECT_CLASS_DEFINE (DskOctetFilter, &dsk_object_class, NULL, NULL),
NULL, NULL
};
dsk_boolean dsk_octet_filter_process_buffer (DskOctetFilter *filter,
DskBuffer *out,
unsigned in_len,
DskBuffer *in,
dsk_boolean discard,
DskError **error)
{
DskBufferFragment *at = in->first_frag;
unsigned to_discard;
if (in_len > in->size)
in_len = in->size;
to_discard = discard ? in_len : 0;
while (in_len != 0)
{
unsigned process = at->buf_length;
if (process > in_len)
process = in_len;
if (!dsk_octet_filter_process (filter, out, process, at->buf + at->buf_start, error))
return DSK_FALSE;
in_len -= process;
at = at->next;
}
dsk_buffer_discard (in, to_discard);
return DSK_IO_RESULT_AGAIN;
dsk_buffer_transfer (&msink->buffer, buffer, max_xfer);
dsk_hook_set_idle_notify (&msink->buffer_nonempty, DSK_TRUE);
return DSK_IO_RESULT_SUCCESS;
}
static void
dsk_memory_sink_shutdown (DskOctetSink *sink)
{
DSK_MEMORY_SINK (sink)->got_shutdown = DSK_TRUE;
}
DSK_OBJECT_CLASS_DEFINE_CACHE_DATA (DskMemorySink);
DskMemorySinkClass dsk_memory_sink_class =
{
{
DSK_OBJECT_CLASS_DEFINE(DskMemorySink,
&dsk_octet_sink_class,
dsk_memory_sink_init,
dsk_memory_sink_finalize),
dsk_memory_sink_write,
dsk_memory_sink_write_buffer,
dsk_memory_sink_shutdown
}
};
void dsk_memory_sink_drained (DskMemorySink *sink)
{
if (sink->buffer.size == 0)
dsk_hook_set_idle_notify (&sink->buffer_nonempty, DSK_FALSE);
}
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);
}
typedef DskObjectClass DskWebsocketClass;
DSK_OBJECT_CLASS_DEFINE_CACHE_DATA(DskWebsocket);
DskObjectClass dsk_websocket_class =
DSK_OBJECT_CLASS_DEFINE(DskWebsocket, &dsk_object_class,
dsk_websocket_init, dsk_websocket_finalize);
/* read-hook function */
static void ensure_has_read_trap (DskWebsocket *websocket);
static void ensure_has_write_trap (DskWebsocket *websocket);
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_dispatch_remove_timer (stream->idle_disconnect_timer);
if (stream->reconnect_timer)
dsk_dispatch_remove_timer (stream->reconnect_timer);
if (stream->fd >= 0)
{
dsk_main_close_fd (stream->fd);
stream->fd = -1;
}
dsk_free (stream->name);
}
DSK_OBJECT_CLASS_DEFINE_CACHE_DATA(DskClientStream);
DskClientStreamClass dsk_client_stream_class =
{
{ DSK_OBJECT_CLASS_DEFINE(DskClientStream, &dsk_octet_stream_class,
dsk_client_stream_init,
dsk_client_stream_finalize) }
};
void dsk_client_stream_disconnect (DskClientStream *stream)
{
if (!stream->is_connected)
return;
/* close fd */
dsk_main_close_fd (stream->fd);
stream->is_connected = DSK_FALSE;
stream->fd = -1;
/* emit disconnect hook */
dsk_hook_notify (&stream->disconnect_hook);
