int ws_utf8_set_data(WsUtf8String *string, const unsigned char *data, size_t len) { size_t num_chars; if (!ws_utf8_verify(data, len, &num_chars)) /* Malformed data. */ return 0; /* Init `string' to empty. */ ws_free(string->data); string->data = NULL; string->len = 0; string->num_chars = 0; /* Set the new data. */ string->data = ws_memdup(data, len); if (string->data == NULL) return 0; string->len = len; string->num_chars = num_chars; return 1; }
WsBool ws_bc_add_function(WsBc *bc, WsUInt8 *index_return, char *name, WsUInt8 num_arguments, WsUInt8 num_locals, WsUInt32 code_size, unsigned char *code) { WsBcFunction *nf; /* First, add the function to the function pool. */ nf = ws_realloc(bc->functions, (bc->num_functions + 1) * sizeof(WsBcFunction)); if (nf == NULL) return WS_FALSE; bc->functions = nf; bc->functions[bc->num_functions].num_arguments = num_arguments; bc->functions[bc->num_functions].num_locals = num_locals; bc->functions[bc->num_functions].code_size = code_size; bc->functions[bc->num_functions].code = ws_memdup(code, code_size); if (bc->functions[bc->num_functions].code == NULL) return WS_FALSE; /* Save the index of the function. */ *index_return = bc->num_functions++; /* For external functions (which have name), add a name entry to the function name pool. */ if (name) { WsBcFunctionName *nfn; nfn = ws_realloc(bc->function_names, ((bc->num_function_names + 1) * sizeof(WsBcFunctionName))); if (nfn == NULL) return WS_FALSE; bc->function_names = nfn; bc->function_names[bc->num_function_names].index = *index_return; bc->function_names[bc->num_function_names].name = ws_strdup(name); if (bc->function_names[bc->num_function_names].name == NULL) return WS_FALSE; bc->num_function_names++; } /* All done. */ return WS_TRUE; }
WsBool ws_bc_add_const_utf8_string(WsBc *bc, WsUInt16 *index_return, const unsigned char *data, size_t len) { WsUInt16 i; WsBcConstant *nc; /* Do we already have a suitable UFT-8 constant? */ for (i = 0; i < bc->num_constants; i++) { if (bc->constants[i].type == WS_BC_CONST_TYPE_UTF8_STRING && bc->constants[i].u.v_string.len == len && memcmp(bc->constants[i].u.v_string.data, data, len) == 0) { *index_return = i; return WS_TRUE; } } /* Must add a new constant. */ nc = ws_realloc(bc->constants, (bc->num_constants + 1) * sizeof(WsBcConstant)); if (nc == NULL) return WS_FALSE; bc->constants = nc; bc->constants[bc->num_constants].type = WS_BC_CONST_TYPE_UTF8_STRING; bc->constants[bc->num_constants].u.v_string.len = len; bc->constants[bc->num_constants].u.v_string.data = ws_memdup(data, len); if (bc->constants[bc->num_constants].u.v_string.data == NULL) return WS_FALSE; *index_return = bc->num_constants++; return WS_TRUE; }
WsBc *ws_bc_decode(const unsigned char *data, size_t data_len) { WsBc *bc = ws_bc_alloc(WS_BC_STRING_ENC_ISO_8859_1); WsByte b; WsUInt32 ui32; WsUInt16 ui16, j; WsUInt16 ui16b; WsUInt8 ui8, num_functions, k, l; WsInt8 i8; WsInt16 i16; WsInt32 i32; WsIeee754Result ieee754; unsigned char *ucp; size_t decoded; /* Decode the byte-code header. */ decoded = ws_decode_buffer(data, data_len, WS_ENC_BYTE, &b, WS_ENC_MB_UINT32, &ui32, WS_ENC_END); if (!decoded || b != WS_BC_VERSION || ui32 != data_len - decoded) /* This is not a valid (or supported) byte-code header. */ goto error; WS_UPDATE_DATA; /* Constant pool. */ decoded = ws_decode_buffer(data, data_len, WS_ENC_MB_UINT16, &ui16, WS_ENC_MB_UINT16, &ui16b, WS_ENC_END); if (!decoded) goto error; bc->string_encoding = ui16b; bc->constants = ws_calloc(ui16, sizeof(WsBcConstant)); if (bc->constants == NULL) goto error; bc->num_constants = ui16; WS_UPDATE_DATA; for (j = 0; j < bc->num_constants; j++) { WsBcConstant *c = &bc->constants[j]; decoded = ws_decode_buffer(data, data_len, WS_ENC_UINT8, &ui8, WS_ENC_END); if (decoded != 1) goto error; WS_UPDATE_DATA; switch (ui8) { case WS_BC_CONST_INT8: decoded = ws_decode_buffer(data, data_len, WS_ENC_INT8, &i8, WS_ENC_END); if (decoded != 1) goto error; WS_UPDATE_DATA; c->type = WS_BC_CONST_TYPE_INT; c->u.v_int = i8; break; case WS_BC_CONST_INT16: decoded = ws_decode_buffer(data, data_len, WS_ENC_INT16, &i16, WS_ENC_END); if (decoded != 2) goto error; WS_UPDATE_DATA; c->type = WS_BC_CONST_TYPE_INT; c->u.v_int = i16; break; case WS_BC_CONST_INT32: decoded = ws_decode_buffer(data, data_len, WS_ENC_INT32, &i32, WS_ENC_END); if (decoded != 4) goto error; WS_UPDATE_DATA; c->type = WS_BC_CONST_TYPE_INT; c->u.v_int = i32; break; case WS_BC_CONST_FLOAT32: decoded = ws_decode_buffer(data, data_len, WS_ENC_DATA, &ucp, (size_t) 4, WS_ENC_END); if (decoded != 4) goto error; WS_UPDATE_DATA; ieee754 = ws_ieee754_decode_single(ucp, &c->u.v_float); switch (ieee754) { case WS_IEEE754_OK: c->type = WS_BC_CONST_TYPE_FLOAT32; break; case WS_IEEE754_NAN: c->type = WS_BC_CONST_TYPE_FLOAT32_NAN; break; case WS_IEEE754_POSITIVE_INF: c->type = WS_BC_CONST_TYPE_FLOAT32_POSITIVE_INF; break; case WS_IEEE754_NEGATIVE_INF: c->type = WS_BC_CONST_TYPE_FLOAT32_NEGATIVE_INF; break; } break; case WS_BC_CONST_UTF8_STRING: decoded = ws_decode_buffer(data, data_len, WS_ENC_MB_UINT32, &ui32, WS_ENC_END); if (decoded == 0) goto error; WS_UPDATE_DATA; c->type = WS_BC_CONST_TYPE_UTF8_STRING; c->u.v_string.len = ui32; decoded = ws_decode_buffer(data, data_len, WS_ENC_DATA, &ucp, c->u.v_string.len, WS_ENC_END); if (decoded != ui32) goto error; WS_UPDATE_DATA; c->u.v_string.data = ws_memdup(ucp, ui32); if (c->u.v_string.data == NULL) goto error; /* Check the validity of the data. */ if (!ws_utf8_verify(c->u.v_string.data, c->u.v_string.len, &c->u.v_string.num_chars)) goto error; break; case WS_BC_CONST_EMPTY_STRING: c->type = WS_BC_CONST_TYPE_EMPTY_STRING; break; case WS_BC_CONST_EXT_ENC_STRING: ws_fatal("external character encoding not implemented yet"); break; default: /* Reserved. */ goto error; break; } } /* Pragma pool. */ decoded = ws_decode_buffer(data, data_len, WS_ENC_MB_UINT16, &ui16, WS_ENC_END); if (!decoded) goto error; bc->pragmas = ws_calloc(ui16, sizeof(WsBcPragma)); if (bc->pragmas == NULL) goto error; bc->num_pragmas = ui16; WS_UPDATE_DATA; for (j = 0; j < bc->num_pragmas; j++) { WsBcPragma *p = &bc->pragmas[j]; decoded = ws_decode_buffer(data, data_len, WS_ENC_UINT8, &ui8, WS_ENC_END); if (decoded != 1) goto error; WS_UPDATE_DATA; p->type = ui8; switch (ui8) { case WS_BC_PRAGMA_ACCESS_DOMAIN: decoded = ws_decode_buffer(data, data_len, WS_ENC_MB_UINT16, &p->index_1, WS_ENC_END); if (!decoded) goto error; WS_CHECK_STRING(p->index_1); break; case WS_BC_PRAGMA_ACCESS_PATH: decoded = ws_decode_buffer(data, data_len, WS_ENC_MB_UINT16, &p->index_1, WS_ENC_END); if (!decoded) goto error; WS_CHECK_STRING(p->index_1); break; case WS_BC_PRAGMA_USER_AGENT_PROPERTY: decoded = ws_decode_buffer(data, data_len, WS_ENC_MB_UINT16, &p->index_1, WS_ENC_MB_UINT16, &p->index_2, WS_ENC_END); if (!decoded) goto error; WS_CHECK_STRING(p->index_1); WS_CHECK_STRING(p->index_2); break; case WS_BC_PRAGMA_USER_AGENT_PROPERTY_AND_SCHEME: decoded = ws_decode_buffer(data, data_len, WS_ENC_MB_UINT16, &p->index_1, WS_ENC_MB_UINT16, &p->index_2, WS_ENC_MB_UINT16, &p->index_3, WS_ENC_END); if (!decoded) goto error; WS_CHECK_STRING(p->index_1); WS_CHECK_STRING(p->index_2); WS_CHECK_STRING(p->index_3); break; default: goto error; break; } WS_UPDATE_DATA; } /* Function pool. */ decoded = ws_decode_buffer(data, data_len, WS_ENC_UINT8, &num_functions, WS_ENC_END); if (decoded != 1) goto error; WS_UPDATE_DATA; /* Function names. */ decoded = ws_decode_buffer(data, data_len, WS_ENC_UINT8, &ui8, WS_ENC_END); if (decoded != 1) goto error; WS_UPDATE_DATA; if (ui8) { /* We have function names. */ bc->function_names = ws_calloc(ui8, sizeof(WsBcFunctionName)); if (bc->function_names == NULL) goto error; bc->num_function_names = ui8; for (k = 0; k < bc->num_function_names; k++) { WsBcFunctionName *n = &bc->function_names[k]; decoded = ws_decode_buffer(data, data_len, WS_ENC_UINT8, &n->index, WS_ENC_UINT8, &ui8, WS_ENC_END); if (decoded != 2) goto error; WS_UPDATE_DATA; decoded = ws_decode_buffer(data, data_len, WS_ENC_DATA, &ucp, (size_t) ui8, WS_ENC_END); if (decoded != ui8) goto error; WS_UPDATE_DATA; n->name = ws_memdup(ucp, ui8); if (n->name == NULL) goto error; /* Check the validity of the name. */ if (!ws_utf8_verify((unsigned char *) n->name, ui8, NULL)) goto error; /* Just check that the data contains only valid characters. */ for (l = 0; l < ui8; l++) { unsigned int ch = (unsigned char) n->name[l]; if (('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') || ch == '_' || (l > 0 && ('0' <= ch && ch <= '9'))) /* Ok. */ continue; /* Invalid character in the function name. */ goto error; } /* Is the index valid? */ if (n->index >= num_functions) goto error; } } /* Functions. */ if (num_functions) { /* We have functions. */ bc->functions = ws_calloc(num_functions, sizeof(WsBcFunction)); if (bc->functions == NULL) goto error; bc->num_functions = num_functions; for (k = 0; k < bc->num_functions; k++) { WsBcFunction *f = &bc->functions[k]; decoded = ws_decode_buffer(data, data_len, WS_ENC_UINT8, &f->num_arguments, WS_ENC_UINT8, &f->num_locals, WS_ENC_MB_UINT32, &f->code_size, WS_ENC_END); if (!decoded) goto error; WS_UPDATE_DATA; decoded = ws_decode_buffer(data, data_len, WS_ENC_DATA, &ucp, f->code_size, WS_ENC_END); if (decoded != f->code_size) goto error; WS_UPDATE_DATA; if (f->code_size) { /* It is not an empty function. */ f->code = ws_memdup(ucp, f->code_size); if (f->code == NULL) goto error; } } } /* Did we process it all? */ if (data_len != 0) goto error; /* All done. */ return bc; /* * Error handling. */ error: ws_bc_free(bc); return NULL; }