static RNG *
get_rng (void)
{
static RNG rng;
static bool rng_initialized = false;
if (!rng_initialized)
{
if (!check_result (InitRng (&rng)))
return NULL;
rng_initialized = true;
}
return &rng;
}
int cgroup_add(unicorn_t * u){
int i;
for (i=0; i< cgroup_subsystems_lengh; i++){
char system_path[80];
check_result(sprintf(system_path, "%s/%s", cgroup_base_dir, cgroup_subsystems[i]),system_path);
char cmd[100];
check_result(sprintf(cmd, "mkdir -p %s/%s", system_path, u->unicorn_id),cmd);
check_result(system(cmd), "system call mkdir ");
// char file_path[100];
// check_result(sprintf(file_path, "%s/%s/%s/tasks", cgroup_base_dir, cgroup_subsystems[i], u->unicorn_id),file_path);
// char value[10];
// check_result(sprintf(value, "%d", u->child_pid), value);
// printf("write value %s to %s \n", value, file_path);
// FILE * f = fopen(file_path, "w");
// if(f == NULL){
// printf("open file error %s \n", strerror(errno));
// exit(errno);
// }
// int rt = fputs("2345", f);
// if( rt < 0) {
// printf("write task file error %s ", cgroup_subsystems[i]);
// exit(-1);
// }
// printf("write %d chars \n", rt);
if( strcmp(cgroup_subsystems[i], "cpuset") == 0){
check_result(sprintf(cmd, "cat %s/cpuset.mems > %s/%s/cpuset.mems", system_path, system_path, u->unicorn_id),cmd);
check_result(system(cmd), "system call add cpuset.mems ");
check_result(sprintf(cmd, "cat %s/cpuset.cpus > %s/%s/cpuset.cpus", system_path, system_path, u->unicorn_id),cmd);
check_result(system(cmd), "system call add cpuset.cpus ");
}
check_result(sprintf(cmd, "echo %d > %s/%s/tasks", u->child_pid, system_path, u->unicorn_id),cmd);
check_result(system(cmd), "system call add pid ");
}
return 0;
}
bool
tr_rand_buffer (void * buffer,
size_t length)
{
bool ret;
tr_lock * rng_lock = get_rng_lock ();
assert (buffer != NULL);
tr_lockLock (rng_lock);
ret = check_result (RNG_GenerateBlock (get_rng (), buffer, length));
tr_lockUnlock (rng_lock);
return ret;
}
int flatcc_verify_struct_as_nested_root(flatcc_table_verifier_descriptor_t *td,
voffset_t id, int required, const char *fid, uint16_t align, size_t size)
{
const uoffset_t *buf;
uoffset_t bufsiz;
check_result(flatcc_verify_vector_field(td, id, required, align, 1, FLATBUFFERS_COUNT_MAX(1)));
if (0 == (buf = get_field_ptr(td, id))) {
return flatcc_verify_ok;
}
buf = (const uoffset_t *)((size_t)buf + read_uoffset(buf, 0));
bufsiz = read_uoffset(buf, 0);
++buf;
return flatcc_verify_struct_as_root(buf, bufsiz, fid, align, size);
}
void TopParser::next(TypeDef::Atom *atom)
{
TypeDef::State *state=topState();
TypeDef::Rule *rule=Find(state->final->actions,atom);
if( rule )
{
Printf(Exception,"App::TopParser::next(...) : rule mismatch");
}
if( atom )
push(atom,Transition(state->transitions,atom));
else
check_result();
}
int ulcd_sd_image_load(ulcd_dev *dev, const char *file, uint16_t x, uint16_t y) {
// Write commands
write_char(dev, 0x40);
write_char(dev, 0x6D);
serial_write(dev->port, file, strlen(file));
write_char(dev, 0x00);
write_word(dev, x);
write_word(dev, y);
write_word(dev, 0);
// Check results
if(!check_result(dev, "Image load+show failed.")) {
return 0;
}
return 1;
}
static int maintain_reactor(int epoll_fd, int action, int fd, int event_type)
{
CHECK_FD_RETURN(epoll_fd, -1);
CHECK_FD_RETURN(fd, -1);
struct epoll_event event;
memset(&event, 0, sizeof(event));
event.events = event_type;
event.data.fd = fd;
int ret = epoll_ctl(epoll_fd, action, fd, &event);
check_result(ret, errno, "epoll_ctl");
return ret;
}
/*
* This could be further simplified by constructing an expected
* HANDSHAKE_RESULT, and implementing comparison methods for
* its fields.
*/
static int check_test(HANDSHAKE_RESULT *result, SSL_TEST_CTX *test_ctx)
{
int ret = 1;
ret &= check_result(result, test_ctx);
ret &= check_alerts(result, test_ctx);
if (result->result == SSL_TEST_SUCCESS) {
ret &= check_protocol(result, test_ctx);
ret &= check_servername(result, test_ctx);
ret &= check_session_ticket(result, test_ctx);
ret &= (result->session_ticket_do_not_call == 0);
ret &= check_npn(result, test_ctx);
ret &= check_alpn(result, test_ctx);
ret &= check_resumption(result, test_ctx);
}
return ret;
}
bool
tr_sha1_final (tr_sha1_ctx_t handle,
uint8_t * hash)
{
bool ret = true;
if (hash != NULL)
{
assert (handle != NULL);
ret = check_result (ShaFinal (handle, hash));
}
tr_free (handle);
return ret;
}
main ()
{
int lp;
int errors = 0;
thds = omp_get_max_threads ();
if (thds == 1) {
printf ("should be run this program on multi threads.\n");
exit (0);
}
buf = (int *) malloc (sizeof (int) * (LOOPNUM + 1));
if (buf == NULL) {
printf ("can not allocate memory.\n");
exit (1);
}
idbuf = (int *) malloc (sizeof (int) * thds);
if (idbuf == NULL) {
printf ("can not allocate memory.\n");
exit (1);
}
omp_set_dynamic (0);
clear ();
#pragma omp parallel
{
#pragma omp for
for (lp=0; lp<LOOPNUM; lp++) {
buf[lp] = omp_get_thread_num ();
}
}
errors += check_result ();
if (errors == 0) {
printf ("for 010 : SUCCESS\n");
if (use_thd == 1) {
printf ("but, for loop executed by 1 thread.\n");
}
return 0;
} else {
printf ("for 010 : FAILED\n");
return 1;
}
}
/*%
* short_form message print handler. Calls above say_message()
*/
static isc_result_t
short_answer(dns_message_t *msg, dns_messagetextflag_t flags,
isc_buffer_t *buf, dig_query_t *query)
{
dns_name_t *name;
dns_rdataset_t *rdataset;
isc_result_t result, loopresult;
dns_name_t empty_name;
dns_rdata_t rdata = DNS_RDATA_INIT;
UNUSED(flags);
dns_name_init(&empty_name, NULL);
result = dns_message_firstname(msg, DNS_SECTION_ANSWER);
if (result == ISC_R_NOMORE)
return (ISC_R_SUCCESS);
else if (result != ISC_R_SUCCESS)
return (result);
for (;;) {
name = NULL;
dns_message_currentname(msg, DNS_SECTION_ANSWER, &name);
for (rdataset = ISC_LIST_HEAD(name->list);
rdataset != NULL;
rdataset = ISC_LIST_NEXT(rdataset, link)) {
loopresult = dns_rdataset_first(rdataset);
while (loopresult == ISC_R_SUCCESS) {
dns_rdataset_current(rdataset, &rdata);
result = say_message(&rdata, query,
buf);
if (result == ISC_R_NOSPACE)
return (result);
check_result(result, "say_message");
loopresult = dns_rdataset_next(rdataset);
dns_rdata_reset(&rdata);
}
}
result = dns_message_nextname(msg, DNS_SECTION_ANSWER);
if (result == ISC_R_NOMORE)
break;
else if (result != ISC_R_SUCCESS)
return (result);
}
return (ISC_R_SUCCESS);
}
// gets a json value from a key
int json_object_get_string(json_t *object, char *key, char **value)
{
char *value_return = NULL;
int exit_code = 0;
check_not_null(object);
check_not_null(key);
check_not_null(value);
json_t *json_string_peek = json_object_get(object, key);
if (json_string_peek == NULL)
{
*value = NULL;
goto cleanup;
}
int json_typeof_result = json_typeof(json_string_peek);
if (json_typeof_result != JSON_STRING)
{
*value = NULL;
goto cleanup;
}
char *value_peek = (char *)json_string_value(json_string_peek);
if (value_peek == NULL)
{
*value = NULL;
goto cleanup;
}
check_result(malloc_memcpy_string(&value_return, value_peek), 0);
*value = value_return;
goto cleanup;
error:
if (value_return != NULL) { free(value_return); }
exit_code = -1;
cleanup:
return exit_code;
}
static int
cgm_begin_picture(gx_device_cgm * cdev)
{
cgm_picture_elements pic;
cgm_result result;
cgm_edge_width edge;
result = cgm_BEGIN_PICTURE(cdev->st, "", 0);
check_result(result);
pic.scaling_mode = cgm_scaling_abstract;
pic.color_selection_mode =
(cdev->color_info.depth <= 8 ?
cgm_color_selection_indexed :
cgm_color_selection_direct);
pic.line_width_specification_mode = cgm_line_marker_absolute;
pic.edge_width_specification_mode = cgm_line_marker_absolute;
cgm_set_rect(pic.vdc_extent, 0, 0, cdev->width, cdev->height);
result = cgm_set_picture_elements(cdev->st, &pic,
cgm_set_SCALING_MODE |
cgm_set_COLOR_SELECTION_MODE |
cgm_set_LINE_WIDTH_SPECIFICATION_MODE |
cgm_set_EDGE_WIDTH_SPECIFICATION_MODE |
cgm_set_VDC_EXTENT);
check_result(result);
result = cgm_BEGIN_PICTURE_BODY(cdev->st);
check_result(result);
result = cgm_VDC_INTEGER_PRECISION(cdev->st,
(cdev->width <= 0x7fff &&
cdev->height <= 0x7fff ?
16 : sizeof(cdev->width) * 8));
check_result(result);
edge.absolute.integer = 0;
result = cgm_EDGE_WIDTH(cdev->st, &edge);
check_result(result);
if (cdev->color_info.depth <= 8) {
cgm_color colors[256];
int i;
for (i = 0; i < (1 << cdev->color_info.depth); i++) {
gx_color_value rgb[3];
(*dev_proc(cdev, map_color_rgb)) ((gx_device *) cdev,
(gx_color_index) i, rgb);
colors[i].rgb.r =
rgb[0] >> (gx_color_value_bits - 8);
colors[i].rgb.g =
rgb[1] >> (gx_color_value_bits - 8);
colors[i].rgb.b =
rgb[2] >> (gx_color_value_bits - 8);
}
result = cgm_COLOR_TABLE(cdev->st, 0, colors,
1 << cdev->color_info.depth);
check_result(result);
}
int ulcd_draw_pixel(ulcd_dev *dev,
uint16_t x, uint16_t y,
uint16_t color) {
char buf[7];
buf[0] = 0x50;
buf[1] = x >> 8;
buf[2] = x & 0xFF;
buf[3] = y >> 8;
buf[4] = y & 0xFF;
buf[5] = color >> 8;
buf[6] = color & 0xFF;
serial_write(dev->port, buf, 7);
if(!check_result(dev, "Error while drawing pixel.")) {
return 0;
}
return 1;
}
int solve(ull_t n)
{
ull_t sum = 0;
for(ull_t i = 0; i <= n; i++) {
sum += i * i;
}
ull_t sum_square = 0;
for(ull_t i = 0; i <= n; i++) {
sum_square += i;
}
sum_square = sum_square * sum_square;
printf("Sum of the squares: %llu\n", sum);
printf("Square of the sum: %llu\n", sum_square);
printf("Difference: %llu\n", sum_square - sum);
check_result(n == 10, sum == 385 && sum_square == 3025);
return 0;
}
// 读取sock peer信息
void getpeerinfo(int fd, char* addr, uint32_t* port)
{
if (-1 == fd || NULL == addr || NULL == port) {
assert(0);
return;
}
struct sockaddr_in saddr;
socklen_t len = sizeof(saddr);
int ret = getpeername(fd, (struct sockaddr*)&saddr, &len);
check_result(ret, errno, "getpeername");
const char* paddr = inet_ntop(AF_INET, &saddr.sin_addr, addr, INET_ADDRSTRLEN);
assert(NULL != paddr);
*port = ntohs(saddr.sin_port);
}
/**
*
* @brief Mutex lock/unlock test
*
* @return N/A
*/
void mutex_test(void)
{
u32_t et; /* elapsed time */
int i;
PRINT_STRING(dashline, output_file);
et = BENCH_START();
for (i = 0; i < NR_OF_MUTEX_RUNS; i++) {
k_mutex_lock(&DEMO_MUTEX, K_FOREVER);
k_mutex_unlock(&DEMO_MUTEX);
}
et = TIME_STAMP_DELTA_GET(et);
check_result();
PRINT_F(output_file, FORMAT, "average lock and unlock mutex",
SYS_CLOCK_HW_CYCLES_TO_NS_AVG(et, (2 * NR_OF_MUTEX_RUNS)));
}
static int konoha_test(const char *testname)
{
verbose_debug = 0;
verbose_sugar = 0;
verbose_gc = 0;
verbose_code = 0;
konoha_t konoha = konoha_open();
if(preimport != NULL) {
konoha_preimport((CTX_t)konoha, preimport);
}
if(startup_script != NULL) {
konoha_startup(konoha, startup_script);
}
int ret = 0;//OK
char script_file[256];
char correct_file[256];
char result_file[256];
snprintf(script_file, 256, "%s", testname);
snprintf(correct_file, 256, "%s.proof", script_file);
snprintf(result_file, 256, "%s.tested", script_file);
FILE *fp = fopen(correct_file, "r");
if (fp == NULL) {
fprintf(stdout, "no proof file: %s\n", testname);
}
stdlog = fopen(result_file, "w");
((struct _klib2*)konoha->lib2)->Kreport = Kreport;
((struct _klib2*)konoha->lib2)->Kreportf = Kreportf;
konoha_load(konoha, script_file);
fprintf(stdlog, "Q.E.D.\n"); // Q.E.D.
fclose(stdlog);
if(fp != NULL) {
FILE *fp2 = fopen(result_file, "r");
ret = check_result(fp, fp2);
if(ret == 0) {
fprintf(stdout, "[PASS]: %s\n", testname);
}
fclose(fp);
fclose(fp2);
}
else {
ret = 1;
}
konoha_close(konoha);
return ret;
}
static void
show_settings(isc_boolean_t full, isc_boolean_t serv_only) {
dig_server_t *srv;
isc_sockaddr_t sockaddr;
dig_searchlist_t *listent;
isc_result_t result;
srv = ISC_LIST_HEAD(server_list);
while (srv != NULL) {
char sockstr[ISC_SOCKADDR_FORMATSIZE];
result = get_address(srv->servername, port, &sockaddr);
check_result(result, "get_address");
isc_sockaddr_format(&sockaddr, sockstr, sizeof(sockstr));
printf("Default server: %s\nAddress: %s\n",
srv->userarg, sockstr);
if (!full)
return;
srv = ISC_LIST_NEXT(srv, link);
}
if (serv_only)
return;
printf("\nSet options:\n");
printf(" %s\t\t\t%s\t\t%s\n",
tcpmode ? "vc" : "novc",
short_form ? "nodebug" : "debug",
debugging ? "d2" : "nod2");
printf(" %s\t\t%s\n",
usesearch ? "search" : "nosearch",
recurse ? "recurse" : "norecurse");
printf(" timeout = %d\t\tretry = %d\tport = %d\tndots = %d\n",
timeout, tries, port, ndots);
printf(" querytype = %-8s\tclass = %s\n", deftype, defclass);
printf(" srchlist = ");
for (listent = ISC_LIST_HEAD(search_list);
listent != NULL;
listent = ISC_LIST_NEXT(listent, link)) {
printf("%s", listent->origin);
if (ISC_LIST_NEXT(listent, link) != NULL)
printf("/");
}
printf("\n");
}
void
tr_rc4_process (tr_rc4_ctx_t handle,
const void * input,
void * output,
size_t length)
{
int output_length;
assert (handle != NULL);
if (length == 0)
return;
assert (input != NULL);
assert (output != NULL);
check_result (EVP_CipherUpdate (handle, output, &output_length, input, length));
}
/**
*
* @brief Write the number of data chunks into the mailbox
*
* @param size The size of the data chunk.
* @param count Number of data chunks.
* @param time The total time.
*
* @return N/A
*/
void mailbox_put(u32_t size, int count, u32_t *time)
{
int i;
unsigned int t;
Message.rx_source_thread = K_ANY;
Message.tx_target_thread = K_ANY;
/* first sync with the receiver */
k_sem_give(&SEM0);
t = BENCH_START();
for (i = 0; i < count; i++) {
k_mbox_put(&MAILB1, &Message, K_FOREVER);
}
t = TIME_STAMP_DELTA_GET(t);
*time = SYS_CLOCK_HW_CYCLES_TO_NS_AVG(t, count);
check_result();
}
static void
parse_name(char **cmdlinep, dns_name_t *name) {
isc_result_t result;
char *word;
isc_buffer_t source;
word = nsu_strsep(cmdlinep, " \t\r\n");
if (word == NULL || *word == 0) {
fprintf(stderr, "could not read owner name\n");
exit(1);
}
isc_buffer_init(&source, word, strlen(word));
isc_buffer_add(&source, strlen(word));
result = dns_name_fromtext(name, &source, dns_rootname, 0, NULL);
check_result(result, "dns_name_fromtext");
isc_buffer_invalidate(&source);
}
int validator_test(void)
{
int i=0;
int success_count=0;
jerif_err err_code = jerif_ok;
for(i=0; i<validator_test_case_count; i++){
printf("Test Case #%d\n", i+1);
err_code = jerif_check_validation(validator_test_case_json_str[i]);
success_count += check_result(validator_test_case_expected_result[i] == err_code);
}
if(success_count >= validator_test_case_count){
return 0;
}else{
return -1;
}
}
isc_result_t
printrdataset(dns_name_t *owner_name, dns_rdataset_t *rdataset,
isc_buffer_t *target)
{
isc_result_t result;
dns_master_style_t *style = NULL;
unsigned int styleflags = 0;
if (rdataset == NULL || owner_name == NULL || target == NULL)
return(ISC_FALSE);
styleflags |= DNS_STYLEFLAG_REL_OWNER;
if (nottl)
styleflags |= DNS_STYLEFLAG_NO_TTL;
if (noclass)
styleflags |= DNS_STYLEFLAG_NO_CLASS;
if (multiline) {
styleflags |= DNS_STYLEFLAG_OMIT_OWNER;
styleflags |= DNS_STYLEFLAG_OMIT_CLASS;
styleflags |= DNS_STYLEFLAG_REL_DATA;
styleflags |= DNS_STYLEFLAG_OMIT_TTL;
styleflags |= DNS_STYLEFLAG_TTL;
styleflags |= DNS_STYLEFLAG_MULTILINE;
styleflags |= DNS_STYLEFLAG_COMMENT;
}
if (multiline || (nottl && noclass))
result = dns_master_stylecreate(&style, styleflags,
24, 24, 24, 32, 80, 8, mctx);
else if (nottl || noclass)
result = dns_master_stylecreate(&style, styleflags,
24, 24, 32, 40, 80, 8, mctx);
else
result = dns_master_stylecreate(&style, styleflags,
24, 32, 40, 48, 80, 8, mctx);
check_result(result, "dns_master_stylecreate");
result = dns_master_rdatasettotext(owner_name, rdataset, style, target);
if (style != NULL)
dns_master_styledestroy(&style, mctx);
return(result);
}
int ulcd_draw_circle(ulcd_dev *dev,
uint16_t x, uint16_t y,
uint16_t radius,
uint16_t color) {
char buf[9];
buf[0] = 0x43;
buf[1] = x >> 8;
buf[2] = x & 0xFF;
buf[3] = y >> 8;
buf[4] = y & 0xFF;
buf[5] = radius >> 8;
buf[6] = radius & 0xFF;
buf[7] = color >> 8;
buf[8] = color & 0xFF;
serial_write(dev->port, buf, 9);
if(!check_result(dev, "Error while drawing circle.")) {
return 0;
}
return 1;
}
bool
tr_sha1_final (tr_sha1_ctx_t handle,
uint8_t * hash)
{
bool ret = true;
if (hash != NULL)
{
unsigned int hash_length;
assert (handle != NULL);
ret = check_result (EVP_DigestFinal_ex (handle, hash, &hash_length));
assert (!ret || hash_length == SHA_DIGEST_LENGTH);
}
EVP_MD_CTX_destroy (handle);
return ret;
}
int flatcc_verify_union_field(flatcc_table_verifier_descriptor_t *td,
voffset_t id, int required, flatcc_union_verifier_f *uvf)
{
voffset_t vte_type, vte_table;
const uint8_t *type;
if (0 == (vte_type = read_vt_entry(td, id - 1))) {
vte_table = read_vt_entry(td, id);
verify(vte_table == 0, flatcc_verify_error_union_cannot_have_a_table_without_a_type);
verify(!required, flatcc_verify_error_type_field_absent_from_required_union_field);
return flatcc_verify_ok;
}
/* No need to check required here. */
check_result(verify_field(td, id - 1, 0, 1, 1));
/* Only now is it safe to read the type. */
vte_table = read_vt_entry(td, id);
type = (const uint8_t *)td->buf + td->table + vte_type;
verify(*type || vte_table == 0, flatcc_verify_error_union_type_NONE_cannot_have_a_table);
return uvf(td, id, *type);
}
void Engine::unload_library(const void *data, const char *name)
{
if (m_process == 0) {
return;
}
for (DynLibList::iterator it = m_dyn_libs.begin();
it != m_dyn_libs.end(); it++) {
if (it->data == data) {
COIRESULT res;
OFFLOAD_DEBUG_TRACE(2,
"Unloading library \"%s\"\n",name);
res = COI::ProcessUnloadLibrary(m_process,it->lib);
m_dyn_libs.erase(it);
if (res != COI_SUCCESS) {
check_result(res, c_unload_library, m_index, res);
}
return;
}
}
}
tr_dh_ctx_t tr_dh_new(uint8_t const* prime_num, size_t prime_num_length, uint8_t const* generator_num,
size_t generator_num_length)
{
struct tr_dh_ctx* handle = tr_new0(struct tr_dh_ctx, 1);
TR_ASSERT(prime_num != NULL);
TR_ASSERT(generator_num != NULL);
API(InitDhKey)(&handle->dh);
if (!check_result(API(DhSetKey)(&handle->dh, prime_num, prime_num_length, generator_num, generator_num_length)))
{
tr_free(handle);
return NULL;
}
handle->key_length = prime_num_length;
return handle;
}
static void
printsoa(dns_rdata_t *rdata) {
dns_rdata_soa_t soa;
isc_result_t result;
char namebuf[DNS_NAME_FORMATSIZE];
result = dns_rdata_tostruct(rdata, &soa, NULL);
check_result(result, "dns_rdata_tostruct");
dns_name_format(&soa.origin, namebuf, sizeof(namebuf));
printf("\torigin = %s\n", namebuf);
dns_name_format(&soa.contact, namebuf, sizeof(namebuf));
printf("\tmail addr = %s\n", namebuf);
printf("\tserial = %u\n", soa.serial);
printf("\trefresh = %u\n", soa.refresh);
printf("\tretry = %u\n", soa.retry);
printf("\texpire = %u\n", soa.expire);
printf("\tminimum = %u\n", soa.minimum);
dns_rdata_freestruct(&soa);
}
