struct slave_sync_res *parse_master_response(struct mile_packet *packet) {
struct data_buffer* rbuf = packet->rbuf;
struct mile_message_header header;
if (NULL == rbuf) {
log_error( "read buffer is empty");
return NULL;
}
header.version_major = read_int8(rbuf);
header.version_minor = read_int8(rbuf);
header.message_type = read_int16(rbuf);
header.message_id = read_int32(rbuf);
log_debug(
"数据包包头信息 -- 主版本号: %d, 小版本号: %d, 消息类型: 0x%x, 消息id: %d", header.version_major, header.version_minor, header.message_type, header.message_id);
if (MT_DM_RS != header.message_type) {
log_error( "unknown message type: %hu", header.message_type);
return NULL;
}
// read body
struct slave_sync_res *res = (struct slave_sync_res *) (rbuf->data
+ rbuf->rpos);
rbuf->rpos += res->len + sizeof(struct slave_sync_res);
if (rbuf->rpos > rbuf->data_len) {
log_error( "wrong packet lenght.");
return NULL;
}
return res;
}
int32_t execute_index_stat_handle(struct data_buffer* dbuf,int socket_fd,MEM_POOL* mem_pool)
{
struct data_buffer rbuf;
//发一个数据包长度
if(socket_write(socket_fd,dbuf->data,dbuf->data_len) <= 0)
return -1;
//接受命名
memset(&rbuf,0,sizeof(struct data_buffer));
rbuf.data_len = sizeof(uint32_t);
rbuf.size = rbuf.data_len;
rbuf.data = (uint8_t *)mem_pool_malloc(mem_pool,sizeof(uint32_t));
if(socket_read(socket_fd,rbuf.data,rbuf.data_len) <= 0)
return -1;
rbuf.data_len = read_int32(&rbuf);
rbuf.data = (uint8_t *)mem_pool_malloc(mem_pool,rbuf.data_len);
rbuf.rpos = 0;
rbuf.size = rbuf.data_len;
if(socket_read(socket_fd,rbuf.data,rbuf.data_len) <= 0)
return -1;
rbuf.rpos += MESSAGE_HEAD_LEN;
uint16_t type = message_type(&rbuf);
if (type != MT_DC_STAT_RS)
return -1;
uint16_t field_count = read_int16(&rbuf);
uint16_t i;
char* field_name = NULL;
fprintf(stderr,"%-20s%-20s%-20s%-20s\n","FIELD_NAME","INDEX_TYPE","DATA_TYPE","FLAG");
uint8_t j;
uint8_t index_num;
for(i=0; i<field_count; i++)
{
field_name = read_cstring(&rbuf,mem_pool);
index_num = read_int8(&rbuf);
for(j=0;j < index_num; j++)
{
fprintf(stderr,"%-20s",field_name);
fprintf(stderr,"%-20u",read_int8(&rbuf));
fprintf(stderr,"%-20u",read_int8(&rbuf));
fprintf(stderr,"%-20u\n",read_int8(&rbuf));
}
}
return 0;
}
static int8_t SPICE_GNUC_UNUSED consume_int8(uint8_t **ptr)
{
int8_t val;
val = read_int8(*ptr);
*ptr += 1;
return val;
}
static guint32
read_int32 (AniLoaderContext *context)
{
guint32 result;
read_int8 (context, (guchar*) &result, 4);
return lsb_32 ((guchar *) &result);
}
int32_t execute_segment_stat_handle(struct data_buffer* dbuf,int socket_fd,MEM_POOL* mem_pool)
{
struct data_buffer rbuf;
//发数据包
if(socket_write(socket_fd,dbuf->data,dbuf->data_len) <= 0)
return -1;
//接受命名
memset(&rbuf,0,sizeof(struct data_buffer));
rbuf.data_len = sizeof(uint32_t);
rbuf.size = rbuf.data_len;
rbuf.data = (uint8_t *)mem_pool_malloc(mem_pool,sizeof(uint32_t));
if(socket_read(socket_fd,rbuf.data,rbuf.data_len) <= 0)
return -1;
rbuf.data_len = read_int32(&rbuf);
rbuf.data = (uint8_t *)mem_pool_malloc(mem_pool,rbuf.data_len);
rbuf.rpos = 0;
rbuf.size = rbuf.data_len;
if(socket_read(socket_fd,rbuf.data,rbuf.data_len) <= 0)
return -1;
rbuf.rpos += MESSAGE_HEAD_LEN;
uint16_t type = message_type(&rbuf);
if (type != MT_DC_STAT_RS)
return -1;
uint16_t segment_count = read_int16(&rbuf);
uint16_t i;
fprintf(stderr,"%-20s%-20s%-20s%-20s%-20s%-20s%-20s\n","SEGMENT_ID","CREATE_TIME","MODIFY_TIME","CHECKPOINT_TIME","FLAG","ROW_COUNT","DEL_COUNT");
for(i=0; i<segment_count; i++)
{
fprintf(stderr,"%-20u",read_int16(&rbuf));
fprintf(stderr,"%-20llu",read_int64(&rbuf));
fprintf(stderr,"%-20llu",read_int64(&rbuf));
fprintf(stderr,"%-20llu",read_int64(&rbuf));
fprintf(stderr,"%-20u",read_int8(&rbuf));
fprintf(stderr,"%-20u",read_int32(&rbuf));
fprintf(stderr,"%-20u\n",read_int32(&rbuf));
}
return 0;
}
static jl_methlist_t *jl_deserialize_methlist(ios_t *s)
{
jl_methlist_t *ml = NULL;
jl_methlist_t **pnext = &ml;
while (1) {
jl_value_t *sig = jl_deserialize_value(s);
if (sig == NULL)
break;
jl_methlist_t *node = (jl_methlist_t*)allocb(sizeof(jl_methlist_t));
node->sig = (jl_tuple_t*)sig;
assert(jl_is_tuple(sig));
node->va = read_int8(s);
node->tvars = (jl_tuple_t*)jl_deserialize_value(s);
node->func = (jl_function_t*)jl_deserialize_value(s);
node->invokes = (jl_methtable_t*)jl_deserialize_value(s);
node->next = NULL;
*pnext = node;
pnext = &node->next;
}
return ml;
}
TEST(DATA_BUFFER_TEST, READ_AND_WRITE){
MEM_POOL_PTR pMemPool = mem_pool_init(MB_SIZE);
struct data_buffer* buffer = init_data_buffer();
buffer->data_len = 256;
buffer->data = (uint8*) mem_pool_malloc(pMemPool, 256);
uint8 tmp8;
uint16 tmp16;
uint32 tmp32;
uint64 tmp64;
char* str = (char*) mem_pool_malloc(pMemPool, 100);
char* result = (char*) mem_pool_malloc(pMemPool, 100);
strcpy(str, "hello world!");
write_int8(122, buffer);
write_int16(1111, buffer);
write_int32(324, buffer);
write_int64(2321, buffer);
write_bytes((uint8*)str, strlen(str)+1, buffer);
tmp8 = read_int8(buffer);
ASSERT_EQ(tmp8, 122);
tmp16 = read_int16(buffer);
ASSERT_EQ(tmp16, 1111);
tmp32 = read_int32(buffer);
ASSERT_EQ(tmp32, 324);
tmp64 = read_int64(buffer);
ASSERT_EQ(tmp64, 2321);
read_bytes(buffer, (uint8*)result, strlen(str)+1);
ASSERT_EQ(0, strcmp(str, result));
destroy_data_buffer(buffer);
mem_pool_destroy(pMemPool);
}
static jl_value_t *jl_deserialize_value(ios_t *s)
{
int pos = ios_pos(s);
int32_t tag = read_uint8(s);
if (tag == Null_tag)
return NULL;
if (tag == 0) {
tag = read_uint8(s);
return (jl_value_t*)ptrhash_get(&deser_tag, (void*)(ptrint_t)tag);
}
if (tag == BackRef_tag) {
assert(tree_literal_values == NULL);
ptrint_t offs = read_int32(s);
void **bp = ptrhash_bp(&backref_table, (void*)(ptrint_t)offs);
assert(*bp != HT_NOTFOUND);
return (jl_value_t*)*bp;
}
jl_value_t *vtag=(jl_value_t*)ptrhash_get(&deser_tag,(void*)(ptrint_t)tag);
if (tag >= VALUE_TAGS) {
return vtag;
}
int usetable = (tree_literal_values == NULL);
size_t i;
if (vtag == (jl_value_t*)jl_tuple_type ||
vtag == (jl_value_t*)LongTuple_tag) {
size_t len;
if (vtag == (jl_value_t*)jl_tuple_type)
len = read_uint8(s);
else
len = read_int32(s);
jl_tuple_t *tu = jl_alloc_tuple_uninit(len);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, (jl_value_t*)tu);
for(i=0; i < len; i++)
jl_tupleset(tu, i, jl_deserialize_value(s));
return (jl_value_t*)tu;
}
else if (vtag == (jl_value_t*)jl_symbol_type ||
vtag == (jl_value_t*)LongSymbol_tag) {
size_t len;
if (vtag == (jl_value_t*)jl_symbol_type)
len = read_uint8(s);
else
len = read_int32(s);
char *name = alloca(len+1);
ios_read(s, name, len);
name[len] = '\0';
jl_value_t *s = (jl_value_t*)jl_symbol(name);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, s);
return s;
}
else if (vtag == (jl_value_t*)jl_array_type) {
jl_value_t *aty = jl_deserialize_value(s);
jl_value_t *elty = jl_tparam0(aty);
int16_t ndims = jl_unbox_long(jl_tparam1(aty));
size_t *dims = alloca(ndims*sizeof(size_t));
for(i=0; i < ndims; i++)
dims[i] = jl_unbox_long(jl_deserialize_value(s));
jl_array_t *a = jl_new_array_((jl_type_t*)aty, ndims, dims);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, (jl_value_t*)a);
if (jl_is_bits_type(elty)) {
size_t tot = a->length * a->elsize;
ios_read(s, a->data, tot);
}
else {
for(i=0; i < a->length; i++) {
((jl_value_t**)a->data)[i] = jl_deserialize_value(s);
}
}
return (jl_value_t*)a;
}
else if (vtag == (jl_value_t*)jl_expr_type ||
vtag == (jl_value_t*)LongExpr_tag) {
size_t len;
if (vtag == (jl_value_t*)jl_expr_type)
len = read_uint8(s);
else
len = read_int32(s);
jl_expr_t *e = jl_exprn((jl_sym_t*)jl_deserialize_value(s), len);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, (jl_value_t*)e);
e->etype = jl_deserialize_value(s);
for(i=0; i < len; i++) {
jl_cellset(e->args, i, jl_deserialize_value(s));
}
return (jl_value_t*)e;
}
else if (vtag == (jl_value_t*)LiteralVal_tag) {
return jl_cellref(tree_literal_values, read_uint16(s));
}
else if (vtag == (jl_value_t*)jl_tvar_type) {
jl_tvar_t *tv = (jl_tvar_t*)newobj((jl_type_t*)jl_tvar_type, 4);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, tv);
tv->name = (jl_sym_t*)jl_deserialize_value(s);
tv->lb = jl_deserialize_value(s);
tv->ub = jl_deserialize_value(s);
tv->bound = read_int8(s);
return (jl_value_t*)tv;
}
else if (vtag == (jl_value_t*)jl_func_kind) {
jl_value_t *ftype = jl_deserialize_value(s);
jl_function_t *f = (jl_function_t*)newobj((jl_type_t*)ftype, 3);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, f);
f->linfo = (jl_lambda_info_t*)jl_deserialize_value(s);
f->env = jl_deserialize_value(s);
f->fptr = jl_deserialize_fptr(s);
if (f->fptr == NULL) {
f->fptr = &jl_trampoline;
}
return (jl_value_t*)f;
}
else if (vtag == (jl_value_t*)jl_lambda_info_type) {
jl_lambda_info_t *li =
(jl_lambda_info_t*)newobj((jl_type_t*)jl_lambda_info_type,
LAMBDA_INFO_NW);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, li);
li->ast = jl_deserialize_value(s);
li->sparams = (jl_tuple_t*)jl_deserialize_value(s);
li->tfunc = jl_deserialize_value(s);
li->name = (jl_sym_t*)jl_deserialize_value(s);
li->specTypes = jl_deserialize_value(s);
li->specializations = (jl_array_t*)jl_deserialize_value(s);
li->inferred = jl_deserialize_value(s);
li->file = jl_deserialize_value(s);
li->line = jl_deserialize_value(s);
li->module = (jl_module_t*)jl_deserialize_value(s);
li->fptr = NULL;
li->roots = NULL;
li->functionObject = NULL;
li->inInference = 0;
li->inCompile = 0;
li->unspecialized = NULL;
return (jl_value_t*)li;
}
else if (vtag == (jl_value_t*)jl_module_type) {
jl_module_t *m = jl_new_module(anonymous_sym);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, m);
m->name = (jl_sym_t*)jl_deserialize_value(s);
while (1) {
jl_value_t *name = jl_deserialize_value(s);
if (name == NULL)
break;
jl_binding_t *b = jl_get_binding_wr(m, (jl_sym_t*)name);
b->value = jl_deserialize_value(s);
b->type = (jl_type_t*)jl_deserialize_value(s);
b->constp = read_int8(s);
b->exportp = read_int8(s);
}
while (1) {
jl_value_t *name = jl_deserialize_value(s);
if (name == NULL)
break;
jl_set_expander(m, (jl_sym_t*)name,
(jl_function_t*)jl_deserialize_value(s));
}
return (jl_value_t*)m;
}
else if (vtag == (jl_value_t*)jl_methtable_type) {
jl_methtable_t *mt = (jl_methtable_t*)allocobj(sizeof(jl_methtable_t));
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, mt);
mt->type = (jl_type_t*)jl_methtable_type;
mt->defs = jl_deserialize_methlist(s);
mt->cache = jl_deserialize_methlist(s);
mt->cache_1arg = (jl_array_t*)jl_deserialize_value(s);
mt->max_args = read_int32(s);
return (jl_value_t*)mt;
}
else if (vtag == (jl_value_t*)SmallInt64_tag) {
jl_value_t *v = jl_box_int64(read_int32(s));
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, v);
return v;
}
else if (vtag == (jl_value_t*)jl_bits_kind) {
jl_bits_type_t *bt = (jl_bits_type_t*)jl_deserialize_value(s);
int nby = bt->nbits/8;
char *data = alloca(nby);
ios_read(s, data, nby);
jl_value_t *v=NULL;
if (bt == jl_int32_type)
v = jl_box_int32(*(int32_t*)data);
else if (bt == jl_int64_type)
v = jl_box_int64(*(int64_t*)data);
else if (bt == jl_bool_type)
v = jl_box_bool(*(int8_t*)data);
else {
switch (bt->nbits) {
case 8: v = jl_box8 (bt, *(int8_t*) data); break;
case 16: v = jl_box16(bt, *(int16_t*)data); break;
case 32: v = jl_box32(bt, *(int32_t*)data); break;
case 64: v = jl_box64(bt, *(int64_t*)data); break;
default:
v = (jl_value_t*)allocobj(sizeof(void*)+nby);
v->type = (jl_type_t*)bt;
memcpy(jl_bits_data(v), data, nby);
}
}
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, v);
return v;
}
else if (vtag == (jl_value_t*)jl_struct_kind) {
jl_struct_type_t *typ = (jl_struct_type_t*)jl_deserialize_value(s);
if (typ == jl_struct_kind || typ == jl_bits_kind)
return jl_deserialize_tag_type(s, typ, pos);
size_t nf = typ->names->length;
jl_value_t *v = jl_new_struct_uninit(typ);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, v);
for(i=0; i < nf; i++) {
((jl_value_t**)v)[i+1] = jl_deserialize_value(s);
}
// TODO: put WeakRefs on the weak_refs list
return v;
}
else if (vtag == (jl_value_t*)jl_tag_kind) {
return jl_deserialize_tag_type(s, jl_tag_kind, pos);
}
assert(0);
return NULL;
}
static jl_value_t *jl_deserialize_value(ios_t *s)
{
int pos = ios_pos(s);
int32_t tag = read_uint8(s);
if (tag == Null_tag)
return NULL;
if (tag == 0) {
tag = read_uint8(s);
jl_value_t *v = ptrhash_get(&deser_tag, (void*)(ptrint_t)tag);
assert(v != HT_NOTFOUND);
return v;
}
if (tag == BackRef_tag || tag == ShortBackRef_tag) {
assert(tree_literal_values == NULL);
ptrint_t offs = (tag == BackRef_tag) ? read_int32(s) : read_uint16(s);
void **bp = ptrhash_bp(&backref_table, (void*)(ptrint_t)offs);
assert(*bp != HT_NOTFOUND);
return (jl_value_t*)*bp;
}
jl_value_t *vtag=(jl_value_t*)ptrhash_get(&deser_tag,(void*)(ptrint_t)tag);
if (tag >= VALUE_TAGS) {
return vtag;
}
int usetable = (tree_literal_values == NULL);
size_t i;
if (vtag == (jl_value_t*)jl_tuple_type ||
vtag == (jl_value_t*)LongTuple_tag) {
size_t len;
if (vtag == (jl_value_t*)jl_tuple_type)
len = read_uint8(s);
else
len = read_int32(s);
jl_tuple_t *tu = jl_alloc_tuple_uninit(len);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, (jl_value_t*)tu);
for(i=0; i < len; i++)
jl_tupleset(tu, i, jl_deserialize_value(s));
return (jl_value_t*)tu;
}
else if (vtag == (jl_value_t*)jl_symbol_type ||
vtag == (jl_value_t*)LongSymbol_tag) {
size_t len;
if (vtag == (jl_value_t*)jl_symbol_type)
len = read_uint8(s);
else
len = read_int32(s);
char *name = alloca(len+1);
ios_read(s, name, len);
name[len] = '\0';
jl_value_t *s = (jl_value_t*)jl_symbol(name);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, s);
return s;
}
else if (vtag == (jl_value_t*)jl_array_type) {
jl_value_t *aty = jl_deserialize_value(s);
jl_value_t *elty = jl_tparam0(aty);
int16_t ndims = jl_unbox_long(jl_tparam1(aty));
size_t *dims = alloca(ndims*sizeof(size_t));
for(i=0; i < ndims; i++)
dims[i] = jl_unbox_long(jl_deserialize_value(s));
jl_array_t *a = jl_new_array_((jl_type_t*)aty, ndims, dims);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, (jl_value_t*)a);
if (jl_is_bits_type(elty)) {
size_t tot = jl_array_len(a) * a->elsize;
ios_read(s, jl_array_data(a), tot);
}
else {
for(i=0; i < jl_array_len(a); i++) {
((jl_value_t**)a->data)[i] = jl_deserialize_value(s);
}
}
return (jl_value_t*)a;
}
else if (vtag == (jl_value_t*)jl_expr_type ||
vtag == (jl_value_t*)LongExpr_tag) {
size_t len;
if (vtag == (jl_value_t*)jl_expr_type)
len = read_uint8(s);
else
len = read_int32(s);
jl_expr_t *e = jl_exprn((jl_sym_t*)jl_deserialize_value(s), len);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, (jl_value_t*)e);
e->etype = jl_deserialize_value(s);
for(i=0; i < len; i++) {
jl_cellset(e->args, i, jl_deserialize_value(s));
}
return (jl_value_t*)e;
}
else if (vtag == (jl_value_t*)LiteralVal_tag) {
return jl_cellref(tree_literal_values, read_uint16(s));
}
else if (vtag == (jl_value_t*)jl_tvar_type) {
jl_tvar_t *tv = (jl_tvar_t*)newobj((jl_type_t*)jl_tvar_type, 4);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, tv);
tv->name = (jl_sym_t*)jl_deserialize_value(s);
tv->lb = jl_deserialize_value(s);
tv->ub = jl_deserialize_value(s);
tv->bound = read_int8(s);
return (jl_value_t*)tv;
}
else if (vtag == (jl_value_t*)jl_function_type) {
jl_function_t *f =
(jl_function_t*)newobj((jl_type_t*)jl_function_type, 3);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, f);
f->linfo = (jl_lambda_info_t*)jl_deserialize_value(s);
f->env = jl_deserialize_value(s);
f->fptr = jl_deserialize_fptr(s);
return (jl_value_t*)f;
}
else if (vtag == (jl_value_t*)jl_lambda_info_type) {
jl_lambda_info_t *li =
(jl_lambda_info_t*)newobj((jl_type_t*)jl_lambda_info_type,
LAMBDA_INFO_NW);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, li);
li->ast = jl_deserialize_value(s);
li->sparams = (jl_tuple_t*)jl_deserialize_value(s);
li->tfunc = jl_deserialize_value(s);
li->name = (jl_sym_t*)jl_deserialize_value(s);
li->specTypes = (jl_tuple_t*)jl_deserialize_value(s);
li->specializations = (jl_array_t*)jl_deserialize_value(s);
li->inferred = read_int8(s);
li->file = jl_deserialize_value(s);
li->line = read_int32(s);
li->module = (jl_module_t*)jl_deserialize_value(s);
li->roots = (jl_array_t*)jl_deserialize_value(s);
li->def = (jl_lambda_info_t*)jl_deserialize_value(s);
li->capt = jl_deserialize_value(s);
li->fptr = &jl_trampoline;
li->functionObject = NULL;
li->cFunctionObject = NULL;
li->inInference = 0;
li->inCompile = 0;
li->unspecialized = NULL;
return (jl_value_t*)li;
}
else if (vtag == (jl_value_t*)jl_module_type) {
jl_sym_t *mname = (jl_sym_t*)jl_deserialize_value(s);
jl_module_t *m = jl_new_module(mname);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, m);
m->parent = (jl_module_t*)jl_deserialize_value(s);
while (1) {
jl_value_t *name = jl_deserialize_value(s);
if (name == NULL)
break;
jl_binding_t *b = jl_get_binding_wr(m, (jl_sym_t*)name);
b->value = jl_deserialize_value(s);
b->type = (jl_type_t*)jl_deserialize_value(s);
b->owner = (jl_module_t*)jl_deserialize_value(s);
int8_t flags = read_int8(s);
b->constp = (flags>>2) & 1;
b->exportp = (flags>>1) & 1;
b->imported = (flags) & 1;
}
size_t ni = read_int32(s);
for(size_t i=0; i < ni; i++) {
arraylist_push(&m->usings, jl_deserialize_value(s));
}
return (jl_value_t*)m;
}
static int reader_int8(lua_State* L)
{
reader_t* reader = lua_touserdata(L, 1);
lua_pushinteger(L, (lua_Integer)read_int8(reader));
return 1;
}
int
bson_decoder_next(bson_decoder_t decoder)
{
int8_t tbyte;
int32_t tint;
unsigned nlen;
CODER_CHECK(decoder);
/* if the previous node was EOO, pop a nesting level */
if (decoder->node.type == BSON_EOO) {
if (decoder->nesting > 0) {
decoder->nesting--;
}
/* if the nesting level is now zero, the top-level document is done */
if (decoder->nesting == 0) {
/* like kill but not an error */
debug("nesting is zero, document is done");
decoder->fd = -1;
/* return end-of-file to the caller */
return 0;
}
}
/* if there are unread bytes pending in the stream, discard them */
while (decoder->pending > 0) {
if (read_int8(decoder, &tbyte)) {
CODER_KILL(decoder, "read error discarding pending bytes");
}
decoder->pending--;
}
/* get the type byte */
if (read_int8(decoder, &tbyte)) {
CODER_KILL(decoder, "read error on type byte");
}
decoder->node.type = tbyte;
decoder->pending = 0;
debug("got type byte 0x%02x", decoder->node.type);
/* EOO is special; it has no name/data following */
if (decoder->node.type == BSON_EOO) {
decoder->node.name[0] = '\0';
} else {
/* get the node name */
nlen = 0;
for (;;) {
if (nlen >= BSON_MAXNAME) {
CODER_KILL(decoder, "node name overflow");
}
if (read_int8(decoder, (int8_t *)&decoder->node.name[nlen])) {
CODER_KILL(decoder, "read error on node name");
}
if (decoder->node.name[nlen] == '\0') {
break;
}
nlen++;
}
debug("got name '%s'", decoder->node.name);
switch (decoder->node.type) {
case BSON_BOOL:
if (read_int8(decoder, &tbyte)) {
CODER_KILL(decoder, "read error on BSON_BOOL");
}
decoder->node.b = (tbyte != 0);
break;
case BSON_INT32:
if (read_int32(decoder, &tint)) {
CODER_KILL(decoder, "read error on BSON_INT");
}
decoder->node.i = tint;
break;
case BSON_INT64:
if (read_int64(decoder, &decoder->node.i)) {
CODER_KILL(decoder, "read error on BSON_INT");
}
break;
case BSON_DOUBLE:
if (read_double(decoder, &decoder->node.d)) {
CODER_KILL(decoder, "read error on BSON_DOUBLE");
}
break;
case BSON_STRING:
if (read_int32(decoder, &decoder->pending)) {
CODER_KILL(decoder, "read error on BSON_STRING length");
}
break;
case BSON_BINDATA:
if (read_int32(decoder, &decoder->pending)) {
CODER_KILL(decoder, "read error on BSON_BINDATA size");
}
if (read_int8(decoder, &tbyte)) {
CODER_KILL(decoder, "read error on BSON_BINDATA subtype");
}
decoder->node.subtype = tbyte;
break;
/* XXX currently not supporting other types */
default:
CODER_KILL(decoder, "unsupported node type");
}
}
/* call the callback and pass its results back */
return decoder->callback(decoder, decoder->priv, &decoder->node);
}
int32_t parse_mile_message(struct mile_packet *packet, void **bl_reader,
int16_t exceed_cpu_used, MEM_POOL_PTR session_mem) {
int32_t result_code = MILE_RETURN_SUCCESS;
//读buffer和写buffer
struct data_buffer* rbuf = packet->rbuf;
struct data_buffer* sbuf = packet->sbuf;
//读取消息头
struct mile_message_header msg_head;
//当前时间与超时时间
uint64_t now_time;
uint64_t deadline_time;
if (rbuf == NULL) {
log_error("严重错误, 读buffer为空!");
return ERROR_PACKET_FORMAT;
}
msg_head.version_major = read_int8(rbuf);
msg_head.version_minor = read_int8(rbuf);
msg_head.message_type = read_int16(rbuf);
msg_head.message_id = read_int32(rbuf);
packet->timeout = read_int32(rbuf);
log_debug(
"数据包包头信息 -- 主版本号: %d, 小版本号: %d, 消息类型: 0x%x, 消息id: %d, 超时: %d", msg_head.version_major, msg_head.version_minor, msg_head.message_type, msg_head.message_id, packet->timeout);
now_time = get_time_msec();
if (packet->timeout != 0
&& now_time - packet->launch_time / 1000 > packet->timeout) {
log_warn(
"执行sql超时, 收到sql命令时的时间 %llu, 当前时间 %llu, 超时时间 %u", packet->launch_time / 1000, now_time, packet->timeout);
return ERROR_TIMEOUT;
} else {
deadline_time = now_time + packet->timeout;
}
uint16_t msg_head_type = (msg_head.message_type & 0xFF00);
if (msg_head_type == MT_VG_MD) {
result_code = process_mergeserver_message(&msg_head, rbuf, sbuf,
exceed_cpu_used, deadline_time);
} else if (msg_head_type == MT_VG_SC) {
result_code = StorageEngine::storage->Command(&msg_head, rbuf, sbuf);
if (MILE_RETURN_SUCCESS != result_code)
gen_docserver_client_error_packet(result_code, &msg_head, sbuf);
} else if (msg_head_type == MT_VG_CD) {
result_code = process_client_message(&msg_head, rbuf, sbuf);
} else if (msg_head_type == MT_VG_SM) {
result_code = process_master_message(&msg_head, rbuf, sbuf, bl_reader,
session_mem);
} else if (msg_head_type == MT_VG_TEST_REQ) {
result_code = process_test_message(&msg_head, rbuf, sbuf);
} else {
result_code = -1;
}
if (result_code != MILE_RETURN_SUCCESS) {
log_error(
"执行过程中出错, 错误码 %d, 错误原因 %s", result_code, error_msg(result_code));
}
return result_code;
}
long long evaluate(TERM* term, EVALUATION_CONTEXT* context)
{
size_t offs, hi_bound, lo_bound;
long long op1;
long long op2;
long long index;
unsigned int i;
unsigned int needed;
unsigned int satisfied;
int ovector[3];
int rc;
STRING* string;
STRING* saved_anonymous_string;
TERM_CONST* term_const = ((TERM_CONST*) term);
TERM_UNARY_OPERATION* term_unary = ((TERM_UNARY_OPERATION*) term);
TERM_BINARY_OPERATION* term_binary = ((TERM_BINARY_OPERATION*) term);
TERM_TERNARY_OPERATION* term_ternary = ((TERM_TERNARY_OPERATION*) term);
TERM_STRING* term_string = ((TERM_STRING*) term);
TERM_VARIABLE* term_variable = ((TERM_VARIABLE*) term);
TERM_STRING_OPERATION* term_string_operation = ((TERM_STRING_OPERATION*) term);
TERM_INTEGER_FOR* term_integer_for;
MATCH* match;
TERM* item;
TERM_RANGE* range;
TERM_ITERABLE* items;
TERM_STRING* t;
switch(term->type)
{
case TERM_TYPE_CONST:
return term_const->value;
case TERM_TYPE_FILESIZE:
return context->file_size;
case TERM_TYPE_ENTRYPOINT:
return context->entry_point;
case TERM_TYPE_RULE:
return evaluate(term_binary->op1, context);
case TERM_TYPE_STRING:
if (term_string->string == NULL) /* it's an anonymous string */
{
string = context->current_string;
}
else
{
string = term_string->string;
}
return string->flags & STRING_FLAGS_FOUND;
case TERM_TYPE_STRING_AT:
if (term_string->string == NULL) /* it's an anonymous string */
{
string = context->current_string;
}
else
{
string = term_string->string;
}
if (string->flags & STRING_FLAGS_FOUND)
{
offs = evaluate(term_string->offset, context);
match = string->matches_head;
while (match != NULL)
{
if (match->offset == offs)
return 1;
match = match->next;
}
return 0;
}
else return 0;
case TERM_TYPE_STRING_IN_RANGE:
if (term_string->string == NULL) /* it's an anonymous string */
{
string = context->current_string;
}
else
{
string = term_string->string;
}
if (string->flags & STRING_FLAGS_FOUND)
{
range = (TERM_RANGE*) term_string->range;
lo_bound = evaluate(range->min, context);
hi_bound = evaluate(range->max, context);
match = string->matches_head;
while (match != NULL)
{
if (match->offset >= lo_bound && match->offset <= hi_bound)
return 1;
match = match->next;
}
return 0;
}
else return 0;
case TERM_TYPE_STRING_IN_SECTION_BY_NAME:
return 0; /*TODO: Implementar section by name*/
case TERM_TYPE_STRING_COUNT:
i = 0;
if (term_string->string == NULL) /* it's an anonymous string */
{
string = context->current_string;
}
else
{
string = term_string->string;
}
match = string->matches_head;
while (match != NULL)
{
i++;
match = match->next;
}
return i;
case TERM_TYPE_STRING_OFFSET:
i = 1;
index = evaluate(term_string->index, context);
if (term_string->string == NULL) /* it's an anonymous string */
{
string = context->current_string;
}
else
{
string = term_string->string;
}
match = string->matches_head;
while (match != NULL && i < index)
{
match = match->next;
i++;
}
if (match != NULL && i == index)
{
return match->offset;
}
return UNDEFINED;
case TERM_TYPE_AND:
if (evaluate(term_binary->op1, context))
return evaluate(term_binary->op2, context);
else
return 0;
case TERM_TYPE_OR:
if (evaluate(term_binary->op1, context))
return 1;
else
return evaluate(term_binary->op2, context);
case TERM_TYPE_NOT:
return !evaluate(term_unary->op, context);
case TERM_TYPE_ADD:
ARITHMETIC_OPERATOR(+, term_binary, context);
case TERM_TYPE_SUB:
ARITHMETIC_OPERATOR(-, term_binary, context);
case TERM_TYPE_MUL:
ARITHMETIC_OPERATOR(*, term_binary, context);
case TERM_TYPE_DIV:
ARITHMETIC_OPERATOR(/, term_binary, context);
case TERM_TYPE_BITWISE_AND:
ARITHMETIC_OPERATOR(&, term_binary, context);
case TERM_TYPE_BITWISE_OR:
ARITHMETIC_OPERATOR(|, term_binary, context);
case TERM_TYPE_SHIFT_LEFT:
ARITHMETIC_OPERATOR(<<, term_binary, context);
case TERM_TYPE_SHIFT_RIGHT:
ARITHMETIC_OPERATOR(>>, term_binary, context);
case TERM_TYPE_BITWISE_NOT:
op1 = evaluate(term_unary->op, context);
if (IS_UNDEFINED(op1))
return UNDEFINED;
else
return ~op1;
case TERM_TYPE_GT:
COMPARISON_OPERATOR(>, term_binary, context);
case TERM_TYPE_LT:
COMPARISON_OPERATOR(<, term_binary, context);
case TERM_TYPE_GE:
COMPARISON_OPERATOR(>=, term_binary, context);
case TERM_TYPE_LE:
COMPARISON_OPERATOR(<=, term_binary, context);
case TERM_TYPE_EQ:
COMPARISON_OPERATOR(==, term_binary, context);
case TERM_TYPE_NOT_EQ:
COMPARISON_OPERATOR(!=, term_binary, context);
case TERM_TYPE_OF:
t = (TERM_STRING*) term_binary->op2;
needed = evaluate(term_binary->op1, context);
satisfied = 0;
i = 0;
while (t != NULL)
{
if (evaluate((TERM*) t, context))
{
satisfied++;
}
t = t->next;
i++;
}
if (needed == 0) /* needed == 0 means ALL*/
needed = i;
return (satisfied >= needed);
case TERM_TYPE_STRING_FOR:
t = (TERM_STRING*) term_ternary->op2;
needed = evaluate(term_ternary->op1, context);
satisfied = 0;
i = 0;
while (t != NULL)
{
saved_anonymous_string = context->current_string;
context->current_string = t->string;
if (evaluate(term_ternary->op3, context))
{
satisfied++;
}
context->current_string = saved_anonymous_string;
t = t->next;
i++;
}
if (needed == 0) /* needed == 0 means ALL*/
needed = i;
return (satisfied >= needed);
case TERM_TYPE_INTEGER_FOR:
term_integer_for = (TERM_INTEGER_FOR*) term;
items = term_integer_for->items;
needed = evaluate(term_integer_for->count, context);
satisfied = 0;
i = 0;
item = items->first(items, evaluate, context);
while (item != NULL)
{
term_integer_for->variable->integer = evaluate(item, context);
if (evaluate(term_integer_for->expression, context))
{
satisfied++;
}
item = items->next(items, evaluate, context);
i++;
}
if (needed == 0) /* needed == 0 means ALL*/
needed = i;
return (satisfied >= needed);
case TERM_TYPE_UINT8_AT_OFFSET:
return read_uint8(context->mem_block, evaluate(term_unary->op, context));
case TERM_TYPE_UINT16_AT_OFFSET:
return read_uint16(context->mem_block, evaluate(term_unary->op, context));
case TERM_TYPE_UINT32_AT_OFFSET:
return read_uint32(context->mem_block, evaluate(term_unary->op, context));
case TERM_TYPE_INT8_AT_OFFSET:
return read_int8(context->mem_block, evaluate(term_unary->op, context));
case TERM_TYPE_INT16_AT_OFFSET:
return read_int16(context->mem_block, evaluate(term_unary->op, context));
case TERM_TYPE_INT32_AT_OFFSET:
return read_int32(context->mem_block, evaluate(term_unary->op, context));
case TERM_TYPE_VARIABLE:
if (term_variable->variable->type == VARIABLE_TYPE_STRING)
{
return ( term_variable->variable->string != NULL && *term_variable->variable->string != '\0');
}
else
{
return term_variable->variable->integer;
}
case TERM_TYPE_STRING_MATCH:
rc = regex_exec(&(term_string_operation->re),
FALSE,
term_string_operation->variable->string,
strlen(term_string_operation->variable->string));
return (rc >= 0);
case TERM_TYPE_STRING_CONTAINS:
return (strstr(term_string_operation->variable->string, term_string_operation->string) != NULL);
default:
return 0;
}
}