diff options
Diffstat (limited to 'src/socket.c')
-rw-r--r-- | src/socket.c | 432 |
1 files changed, 432 insertions, 0 deletions
diff --git a/src/socket.c b/src/socket.c new file mode 100644 index 0000000..690b94f --- /dev/null +++ b/src/socket.c @@ -0,0 +1,432 @@ +#include <stdlib.h> +#include <string.h> +#include <stdbool.h> + +#include <sys/types.h> + +#include "mumble.pb-c.h" + +#include "polarssl/net.h" +#include "polarssl/ssl.h" +#include "polarssl/havege.h" + +#include <celt/celt.h> +#include <celt/celt_header.h> +#include <speex/speex_jitter.h> + +#include <glib.h> +#include <glib-object.h> + +#include "messages.h" + +#define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0])) + +#define PREAMBLE_SIZE 6 + +struct context { + GMainLoop *loop; + + uint32_t session; + bool authenticated; + + ssl_context ssl; + havege_state hs; + ssl_session ssn; + int sock; + GIOChannel *sock_channel; + + CELTHeader celt_header; + CELTMode *celt_mode; +}; + +enum udp_message_type { + udp_voice_celt_alpha, + udp_ping, + udp_voice_speex, + udp_voice_celt_beta, +}; + +int64_t +decode_varint(uint8_t *data, uint32_t *read, uint32_t left) +{ + int64_t varint = 0; + + /* 1 byte with 7 · 8 + 1 leading zeroes */ + if ((data[0] & 0x80) == 0x00) { + varint = data[0] & 0x7F; + *read = 1; + /* 2 bytes with 6 · 8 + 2 leading zeroes */ + } else if ((data[0] & 0xC0) == 0x80) { + varint = ((data[0] & 0x3F) << 8) | data[1]; + *read = 2; + /* 3 bytes with 5 · 8 + 3 leading zeroes */ + } else if ((data[0] & 0xE0) == 0xC0) { + varint = (((data[0] & 0x1F) << 16) | + (data[1] << 8) | (data[2])); + *read = 3; + /* 4 bytes with 4 · 8 + 4 leading zeroes */ + } else if ((data[0] & 0xF0) == 0xE0) { + varint = (((data[0] & 0x0F) << 24) | (data[1] << 16) | + (data[2] << 8) | (data[3])); + *read = 4; + } else /* if ((data[pos] & 0xF0) == 0xF0) */ { + switch (data[0] & 0xFC) { + /* 32-bit positive number */ + case 0xF0: + varint = ((data[1] << 24) | (data[2] << 16) | + (data[3] << 8) | data[4]); + *read = 1 + 4; + break; + /* 64-bit number */ + case 0xF4: + varint = + ((int64_t)data[1] << 56) | ((int64_t)data[2] << 48) | + ((int64_t)data[3] << 40) | ((int64_t)data[4] << 32) | + (data[5] << 24) | (data[6] << 16) | + (data[7] << 8) | (data[8] << 0); + *read = 1 + 8; + break; + /* Negative varint */ + case 0xF8: + /* FIXME: handle endless recursion */ + varint = -decode_varint(&data[1], read, left - 1); + *read += 1; + break; + /* Negative two bit number */ + case 0xFC: + varint = -(int)(data[0] & 0x03); + *read = 1; + break; + } + } + + return varint; +} + +static void +handle_udp(struct context *ctx, uint8_t *data, uint32_t len) +{ + int64_t session; + int64_t sequence; + int pos = 1; + int read = 0; + +#define PCM_SIZE (48000/100 * 1) + int16_t pcm[PCM_SIZE]; + uint8_t buf[BUFSIZ]; + FILE *f; + int frame_len, term; + CELTDecoder *dec_state; + JitterBuffer *jitter; + CELTMode *mode; + static int iseq = 0; + + session = decode_varint(&data[pos], &read, len-pos); + pos += read; + sequence = decode_varint(&data[pos], &read, len-pos); + pos += read; + printf("session: %ld, sequence: %ld\n", session, sequence); + + f = fopen("foo", "a+"); + + dec_state = celt_decoder_create(ctx->celt_mode, + ctx->celt_header.nb_channels, NULL); + + jitter = jitter_buffer_init(ctx->celt_header.frame_size); + jitter_buffer_ctl(jitter, JITTER_BUFFER_SET_MARGIN, + &ctx->celt_header.frame_size); + + do { + frame_len = (data[pos] & 0x7F); + term = (data[pos] & 0x80) == 0x80; + printf("_len: %d, term: %d\n", frame_len, term); + pos += 1; + + if (frame_len == 0) + break; + + JitterBufferPacket packet; + packet.data = &data[pos]; + packet.len = frame_len; + packet.timestamp = ctx->celt_header.frame_size * iseq++; + packet.span = ctx->celt_header.frame_size; + packet.sequence = 0; + + jitter_buffer_put(jitter, &packet); + + packet.data = buf; + packet.len = BUFSIZ; + jitter_buffer_tick(jitter); + jitter_buffer_get(jitter, &packet, ctx->celt_header.frame_size, NULL); + + if (packet.len == 0) + packet.data = NULL; + + celt_decode(dec_state, packet.data, packet.len, pcm); + fwrite(pcm, sizeof(int16_t), PCM_SIZE, f); + + pos += frame_len; + sequence++; + } while (term); + + fclose(f); + celt_decoder_destroy(dec_state); +} + +static void +add_preamble(uint8_t *buffer, uint16_t type, uint32_t len) +{ + buffer[1] = (type) & 0xff; + buffer[0] = (type >> 8) & 0xff; + + buffer[5] = (len) & 0xff; + buffer[4] = (len >> 8) & 0xff; + buffer[3] = (len >> 16) & 0xff; + buffer[2] = (len >> 24) & 0xff; +} + +static void +get_preamble(uint8_t *buffer, int *type, int *len) +{ + uint16_t msgType; + uint32_t msgLen; + + msgType = buffer[1] | (buffer[0] << 8); + msgLen = buffer[5] | (buffer[4] << 8) | (buffer[3] << 16) | (buffer[2] << 24); + *type = (int)msgType; + *len = (int)msgLen; +} + +static void +recv_version(MumbleProto__Version *version, struct context *ctx) +{ + printf("version: 0x%x\n", version->version); + printf("release: %s\n", version->release); +} + +static void +recv_channel_state(MumbleProto__ChannelState *state, struct context *ctx) +{ + printf("channel: id: %u, parent: %u, name: %s, description: %s, temporary: %d, position: %d\n", + state->channel_id, state->parent, state->name, state->description, state->temporary, state->position); +} + +static void +send_msg(struct context *ctx, ProtobufCMessage *msg) +{ + uint8_t pad[128]; + uint8_t preamble[PREAMBLE_SIZE]; + int ret = 0; + int type = -1; + int i; + ProtobufCBufferSimple buffer = PROTOBUF_C_BUFFER_SIMPLE_INIT(pad); + + for (i = 0; i < ARRAY_SIZE(messages); ++i) + if (messages[i].descriptor == msg->descriptor) + type = i; + assert(type >= 0); + + protobuf_c_message_pack_to_buffer(msg, &buffer.base); + add_preamble(preamble, type, buffer.len); + + while ((ret = ssl_write(&ctx->ssl, preamble, PREAMBLE_SIZE)) <= 0) { + if (ret != POLARSSL_ERR_NET_TRY_AGAIN) { + printf("write failed: %d\n", ret); + abort(); + } + } + while ((ret = ssl_write(&ctx->ssl, buffer.data, buffer.len)) < buffer.len) { + if (ret != POLARSSL_ERR_NET_TRY_AGAIN) { + printf("write failed: %d\n", ret); + abort(); + } + } + + PROTOBUF_C_BUFFER_SIMPLE_CLEAR(&buffer); +} + +typedef void (*callback_t)(void *, void *); + +static void +recv_msg(struct context *ctx, const callback_t *callbacks, uint32_t callback_size) +{ + uint8_t preamble[PREAMBLE_SIZE]; + ProtobufCMessage *msg; + void *data; + int type, len; + int ret, i; + + printf("recv msg\n"); + + do { + ret = ssl_read(&ctx->ssl, preamble, 6); + if (ret == POLARSSL_ERR_NET_CONN_RESET) { + printf("conn reset\n"); + exit(1); + } + } while (ret == POLARSSL_ERR_NET_TRY_AGAIN); + + if (ret <= 0) { + printf("read failed: %d\n", ret); + return; + } + + get_preamble(preamble, &type, &len); + + if (!(type >= 0 && type < ARRAY_SIZE(messages))) { + printf("unknown message type: %d\n", type); + return; + } + + if (len <= 0) { + printf("length 0\n"); + return; + } + + data = malloc(len); + if (data == NULL) { + printf("out of mem\n"); + abort(); + } + ret = ssl_read(&ctx->ssl, data, len); + if (ret == POLARSSL_ERR_NET_CONN_RESET) { + printf("conn reset\n"); + exit(1); + } + + /* tunneled udp data - not a regular protobuf message */ + if (type == 1) { + handle_udp(ctx, data, len); + free(data); + return; + } + + msg = protobuf_c_message_unpack(messages[type].descriptor, NULL, + len, data); + if (msg == NULL) { + printf("message unpack failure\n"); + return ; + } + + printf("debug: received message: %s type:%d, len:%d\n", messages[type].name, type, len); + if (callbacks[type]) + callbacks[type](msg, ctx); + + protobuf_c_message_free_unpacked(msg, NULL); + free(data); +} + +static void +my_debug(void *ctx, int level, const char *str) +{ + if (level <= 1) + printf("polarssl [level %d]: %s\n", level, str); +} + +static void +do_ping(struct context *ctx) +{ + MumbleProto__Ping ping; + struct timeval tv; + + gettimeofday(&tv, NULL); + mumble_proto__ping__init(&ping); + + ping.timestamp = tv.tv_sec; + ping.resync = 1; + + send_msg(ctx, &ping.base); +} + +static const callback_t callbacks[] = { + /* VERSION */ (callback_t) recv_version, + [7] = (callback_t) recv_channel_state, + [127] = NULL, +}; + +static gboolean +_recv(GIOChannel *source, GIOCondition condition, gpointer data) +{ + struct context *ctx = data; + do { + recv_msg(ctx, callbacks, ARRAY_SIZE(callbacks)); + } while (ssl_get_bytes_avail(&ctx->ssl) > 0); + + do_ping(ctx); + + return TRUE; +} + +int main(int argc, char **argv) +{ +#if 1 + char *host = "localhost"; + unsigned int port = 64738; +#else + char *host = "85.214.21.153"; + unsigned int port = 33321; +#endif + struct context ctx; + int ret; + + memset(&ctx, 0, sizeof(ctx)); + + ssl_init(&ctx.ssl); + havege_init( &ctx.hs ); + + ret = net_connect(&ctx.sock, host, port); + ssl_set_endpoint(&ctx.ssl, SSL_IS_CLIENT); + ssl_set_authmode(&ctx.ssl, SSL_VERIFY_NONE); + + ssl_set_rng(&ctx.ssl, havege_rand, &ctx.hs); + ssl_set_dbg(&ctx.ssl, my_debug, NULL); + ssl_set_bio(&ctx.ssl, net_recv, &ctx.sock, net_send, &ctx.sock); + + //ssl_set_session(&ctx.ssl, 1, 600, &ssn); + ssl_set_session(&ctx.ssl, 0, 0, &ctx.ssn); + ssl_set_ciphers(&ctx.ssl, ssl_default_ciphers); + + { + MumbleProto__Version version; + mumble_proto__version__init(&version); + version.version = 0x010203; + version.release = "cmumble 0.1"; + version.os = "Gentoo/Linux"; + send_msg(&ctx, &version.base); + } + + { + MumbleProto__Authenticate authenticate; + mumble_proto__authenticate__init(&authenticate); + authenticate.username = "ben2"; + authenticate.password = ""; + authenticate.n_celt_versions = 1; + authenticate.celt_versions = (int32_t[]) { 0x8000000b }; + send_msg(&ctx, &authenticate.base); + } + + do_ping(&ctx); + +#define SAMPLERATE 48000 +#define CHANNELS 1 + ctx.celt_mode = celt_mode_create(SAMPLERATE, SAMPLERATE / 100, NULL); + celt_header_init(&ctx.celt_header, ctx.celt_mode, CHANNELS); + uint8_t celt_header_packet[sizeof(CELTHeader)]; + printf("extra headers: %d\n", ctx.celt_header.extra_headers); + celt_header_to_packet(&ctx.celt_header, celt_header_packet, sizeof(CELTHeader)); + + g_type_init(); + ctx.loop = g_main_loop_new(NULL, FALSE); + + ctx.sock_channel = g_io_channel_unix_new(ctx.sock); + g_io_add_watch(ctx.sock_channel, G_IO_IN | G_IO_ERR, _recv, &ctx); + + g_main_loop_run(ctx.loop); + + g_main_loop_unref(ctx.loop); + + net_close(ctx.sock); + ssl_free(&ctx.ssl); + memset(&ctx.ssl, 0, sizeof(ctx.ssl)); + +} |