v/tmate-ssh-server
1
0
Fork 0
mirror of https://github.com/tmate-io/tmate-ssh-server.git synced 2020-11-18 19:53:51 -08:00
Code Issues Releases Wiki Activity

Bump to msgpack new lib

Browse Source
This commit is contained in:
Nicolas Viennot 2015-10-03 13:36:09 -07:00
parent 7c78530344
commit 0f7f5a477a
4 changed files with 127 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tmate-daemon-decoder.c
View File

@ -15,6 +15,10 @@ static void tmate_header(struct tmate_session *session,
char tmp[512];
session->client_protocol_version = unpack_int(uk);
if (session->client_protocol_version <= 4) {
session->daemon_encoder.mpac_version = 4;
}
if (session->client_protocol_version >= 3) {
free(client_version);
client_version = unpack_string(uk);

4
tmate-master.c
View File

@ -63,11 +63,11 @@ static void do_snapshot(struct tmate_unpacker *uk,
str_len += utf8.size;
}
pack(raw, str_len);
pack(str, str_len);
for (i = 0; i < line->cellsize; i++) {
cell = &line->celldata[i];
grid_cell_get(cell, &utf8);
pack(raw_body, utf8.data, utf8.size);
pack(str_body, utf8.data, utf8.size);
}
pack(array, line->cellsize);

124
tmate-msgpack.c
View File

@ -24,11 +24,127 @@ static int on_encoder_write(void *userdata, const char *buf, unsigned int len)
return 0;
}
/* Really sad hack, but we can get away with it */
#define tmate_encoder_from_pk(pk) ((struct tmate_encoder *)pk)
void msgpack_pack_string(msgpack_packer *pk, const char *str)
{
size_t len = strlen(str);
if (tmate_encoder_from_pk(pk)->mpac_version >= 5) {
msgpack_pack_str(pk, len);
msgpack_pack_str_body(pk, str, len);
} else {
msgpack_pack_v4raw(pk, len);
msgpack_pack_v4raw_body(pk, str, len);
}
}
/* Copy/pasted from msgpack sources, except we include the v4 support */
int _msgpack_pack_object(msgpack_packer* pk, msgpack_object d)
{
switch(d.type) {
case MSGPACK_OBJECT_NIL:
return msgpack_pack_nil(pk);
case MSGPACK_OBJECT_BOOLEAN:
if(d.via.boolean) {
return msgpack_pack_true(pk);
} else {
return msgpack_pack_false(pk);
}
case MSGPACK_OBJECT_POSITIVE_INTEGER:
return msgpack_pack_uint64(pk, d.via.u64);
case MSGPACK_OBJECT_NEGATIVE_INTEGER:
return msgpack_pack_int64(pk, d.via.i64);
case MSGPACK_OBJECT_FLOAT:
return msgpack_pack_double(pk, d.via.f64);
case MSGPACK_OBJECT_STR:
{
if (tmate_encoder_from_pk(pk)->mpac_version >= 5) {
int ret = msgpack_pack_str(pk, d.via.str.size);
if(ret < 0) { return ret; }
return msgpack_pack_str_body(pk, d.via.str.ptr, d.via.str.size);
} else {
int ret = msgpack_pack_v4raw(pk, d.via.str.size);
if(ret < 0) { return ret; }
return msgpack_pack_v4raw_body(pk, d.via.str.ptr, d.via.str.size);
}
}
case MSGPACK_OBJECT_BIN:
{
if (tmate_encoder_from_pk(pk)->mpac_version >= 5) {
int ret = msgpack_pack_bin(pk, d.via.bin.size);
if(ret < 0) { return ret; }
return msgpack_pack_bin_body(pk, d.via.bin.ptr, d.via.bin.size);
} else {
int ret = msgpack_pack_v4raw(pk, d.via.bin.size);
if(ret < 0) { return ret; }
return msgpack_pack_v4raw_body(pk, d.via.bin.ptr, d.via.bin.size);
}
}
case MSGPACK_OBJECT_EXT:
{
int ret = msgpack_pack_ext(pk, d.via.ext.size, d.via.ext.type);
if(ret < 0) { return ret; }
return msgpack_pack_ext_body(pk, d.via.ext.ptr, d.via.ext.size);
}
case MSGPACK_OBJECT_ARRAY:
{
int ret = msgpack_pack_array(pk, d.via.array.size);
if(ret < 0) {
return ret;
}
else {
msgpack_object* o = d.via.array.ptr;
msgpack_object* const oend = d.via.array.ptr + d.via.array.size;
for(; o != oend; ++o) {
ret = msgpack_pack_object(pk, *o);
if(ret < 0) { return ret; }
}
return 0;
}
}
case MSGPACK_OBJECT_MAP:
{
int ret = msgpack_pack_map(pk, d.via.map.size);
if(ret < 0) {
return ret;
}
else {
msgpack_object_kv* kv = d.via.map.ptr;
msgpack_object_kv* const kvend = d.via.map.ptr + d.via.map.size;
for(; kv != kvend; ++kv) {
ret = msgpack_pack_object(pk, kv->key);
if(ret < 0) { return ret; }
ret = msgpack_pack_object(pk, kv->val);
if(ret < 0) { return ret; }
}
return 0;
}
}
default:
return -1;
}
}
void tmate_encoder_init(struct tmate_encoder *encoder,
tmate_encoder_write_cb *callback,
void *userdata)
{
msgpack_packer_init(&encoder->pk, encoder, &on_encoder_write);
encoder->mpac_version = 5;
encoder->buffer = evbuffer_new();
encoder->ready_callback = callback;
encoder->userdata = userdata;
@ -83,20 +199,12 @@ void unpack_buffer(struct tmate_unpacker *uk, const char **buf, size_t *len)
if (uk->argc == 0)
tmate_decoder_error();
#if NEW_MSGPACK_API
if (uk->argv[0].type != MSGPACK_OBJECT_STR &&
uk->argv[0].type != MSGPACK_OBJECT_BIN)
tmate_decoder_error();
*len = uk->argv[0].via.str.size;
*buf = uk->argv[0].via.str.ptr;
#else
if (uk->argv[0].type != MSGPACK_OBJECT_RAW)
tmate_decoder_error();
*len = uk->argv[0].via.raw.size;
*buf = uk->argv[0].via.raw.ptr;
#endif
uk->argv++;
uk->argc--;

31
tmate.h
View File

@ -32,6 +32,7 @@ typedef void tmate_encoder_write_cb(void *userdata, struct evbuffer *buffer);
struct tmate_encoder {
msgpack_packer pk;
int mpac_version;
tmate_encoder_write_cb *ready_callback;
void *userdata;
struct evbuffer *buffer;
@ -43,32 +44,10 @@ extern void tmate_encoder_init(struct tmate_encoder *encoder,
tmate_encoder_write_cb *callback,
void *userdata);
#define NEW_MSGPACK_API 1
#if NEW_MSG_PACK
#define msgpack_pack_buffer(pk, buf, len) ({ \
msgpack_pack_bin(pk, len); \
msgpack_pack_bin_body(pk, buf, len); \
})
#define msgpack_pack_string(pk, str) ({ \
int __strlen = strlen(str); \
msgpack_pack_str(pk, __strlen); \
msgpack_pack_str_body(pk, str, __strlen); \
})
#else
/* old msgpack version */
#define msgpack_pack_buffer(pk, buf, len) ({ \
msgpack_pack_raw(pk, len); \
msgpack_pack_raw_body(pk, buf, len); \
})
#define msgpack_pack_string(pk, str) ({ \
int __strlen = strlen(str); \
msgpack_pack_raw(pk, __strlen); \
msgpack_pack_raw_body(pk, str, __strlen); \
})
#endif
/* These functions deal with dual v4/v5 support through mpac_version */
extern void msgpack_pack_string(msgpack_packer *pk, const char *str);
extern int _msgpack_pack_object(msgpack_packer *pk, msgpack_object d);
#define msgpack_pack_object _msgpack_pack_object
#define _pack(enc, what, ...) msgpack_pack_##what(&(enc)->pk, __VA_ARGS__)