int32_t process_test_message(struct mile_message_header* msg_head, struct data_buffer* rbuf, struct data_buffer* sbuf) { int32_t result_code = MILE_RETURN_SUCCESS; MEM_POOL_PTR mem_pool; switch (msg_head->message_type) { case MT_TEST_REQ_ECHO: // echo message for testing. { mem_pool = mem_pool_init(MB_SIZE); const char *str = read_cstring(rbuf, mem_pool); log_debug("get echo message [%s]", str); write_int32(0, sbuf); write_int8(msg_head->version_major, sbuf); write_int8(msg_head->version_minor, sbuf); write_int16(MT_TEST_RES_ECHO, sbuf); write_int32(msg_head->message_id, sbuf); write_int32(strlen(str), sbuf); write_bytes((uint8_t *) str, strlen(str), sbuf); fill_int32(sbuf->data_len, sbuf, 0); result_code = MILE_RETURN_SUCCESS; mem_pool_destroy(mem_pool); } break; default: result_code = -1; break; } return result_code; }
int bson_encoder_append_int(bson_encoder_t encoder, const char *name, int64_t value) { bool result; CODER_CHECK(encoder); /* use the smallest encoding that will hold the value */ if (value == (int32_t)value) { debug("encoding %lld as int32", value); result = write_int8(encoder, BSON_INT32) || write_name(encoder, name) || write_int32(encoder, value); } else { debug("encoding %lld as int64", value); result = write_int8(encoder, BSON_INT64) || write_name(encoder, name) || write_int64(encoder, value); } if (result) { CODER_KILL(encoder, "write error on BSON_INT"); } return 0; }
static void jl_serialize_module(ios_t *s, jl_module_t *m) { // set on every startup; don't save jl_sym_t *jhsym = jl_symbol("JULIA_HOME"); writetag(s, jl_module_type); jl_serialize_value(s, m->name); jl_serialize_value(s, m->parent); size_t i; void **table = m->bindings.table; for(i=1; i < m->bindings.size; i+=2) { if (table[i] != HT_NOTFOUND && !(table[i-1] == jhsym && m == jl_core_module)) { jl_binding_t *b = (jl_binding_t*)table[i]; jl_serialize_value(s, b->name); jl_serialize_value(s, b->value); jl_serialize_value(s, b->type); jl_serialize_value(s, b->owner); write_int8(s, b->constp); write_int8(s, b->exportp); } } jl_serialize_value(s, NULL); if (m == jl_main_module) { write_int32(s, 1); jl_serialize_value(s, (jl_value_t*)jl_core_module); } else { write_int32(s, m->imports.len); for(i=0; i < m->imports.len; i++) { jl_serialize_value(s, (jl_value_t*)m->imports.items[i]); } } }
struct data_buffer* gen_set_load_threshold_packet(char* cmd,MEM_POOL* mem_pool) { struct data_buffer *dbuf = init_data_buffer(); size_t data_len = MESSAGE_HEAD_LEN + 2*sizeof(uint32_t) + sizeof(double); databuf_resize(dbuf, data_len); //写入数据长度 write_int32(data_len,dbuf); write_int8(1, dbuf); write_int8(1, dbuf); write_int16(MT_CD_EXE_SET_LOAD_THRESHOLD, dbuf); write_int32(0, dbuf); //timeout write_int32(0, dbuf); char *value_str = strtok(NULL, " "); if (!value_str) return NULL; double value = atof(value_str); write_bytes((uint8_t *)&value, sizeof(value), dbuf); return dbuf; }
struct data_buffer* gen_stat_packet(char* cmd,uint8_t* type,MEM_POOL* mem_pool) { char* table_name = NULL; char* token = NULL; uint32_t tblen; if((table_name = strtok(NULL," ")) == NULL) return NULL; tblen = strlen(table_name); if((token = strtok(NULL," ")) == NULL) return NULL; *type = atoi(token); struct data_buffer *dbuf = init_data_buffer(); size_t data_len = tblen + 5 * sizeof(uint8_t) + MESSAGE_HEAD_LEN + 2*sizeof(uint32_t); databuf_resize(dbuf, data_len); //写入数据长度 write_int32(data_len,dbuf); write_int8(1, dbuf); write_int8(1, dbuf); write_int16(MT_CD_STAT, dbuf); write_int32(0, dbuf); //timeout write_int32(0, dbuf); //拼接协议包 write_int32(tblen,dbuf); write_bytes((uint8_t*)table_name,tblen,dbuf); write_int8(*type,dbuf); return dbuf; }
static void jl_serialize_module(ios_t *s, jl_module_t *m) { writetag(s, jl_module_type); jl_serialize_value(s, m->name); size_t i; void **table = m->bindings.table; for(i=1; i < m->bindings.size; i+=2) { if (table[i] != HT_NOTFOUND) { jl_binding_t *b = (jl_binding_t*)table[i]; jl_serialize_value(s, b->name); jl_serialize_value(s, b->value); jl_serialize_value(s, b->type); write_int8(s, b->constp); write_int8(s, b->exportp); } } jl_serialize_value(s, NULL); table = m->macros.table; for(i=1; i < m->macros.size; i+=2) { if (table[i] != HT_NOTFOUND) { jl_serialize_value(s, table[i-1]); jl_serialize_value(s, table[i]); } } jl_serialize_value(s, NULL); }
struct data_buffer* gen_ensure_index_packet(char* cmd,MEM_POOL* mem_pool) { char* table_name = NULL; char* field_name = NULL; uint32_t tblen; uint32_t fdlen; char* token; enum index_key_alg index_type; enum field_types data_type; if((table_name = strtok(NULL," ")) == NULL) return NULL; if((field_name = strtok(NULL," ")) == NULL) return NULL; if((token = strtok(NULL," ")) == NULL) return NULL; index_type = (index_key_alg)atoi(token); if(index_type > 0xff) return NULL; if((token = strtok(NULL," ")) == NULL) return NULL; data_type = (enum field_types)atoi(token); if(data_type > 0xff) return NULL; tblen = strlen(table_name); fdlen = strlen(field_name); struct data_buffer *dbuf = init_data_buffer(); size_t data_len = tblen + fdlen + 10 * sizeof(uint8_t) + MESSAGE_HEAD_LEN + 2*sizeof(uint32_t); databuf_resize(dbuf, data_len); //写入数据长度 write_int32(data_len,dbuf); write_int8(1, dbuf); write_int8(1, dbuf); write_int16(MT_CD_EXE_INDEX, dbuf); write_int32(0, dbuf); //timeout write_int32(0, dbuf); //拼接协议包 write_int32(tblen,dbuf); write_bytes((uint8_t*)table_name,tblen,dbuf); write_int32(fdlen,dbuf); write_bytes((uint8_t*)field_name,fdlen,dbuf); write_int8(index_type,dbuf); write_int8(data_type,dbuf); return dbuf; }
/* Writes an IFF chunk header, consisting of a four-byte type identifier, followed by the 32-bit chunk size (including the chunk header) */ static bool chunk_begin(IOStream *ios, const char *type, size_t size) { assert(strlen(type) == 4); return write_int8(ios, type[0]) && write_int8(ios, type[1]) && write_int8(ios, type[2]) && write_int8(ios, type[3]) && write_int32(ios, (int)size); }
bool SAS::Connection::connect_init() { int rc; struct sockaddr_in addr; LOG_STATUS("Attempting to connect to SAS %s", _sas_address.c_str()); if ((_sock = ::socket(AF_INET, SOCK_STREAM, 0)) == -1) { LOG_ERROR("Failed to open SAS socket: %d (%s)\n", errno, ::strerror(errno)); return false; } memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(SAS_PORT); addr.sin_addr.s_addr = inet_addr(_sas_address.c_str()); rc = ::connect(_sock, (struct sockaddr*)&addr, sizeof(addr)); if (rc != 0) { LOG_ERROR("Failed to connect to SAS %s:%d : %d %s\n", _sas_address.c_str(), SAS_PORT, errno, ::strerror(errno)); ::close(_sock); return false; } LOG_DEBUG("Connected SAS socket to %s:%d", _sas_address.c_str(), SAS_PORT); // Send an init message to SAS. std::string init; std::string version("v0.1"); int init_len = INIT_HDR_SIZE + sizeof(uint8_t) + _system_name.length() + sizeof(uint32_t) + sizeof(uint8_t) + version.length(); init.reserve(init_len); write_hdr(init, init_len, SAS_MSG_INIT); write_int8(init, (uint8_t)_system_name.length()); write_data(init, _system_name.length(), _system_name.data()); int endianness = 1; init.append((char*)&endianness, sizeof(int)); // Endianness must be written in machine order. write_int8(init, version.length()); write_data(init, version.length(), version.data()); LOG_DEBUG("Sending SAS INIT message"); rc = ::send(_sock, init.data(), init.length(), 0); if (rc < 0) { LOG_ERROR("SAS connection to %s:%d failed: %d %s", _sas_address.c_str(), SAS_PORT, errno, ::strerror(errno)); return false; } LOG_STATUS("Connected to SAS %s:%d", _sas_address.c_str(), SAS_PORT); return true; }
int bson_encoder_append_bool(bson_encoder_t encoder, const char *name, bool value) { CODER_CHECK(encoder); if (write_int8(encoder, BSON_BOOL) || write_name(encoder, name) || write_int8(encoder, value ? 1 : 0)) { CODER_KILL(encoder, "write error on BSON_BOOL"); } return 0; }
int bson_encoder_append_binary(bson_encoder_t encoder, const char *name, bson_binary_subtype_t subtype, size_t size, const void *data) { CODER_CHECK(encoder); if (write_int8(encoder, BSON_BINDATA) || write_name(encoder, name) || write_int32(encoder, size) || write_int8(encoder, subtype) || write_x(encoder, data, size)) { CODER_KILL(encoder, "write error on BSON_BINDATA"); } return 0; }
void *spice_marshaller_add_int8(SpiceMarshaller *m, int8_t v) { uint8_t *ptr; ptr = spice_marshaller_reserve_space(m, sizeof(int8_t)); write_int8(ptr, v); return (void *)ptr; }
struct data_buffer* gen_load_packet(char* cmd,MEM_POOL* mem_pool) { char* table_name = NULL; char* segment_dir = NULL; char* token = NULL; uint32_t tblen; uint32_t dirlen; uint16_t sid; if((table_name = strtok(NULL," ")) == NULL) return NULL; tblen = strlen(table_name); if((token = strtok(NULL," ")) == NULL) return NULL; sid = atoi(token); if((segment_dir = strtok(NULL," ")) == NULL) return NULL; dirlen = strlen(segment_dir); struct data_buffer *dbuf = init_data_buffer(); size_t data_len = tblen + dirlen + 10 * sizeof(uint8_t) + MESSAGE_HEAD_LEN + 2*sizeof(uint32_t); databuf_resize(dbuf, data_len); //写入数据长度 write_int32(data_len,dbuf); write_int8(1, dbuf); write_int8(1, dbuf); write_int16(MT_CD_EXE_LOAD, dbuf); write_int32(0, dbuf); //timeout write_int32(0, dbuf); //拼接协议包 write_int32(tblen,dbuf); write_bytes((uint8_t*)table_name,tblen,dbuf); write_int16(sid,dbuf); write_int32(dirlen,dbuf); write_bytes((uint8_t*)segment_dir,dirlen,dbuf); return dbuf; }
struct data_buffer* gen_get_load_threshold_packet(char* cmd,MEM_POOL* mem_pool) { struct data_buffer *dbuf = init_data_buffer(); size_t data_len = MESSAGE_HEAD_LEN + 2*sizeof(uint32_t); databuf_resize(dbuf, data_len); //写入数据长度 write_int32(data_len,dbuf); write_int8(1, dbuf); write_int8(1, dbuf); write_int16(MT_CD_EXE_GET_LOAD_THRESHOLD, dbuf); write_int32(0, dbuf); //timeout write_int32(0, dbuf); return dbuf; }
struct data_buffer* gen_checkpoint_packet(char* cmd,MEM_POOL* mem_pool) { struct data_buffer *dbuf = init_data_buffer(); size_t data_len = MESSAGE_HEAD_LEN + 2*sizeof(uint32_t); databuf_resize(dbuf, data_len); //写入数据长度 write_int32(data_len,dbuf); write_int8(1, dbuf); write_int8(1, dbuf); write_int16(MT_CD_EXE_CP, dbuf); write_int32(0, dbuf); //timeout write_int32(0, dbuf); return dbuf; }
static int writer_int8(lua_State* L) { writer_t* writer = lua_touserdata(L, 1); lua_Integer integer = luaL_checkinteger(L, 2); if(integer < INT8_MIN|| integer > INT8_MAX) luaL_error(L, "integer overflow"); write_int8(writer, (int8_t)integer); return 0; }
static bool write_FUN_chunk(IOStream *ios, size_t chunk_size) { if (!chunk_begin(ios, "FUN ", chunk_size)) return false; Function *functions = (Function*)AR_data(&ar_functions); size_t nfunction = AR_size(&ar_functions), n, i; if (!write_int32(ios, (int)nfunction)) return false; /* Write function headers */ for (n = 0; n < nfunction; ++n) { if (!write_int16(ios, 0) || !write_int8(ios, functions[n].nret) || !write_int8(ios, functions[n].nparam)) { return false; } } /* Write function instructions */ for (n = 0; n < nfunction; ++n) { Instruction *ins = functions[n].instrs; for (i = 0; (int)i < functions[n].ninstr; ++i) { assert(ins[i].opcode == (ins[i].opcode&255)); assert(ins[i].argument >= -0x00800000 && ins[i].argument <= 0x007fffff); if (!write_int8(ios, ins[i].opcode) || !write_int24(ios, ins[i].argument)) return false; } if (!write_int32(ios, 0)) return false; } return chunk_end(ios, chunk_size); }
int key_value_write_lines(FILE *f, struct key_value_specification *kvs, void *base_address[]) { struct key_value_specification *k; int rc; int errs = 0; for (k = kvs; k->key; k++) { switch (k->type) { case KVS_STRING: rc = write_string(f, k, base_address); break; case KVS_INT64: rc = write_int64(f, k, base_address); break; case KVS_INT32: rc = write_int32(f, k, base_address); break; case KVS_INT16: rc = write_int16(f, k, base_address); break; case KVS_INT8: rc = write_int8(f, k, base_address); break; case KVS_UINT64: rc = write_uint64(f, k, base_address); break; case KVS_UINT32: rc = write_uint32(f, k, base_address); break; case KVS_UINT16: rc = write_uint16(f, k, base_address); break; case KVS_UINT8: rc = write_uint8(f, k, base_address); break; case KVS_DOUBLE: rc = write_double(f, k, base_address); break; case KVS_FLOAT: rc = write_float(f, k, base_address); break; default: fprintf(stderr, "%s:%d: unknown key type '%c' for key '%s'\n", __func__, __LINE__, k->type, k->key); rc = -1; break; } if (rc) errs++; } return errs; }
static void jl_serialize_methlist(ios_t *s, jl_methlist_t *ml) { while (ml != NULL) { jl_serialize_value(s, ml->sig); assert(jl_is_tuple(ml->sig)); write_int8(s, ml->va); jl_serialize_value(s, ml->tvars); jl_serialize_value(s, ml->func); jl_serialize_value(s, ml->invokes); ml = ml->next; } jl_serialize_value(s, NULL); }
void SAS::associate_trails(TrailId trail_a, TrailId trail_b, Marker::Scope scope) { std::string trail_assoc_msg; write_hdr(trail_assoc_msg, 29, SAS_MSG_TRAIL_ASSOC, get_current_timestamp()); write_trail(trail_assoc_msg, trail_a); write_trail(trail_assoc_msg, trail_b); write_int8(trail_assoc_msg, (uint8_t)scope); if (_connection) { _connection->send_msg(trail_assoc_msg); } }
struct data_buffer *gen_ldb_control_packet(char *cmd, MEM_POOL *mem_pool) { // make cmd to full command while (strtok(NULL, " ")); struct data_buffer *dbuf = init_data_buffer(); // header write_int32(0, dbuf); write_int8(1, dbuf); write_int8(1, dbuf); write_int16(MT_CD_EXE_LDB_CONTROL, dbuf); write_int32(0, dbuf); //timeout write_int32(0, dbuf); write_int32(strlen(cmd), dbuf); write_bytes((uint8_t *)cmd, strlen(cmd), dbuf); fill_int32(dbuf->data_len, dbuf, 0); return dbuf; }
int bson_encoder_append_double(bson_encoder_t encoder, const char *name, double value) { CODER_CHECK(encoder); if (write_int8(encoder, BSON_DOUBLE) || write_name(encoder, name) || write_double(encoder, value)) { CODER_KILL(encoder, "write error on BSON_DOUBLE"); } return 0; }
int bson_encoder_fini(bson_encoder_t encoder) { CODER_CHECK(encoder); if (write_int8(encoder, BSON_EOO)) { CODER_KILL(encoder, "write error on document terminator"); } /* sync file */ if (encoder->fd > -1) { BSON_FSYNC(encoder->fd); } return 0; }
int bson_encoder_append_string(bson_encoder_t encoder, const char *name, const char *string) { size_t len; CODER_CHECK(encoder); len = strlen(string) + 1; /* include trailing nul */ if (write_int8(encoder, BSON_STRING) || write_name(encoder, name) || write_int32(encoder, len) || write_x(encoder, string, len)) { CODER_KILL(encoder, "write error on BSON_STRING"); } return 0; }
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 void jl_serialize_value_(ios_t *s, jl_value_t *v) { if (v == NULL) { write_uint8(s, Null_tag); return; } void **bp = ptrhash_bp(&ser_tag, v); if (*bp != HT_NOTFOUND) { write_as_tag(s, (uint8_t)(ptrint_t)*bp); return; } if (tree_literal_values) { // compressing tree if (!is_ast_node(v)) { writetag(s, (jl_value_t*)LiteralVal_tag); write_uint16(s, literal_val_id(v)); return; } } else { bp = ptrhash_bp(&backref_table, v); if (*bp != HT_NOTFOUND) { write_uint8(s, BackRef_tag); write_int32(s, (ptrint_t)*bp); return; } ptrhash_put(&backref_table, v, (void*)(ptrint_t)ios_pos(s)); } size_t i; if (jl_is_tuple(v)) { size_t l = ((jl_tuple_t*)v)->length; if (l <= 255) { writetag(s, jl_tuple_type); write_uint8(s, (uint8_t)l); } else { writetag(s, (jl_value_t*)LongTuple_tag); write_int32(s, l); } for(i=0; i < l; i++) { jl_serialize_value(s, jl_tupleref(v, i)); } } else if (jl_is_symbol(v)) { size_t l = strlen(((jl_sym_t*)v)->name); if (l <= 255) { writetag(s, jl_symbol_type); write_uint8(s, (uint8_t)l); } else { writetag(s, (jl_value_t*)LongSymbol_tag); write_int32(s, l); } ios_write(s, ((jl_sym_t*)v)->name, l); } else if (jl_is_array(v)) { jl_array_t *ar = (jl_array_t*)v; writetag(s, (jl_value_t*)jl_array_type); jl_serialize_value(s, ar->type); jl_value_t *elty = jl_tparam0(ar->type); for (i=0; i < ar->ndims; i++) jl_serialize_value(s, jl_box_long(jl_array_dim(ar,i))); if (jl_is_bits_type(elty)) { size_t tot = ar->length * ar->elsize; ios_write(s, ar->data, tot); } else { for(i=0; i < ar->length; i++) { jl_serialize_value(s, jl_cellref(v, i)); } } } else if (jl_is_expr(v)) { jl_expr_t *e = (jl_expr_t*)v; size_t l = e->args->length; if (l <= 255) { writetag(s, jl_expr_type); write_uint8(s, (uint8_t)l); } else { writetag(s, (jl_value_t*)LongExpr_tag); write_int32(s, l); } jl_serialize_value(s, e->head); jl_serialize_value(s, e->etype); for(i=0; i < l; i++) { jl_serialize_value(s, jl_exprarg(e, i)); } } else if (jl_is_some_tag_type(v)) { jl_serialize_tag_type(s, v); } else if (jl_is_typevar(v)) { writetag(s, jl_tvar_type); jl_serialize_value(s, ((jl_tvar_t*)v)->name); jl_serialize_value(s, ((jl_tvar_t*)v)->lb); jl_serialize_value(s, ((jl_tvar_t*)v)->ub); write_int8(s, ((jl_tvar_t*)v)->bound); } else if (jl_is_function(v)) { writetag(s, jl_func_kind); jl_serialize_value(s, v->type); jl_function_t *f = (jl_function_t*)v; jl_serialize_value(s, (jl_value_t*)f->linfo); jl_serialize_value(s, f->env); if (f->linfo && f->linfo->ast && (jl_is_expr(f->linfo->ast) || jl_is_tuple(f->linfo->ast)) && f->fptr != &jl_trampoline) { write_int32(s, 0); } else { jl_serialize_fptr(s, f->fptr); } } else if (jl_is_lambda_info(v)) { writetag(s, jl_lambda_info_type); jl_lambda_info_t *li = (jl_lambda_info_t*)v; jl_serialize_value(s, li->ast); jl_serialize_value(s, (jl_value_t*)li->sparams); // don't save cached type info for code in the Base module, because // it might reference types in the old System module. if (li->module == jl_base_module) jl_serialize_value(s, (jl_value_t*)jl_null); else jl_serialize_value(s, (jl_value_t*)li->tfunc); jl_serialize_value(s, (jl_value_t*)li->name); jl_serialize_value(s, (jl_value_t*)li->specTypes); jl_serialize_value(s, (jl_value_t*)li->specializations); jl_serialize_value(s, (jl_value_t*)li->inferred); jl_serialize_value(s, (jl_value_t*)li->file); jl_serialize_value(s, (jl_value_t*)li->line); jl_serialize_value(s, (jl_value_t*)li->module); } else if (jl_typeis(v, jl_module_type)) { jl_serialize_module(s, (jl_module_t*)v); } else if (jl_typeis(v, jl_methtable_type)) { writetag(s, jl_methtable_type); jl_methtable_t *mt = (jl_methtable_t*)v; jl_serialize_methlist(s, mt->defs); jl_serialize_methlist(s, mt->cache); jl_serialize_value(s, mt->cache_1arg); write_int32(s, mt->max_args); } else if (jl_typeis(v, jl_task_type)) { jl_error("Task cannot be serialized"); } else { jl_value_t *t = (jl_value_t*)jl_typeof(v); if (jl_is_bits_type(t)) { void *data = jl_bits_data(v); if (t == (jl_value_t*)jl_int64_type && *(int64_t*)data >= S32_MIN && *(int64_t*)data <= S32_MAX) { writetag(s, (jl_value_t*)SmallInt64_tag); write_int32(s, (int32_t)*(int64_t*)data); } else { int nb = ((jl_bits_type_t*)t)->nbits; writetag(s, jl_bits_kind); jl_serialize_value(s, t); ios_write(s, data, nb/8); } } else if (jl_is_struct_type(t)) { writetag(s, jl_struct_kind); jl_serialize_value(s, t); size_t nf = ((jl_struct_type_t*)t)->names->length; size_t i; for(i=0; i < nf; i++) { jl_value_t *fld = ((jl_value_t**)v)[i+1]; jl_serialize_value(s, fld); } if (t == jl_idtable_type) { jl_cell_1d_push(idtable_list, v); } } else { assert(0); } } }
void save_ns_dbase(void) { dbFILE *f; int i; NickInfo *ni; char **access; static time_t lastwarn = 0; if (!(f = open_db(s_NickServ, NickDBName, "w"))) return; for (ni = firstnick(); ni; ni = nextnick()) { SAFE(write_int8(1, f)); SAFE(write_buffer(ni->nick, f)); SAFE(write_buffer(ni->pass, f)); SAFE(write_string(ni->url, f)); SAFE(write_string(ni->email, f)); SAFE(write_string(ni->last_usermask, f)); SAFE(write_string(ni->last_realname, f)); SAFE(write_string(ni->last_quit, f)); SAFE(write_int32(ni->time_registered, f)); SAFE(write_int32(ni->last_seen, f)); SAFE(write_int16(ni->status, f)); if (ni->link) { SAFE(write_string(ni->link->nick, f)); SAFE(write_int16(ni->linkcount, f)); SAFE(write_int16(ni->channelcount, f)); } else { SAFE(write_string(NULL, f)); SAFE(write_int16(ni->linkcount, f)); SAFE(write_int32(ni->flags, f)); SAFE(write_ptr(ni->suspendinfo, f)); if (ni->suspendinfo) { SAFE(write_buffer(ni->suspendinfo->who, f)); SAFE(write_string(ni->suspendinfo->reason, f)); SAFE(write_int32(ni->suspendinfo->suspended, f)); SAFE(write_int32(ni->suspendinfo->expires, f)); } SAFE(write_int16(ni->accesscount, f)); for (i=0, access=ni->access; i<ni->accesscount; i++, access++) SAFE(write_string(*access, f)); SAFE(write_int16(ni->channelcount, f)); SAFE(write_int16(ni->channelmax, f)); SAFE(write_int16(ni->language, f)); } } /* for (ni) */ { /* This is an UGLY HACK but it simplifies loading. It will go away * in the next file version */ static char buf[256]; SAFE(write_buffer(buf, f)); } close_db(f); return; fail: restore_db(f); log_perror("Write error on %s", NickDBName); if (time(NULL) - lastwarn > WarningTimeout) { wallops(NULL, "Write error on %s: %s", NickDBName, strerror(errno)); lastwarn = time(NULL); } }
/* Writes instructions within a basic block boundary. */ void write_instructions(MVMThreadContext *tc, MVMSpeshGraph *g, SpeshWriterState *ws, MVMSpeshBB *bb) { MVMSpeshIns *ins = bb->first_ins; while (ins) { MVMint32 i; /* Process any annotations. */ MVMSpeshAnn *ann = ins->annotations; MVMSpeshAnn *deopt_one_ann = NULL; MVMSpeshAnn *deopt_all_ann = NULL; MVMSpeshAnn *deopt_inline_ann = NULL; while (ann) { switch (ann->type) { case MVM_SPESH_ANN_FH_START: ws->handlers[ann->data.frame_handler_index].start_offset = ws->bytecode_pos; break; case MVM_SPESH_ANN_FH_END: ws->handlers[ann->data.frame_handler_index].end_offset = ws->bytecode_pos; break; case MVM_SPESH_ANN_FH_GOTO: ws->handlers[ann->data.frame_handler_index].goto_offset = ws->bytecode_pos; break; case MVM_SPESH_ANN_DEOPT_ONE_INS: deopt_one_ann = ann; break; case MVM_SPESH_ANN_DEOPT_ALL_INS: deopt_all_ann = ann; break; case MVM_SPESH_ANN_INLINE_START: g->inlines[ann->data.inline_idx].start = ws->bytecode_pos; break; case MVM_SPESH_ANN_INLINE_END: g->inlines[ann->data.inline_idx].end = ws->bytecode_pos; break; case MVM_SPESH_ANN_DEOPT_INLINE: deopt_inline_ann = ann; break; case MVM_SPESH_ANN_DEOPT_OSR: g->deopt_addrs[2 * ann->data.deopt_idx + 1] = ws->bytecode_pos; break; } ann = ann->next; } if (ins->info->opcode != MVM_SSA_PHI) { /* Real instruction, not a phi. Emit opcode. */ if (ins->info->opcode == (MVMuint16)-1) { /* Ext op; resolve. */ MVMExtOpRecord *extops = g->sf->body.cu->body.extops; MVMuint16 num_extops = g->sf->body.cu->body.num_extops; MVMint32 found = 0; for (i = 0; i < num_extops; i++) { if (extops[i].info == ins->info) { write_int16(ws, MVM_OP_EXT_BASE + i); found = 1; break; } } if (!found) MVM_exception_throw_adhoc(tc, "Spesh: failed to resolve extop in code-gen"); } else { /* Core op. */ write_int16(ws, ins->info->opcode); } /* Write out operands. */ for (i = 0; i < ins->info->num_operands; i++) { MVMuint8 flags = ins->info->operands[i]; MVMuint8 rw = flags & MVM_operand_rw_mask; switch (rw) { case MVM_operand_read_reg: case MVM_operand_write_reg: write_int16(ws, ins->operands[i].reg.orig); break; case MVM_operand_read_lex: case MVM_operand_write_lex: write_int16(ws, ins->operands[i].lex.idx); write_int16(ws, ins->operands[i].lex.outers); break; case MVM_operand_literal: { MVMuint8 type = flags & MVM_operand_type_mask; switch (type) { case MVM_operand_int8: write_int8(ws, ins->operands[i].lit_i8); break; case MVM_operand_int16: write_int16(ws, ins->operands[i].lit_i16); break; case MVM_operand_int32: write_int32(ws, ins->operands[i].lit_i32); break; case MVM_operand_int64: write_int64(ws, ins->operands[i].lit_i64); break; case MVM_operand_num32: write_num32(ws, ins->operands[i].lit_n32); break; case MVM_operand_num64: write_num64(ws, ins->operands[i].lit_n64); break; case MVM_operand_callsite: write_int16(ws, ins->operands[i].callsite_idx); break; case MVM_operand_coderef: write_int16(ws, ins->operands[i].coderef_idx); break; case MVM_operand_str: write_int32(ws, ins->operands[i].lit_str_idx); break; case MVM_operand_ins: { MVMint32 offset = ws->bb_offsets[ins->operands[i].ins_bb->idx]; if (offset >= 0) { /* Already know where it is, so just write it. */ write_int32(ws, offset); } else { /* Need to fix it up. */ if (ws->num_fixups == ws->alloc_fixups) { ws->alloc_fixups *= 2; ws->fixup_locations = MVM_realloc(ws->fixup_locations, ws->alloc_fixups * sizeof(MVMint32)); ws->fixup_bbs = MVM_realloc(ws->fixup_bbs, ws->alloc_fixups * sizeof(MVMSpeshBB *)); } ws->fixup_locations[ws->num_fixups] = ws->bytecode_pos; ws->fixup_bbs[ws->num_fixups] = ins->operands[i].ins_bb; write_int32(ws, 0); ws->num_fixups++; } break; } case MVM_operand_spesh_slot: write_int16(ws, ins->operands[i].lit_i16); break; default: MVM_exception_throw_adhoc(tc, "Spesh: unknown operand type %d in codegen (op %s)", (int)type, ins->info->name); } } break; default: MVM_exception_throw_adhoc(tc, "Spesh: unknown operand type in codegen"); } } } /* If there was a deopt point annotation, update table. */ if (deopt_one_ann) g->deopt_addrs[2 * deopt_one_ann->data.deopt_idx + 1] = ws->bytecode_pos; if (deopt_all_ann) g->deopt_addrs[2 * deopt_all_ann->data.deopt_idx + 1] = ws->bytecode_pos; if (deopt_inline_ann) g->deopt_addrs[2 * deopt_inline_ann->data.deopt_idx + 1] = ws->bytecode_pos; ins = ins->next; } }
bool SAS::Connection::connect_init() { if (_socket_callback) { _sock = _socket_callback(_sas_address.c_str(), SAS_PORT); } else { _sock = get_local_sock(_sas_address.c_str(), SAS_PORT); } if (_sock < 0) { return false; } SAS_LOG_DEBUG("Connected SAS socket to %s:%s", _sas_address.c_str(), SAS_PORT); set_send_timeout(_sock, SEND_TIMEOUT); // Send an init message to SAS. std::string init; std::string version("v0.1"); // The resource version is part of the binary protocol but is not currently // exposed over the C++ API. std::string resource_version(""); int init_len = INIT_HDR_SIZE + sizeof(uint8_t) + _system_name.length() + sizeof(uint32_t) + sizeof(uint8_t) + version.length() + sizeof(uint8_t) + _system_type.length() + sizeof(uint8_t) + _resource_identifier.length() + sizeof(uint8_t) + resource_version.length(); init.reserve(init_len); write_hdr(init, init_len, SAS_MSG_INIT, get_current_timestamp()); write_int8(init, (uint8_t)_system_name.length()); write_data(init, _system_name.length(), _system_name.data()); int endianness = 1; init.append((char*)&endianness, sizeof(int)); // Endianness must be written in machine order. write_int8(init, version.length()); write_data(init, version.length(), version.data()); write_int8(init, (uint8_t)_system_type.length()); write_data(init, _system_type.length(), _system_type.data()); write_int8(init, (uint8_t)_resource_identifier.length()); write_data(init, _resource_identifier.length(), _resource_identifier.data()); write_int8(init, (uint8_t)resource_version.length()); write_data(init, resource_version.length(), resource_version.data()); SAS_LOG_DEBUG("Sending SAS INIT message"); int rc = ::send(_sock, init.data(), init.length(), 0); if (rc < 0) { SAS_LOG_ERROR("SAS connection to %s:%s failed: %d %s", _sas_address.c_str(), SAS_PORT, errno, ::strerror(errno)); ::close(_sock); _sock = -1; return false; } SAS_LOG_STATUS("Connected to SAS %s:%s", _sas_address.c_str(), SAS_PORT); return true; }
/* Terminates an IFF chunk header, by padding to a 2-byte boundary. */ static bool chunk_end(IOStream *ios, size_t size) { return (size&1) ? write_int8(ios, 0) : true; }