Пример #1
0
static void dr_metalib_validate_align_i(error_monitor_t em, LPDRMETALIB metalib) {
    int meta_pos;
    int meta_count;

    meta_count = dr_lib_meta_num(metalib);
    for(meta_pos = 0; meta_pos < meta_count; ++meta_pos) {
        LPDRMETA meta;
        int entry_pos;
        int entry_count;

        meta = dr_lib_meta_at(metalib, meta_pos);
        entry_count = dr_meta_entry_num(meta);

        for(entry_pos = 0; entry_pos < entry_count; ++entry_pos) {
            LPDRMETAENTRY entry = dr_meta_entry_at(meta, entry_pos);
            int align = dr_entry_align(entry);
            if (align != 1 && align != 2 && align != 4 && align != 8) {
                CPE_ERROR(
                    em, "%s.%s: type align %d error",
                    dr_meta_name(meta), dr_entry_name(entry), align);
                continue;
            }

            if ((int)dr_entry_data_start_pos(entry) % align) {
                CPE_ERROR(
                    em, "%s.%s: start pos error, align is %d, startpos is %d",
                    dr_meta_name(meta), dr_entry_name(entry),
                    align, (int)dr_entry_data_start_pos(entry));
                continue;
            }
        }
    }
}
Пример #2
0
int inet_sch_task_run(inet_sch_task_t task) {
    CURLMcode rc;

    assert(task);

    if (task->m_state != inet_sch_task_state_init) {
        CPE_ERROR(
            task->m_mgr->m_em, "%s: run task: task run in error state %d!",
            inet_sch_manage_name(task->m_mgr),
            task->m_state);
        return -1;
    }

    rc = curl_multi_add_handle(task->m_mgr->m_multi, task->m_handler);
    if (rc != CURLM_OK) {
        CPE_ERROR(
            task->m_mgr->m_em, "%s: run task: curl_multi_add_handle fail, %s(%d)!",
            inet_sch_manage_name(task->m_mgr),
            inet_sch_curl_code_msg(rc), rc);
        return -1;
    }

    task->m_state = inet_sch_task_state_runing;

    return 0;
}
Пример #3
0
void net_ep_cb(EV_P_ ev_io *w, int revents) {
    net_ep_t ep;
    int old_events;

    ep = (net_ep_t)w->data;
    assert(ep);

    old_events = net_ep_calc_ev_events(ep);

    if (revents & EV_READ) {
        int recv_size = ep->m_chanel_r->m_type->read_from_net(ep->m_chanel_r, ep->m_fd);
        if (recv_size < 0) {
            CPE_ERROR(
                ep->m_mgr->m_em,
                "net_mgr: ep %d: read data error, errno=%d (%s)",
                ep->m_id, cpe_sock_errno(), cpe_sock_errstr(cpe_sock_errno()));
            net_ep_close_i(ep, net_ep_event_close_by_error);
            return;
        }
        else if (recv_size == 0) {
            if (ep->m_mgr->m_debug) {
                CPE_INFO(ep->m_mgr->m_em, "net_mgr: ep %d: socket close by peer!", ep->m_id);
            }
            net_ep_close_i(ep, net_ep_event_close_by_peer);
            return;
        }
        else {
            if (ep->m_mgr->m_debug) {
                CPE_INFO(ep->m_mgr->m_em, "net_mgr: ep %d: receive %d types data!", ep->m_id, (int)recv_size);
            }

            if (ep->m_process_fun) {
                ep->m_process_fun(ep, ep->m_process_ctx, net_ep_event_read);
            }
        }
    }

    if (revents & EV_WRITE) {
        ssize_t send_size = ep->m_chanel_w->m_type->write_to_net(ep->m_chanel_w, ep->m_fd);
        if (send_size < 0) {
            CPE_ERROR(
                ep->m_mgr->m_em,
                "net_mgr: ep %d: write data error, errno=%d (%s)",
                ep->m_id, cpe_sock_errno(), cpe_sock_errstr(cpe_sock_errno()));
            net_ep_close_i(ep, net_ep_event_close_by_error);
            return;
        }
        else {
            if (ep->m_mgr->m_debug) {
                CPE_INFO(ep->m_mgr->m_em, "net_mgr: ep %d: send %d bytes data!", ep->m_id, (int)send_size);
            }
        }
    }

    net_ep_update_events(ep, old_events);
}
Пример #4
0
static void inet_sch_task_sock_event_cb(EV_P_ struct ev_io *w, int revents) {
    inet_sch_manage_t mgr;
    inet_sch_task_t task;
    CURLMcode rc;
    int action;

    task = (inet_sch_task_t)w->data;
    assert(task);

    mgr = task->m_mgr;

    action = (revents & EV_READ?CURL_POLL_IN : 0) | ( revents & EV_WRITE?CURL_POLL_OUT : 0);

    rc = curl_multi_socket_action(task->m_mgr->m_multi, w->fd, action, &mgr->m_still_running);
    if (rc != CURLM_OK) {
        CPE_ERROR(
            mgr->m_em, "%s: sock_event_cb: curl_multi_socket_handle fail, %s(%d)!",
            inet_sch_manage_name(task->m_mgr),
            inet_sch_curl_code_msg(rc), rc);
        return;
    }

    inet_sch_process_multi_info(mgr);
    if (mgr->m_still_running <= 0) {
        if (mgr->m_debug >= 2) {
            CPE_INFO(
                mgr->m_em, "%s: sock_event_cb: no task runing, stop timer!",
                inet_sch_manage_name(task->m_mgr));
        }
        ev_timer_stop(mgr->m_loop, &mgr->m_timer_event);
    }
}
Пример #5
0
dr_cvt_result_t dr_cvt_fun_copy_encode(
    LPDRMETA meta,
    void * output, size_t * output_capacity,
    const void * input, size_t * input_capacity,
    void * ctx,
    error_monitor_t em, int debug)
{
    int32_t size;
    size_t require_size = sizeof(size) + *input_capacity;

    if (*output_capacity < require_size) {
        CPE_ERROR(
            em, "encode %s: copy: not enought output buf, require %d(input=%d), but only %d!",
            dr_meta_name(meta), (int)require_size, (int)*input_capacity, (int)*output_capacity);
        return dr_cvt_result_not_enough_output;
    }

    size = *input_capacity;
    memcpy(output, &size, sizeof(size));
    memcpy(((char*)output) + sizeof(size), input, *input_capacity);

    *output_capacity = require_size;

    if (debug) {
        CPE_INFO(
            em, "encode %s: copy: copy %d data to output, input-size=%d",
            dr_meta_name(meta), (int)require_size, (int)*input_capacity);
    }

    return dr_cvt_result_success;
}
Пример #6
0
void inet_sch_process_multi_info(inet_sch_manage_t mgr) {
    CURLMsg *msg;

    while ((msg = curl_multi_info_read(mgr->m_multi, NULL))) {
        struct inet_sch_task * task;
        CURL * easy;
        CURLcode res;
        char * eff_url;

        easy = msg->easy_handle;
        res = msg->data.result;
        curl_easy_getinfo(easy, CURLINFO_PRIVATE, &task);
        curl_easy_getinfo(easy, CURLINFO_EFFECTIVE_URL, &eff_url);

        switch(msg->msg) {
        case CURLMSG_DONE: {
            if (mgr->m_debug) {
                CPE_INFO(mgr->m_em, "%s: DONE: %s => (%d) %s", inet_sch_manage_name(mgr), eff_url, res, ""/*connection->error*/);
            }
            inet_sch_task_complete(task);
            break;
        }
        default:
            CPE_ERROR(mgr->m_em, "%s: UNKNOWN: %s => (%d) %s", inet_sch_manage_name(mgr), eff_url, res, ""/*connection->error*/);
        }
    }
}
Пример #7
0
void net_ep_close_i(net_ep_t ep, net_ep_event_t ev) {
    assert(ep);
    assert(ev == net_ep_event_close_by_user
           || ev == net_ep_event_close_by_peer
           || ev == net_ep_event_close_by_error
           || ev == net_ep_event_close_by_shutdown);

    if (ep->m_fd < 0) return;

#ifdef _MSC_VER
    //if (ep->m_type = net_ep_socket) {
        net_socket_close(&ep->m_fd, ep->m_mgr->m_em);
    //}
    //else {
    //    CPE_ERROR(
    //        ep->m_mgr->m_em, "net_ep_close: close fail, errno=%d (%s)",
    //        cpe_sock_errno(), cpe_sock_errstr(cpe_sock_errno()));
    //}
#else
    if (close(ep->m_fd) != 0) {
        CPE_ERROR(
            ep->m_mgr->m_em, "net_ep_close: close fail, errno=%d (%s)",
            cpe_sock_errno(), cpe_sock_errstr(cpe_sock_errno()));
    }
#endif

    if (net_ep_calc_ev_events(ep)) {
        ev_io_stop(ep->m_mgr->m_ev_loop, &ep->m_watcher);
    }

    ep->m_fd = -1;

    if (ep->m_process_fun) ep->m_process_fun(ep, ep->m_process_ctx, ev);
}
Пример #8
0
dr_cvt_result_t dr_cvt_fun_bson_encode(
    LPDRMETA meta,
    void * output, size_t * output_capacity,
    const void * input, size_t * input_capacity,
    void * ctx,
    error_monitor_t em, int debug)
{
    int r;

    r = dr_bson_write(output, *output_capacity, input, *input_capacity, meta, em);
    if (r < 0) {
        CPE_ERROR(
            em, "encode %s: bson: fail, input buf "FMT_SIZE_T", output buf "FMT_SIZE_T,
            dr_meta_name(meta), *input_capacity, *output_capacity);
        return dr_cvt_result_error;
    }

    *output_capacity = r;

    if (debug) {
        CPE_INFO(
            em, "encode %s: bson: ok, %d data to output, input-size="FMT_SIZE_T,
            dr_meta_name(meta), r, *input_capacity);
    }

    return dr_cvt_result_success;
}
Пример #9
0
inet_sch_task_t inet_sch_task_create(inet_sch_manage_t mgr) {
    inet_sch_task_t task;

    task = mem_alloc(mgr->m_alloc, sizeof(struct inet_sch_task));
    if (task == NULL) return NULL;

    task->m_mgr = mgr;
    task->m_state = inet_sch_task_state_init;
    task->m_evset = 0;
    task->m_error[0] = '\0';

    task->m_handler = curl_easy_init();
    if (task->m_handler == NULL) {
        CPE_ERROR(
            mgr->m_em, "%s: create task: curl_easy_init fail!",
            inet_sch_manage_name(mgr));
        mem_free(mgr->m_alloc, task);
        return NULL;
    }
    curl_easy_setopt(task->m_handler, CURLOPT_PRIVATE, task);
    curl_easy_setopt(task->m_handler, CURLOPT_ERRORBUFFER, task->m_error);

    task->m_ev.data = task;

    return task;
}
Пример #10
0
static int do_generate_lib_c(cpe_dr_generate_ctx_t ctx) {
    struct write_stream_file stream;
    int i;
    int rv;

    rv = 0;

    for(i = 0; i < o_lib_c->count; ++i) {
        FILE * fp;

        if (o_lib_c_arg->count == 0) {
            CPE_ERROR(ctx->m_em, "not arg name setted!");
            return -1;
        }

        fp = file_stream_open(o_lib_c->filename[i], "w", ctx->m_em);
        if (fp == NULL) {
            rv = -1;
            continue;
        }

        write_stream_file_init(&stream, fp, ctx->m_em);

        cpe_dr_generate_lib_c((write_stream_t)&stream, o_lib_c_arg->sval[0], ctx);

        file_stream_close(fp, ctx->m_em);
    }

    return rv;
}
Пример #11
0
int main(int argc, char * argv[]) {
    void* argtable[] = {
                input = arg_filen(   "i",   "input",              "<string>", 0, 100,    "input file")
        ,  o_validate = arg_strn(   "v",  "validate",     "<string>",         0, 10,   "validate operations")
        ,         o_h = arg_file0(   NULL,  "output-h",           "<string>",            "output h file dir")
        ,     o_lib_c = arg_file0(   NULL,  "output-lib-c",       "<string>",            "output c lib file")
        , o_lib_c_arg = arg_str0(   NULL,  "output-lib-c-arg",    "<string>",            "output c lib file")
        ,   o_lib_bin = arg_file0(   NULL,  "output-lib-bin",     "<string>",            "output c lib file")
        ,        help = arg_lit0(   NULL,  "help",                                   "print this help and exit")
        ,         end = arg_end(20)
    };

    struct error_monitor em_buf;
    error_monitor_t em;
    int rv;
    int nerrors;

    cpe_error_monitor_init(&em_buf, cpe_error_log_to_consol, 0);
    em = &em_buf;

    rv = -1;

    if (arg_nullcheck(argtable) != 0) {
        CPE_ERROR(em, "init arg table fail!");
        goto exit;
    }

    nerrors = arg_parse(argc,argv,argtable);

    if (help->count > 0) {
        printf("Usage: %s", argv[0]);
        arg_print_syntax(stdout,argtable,"\n");
        rv = 0;
        goto exit;
    }

    if (nerrors > 0) {
        arg_print_errors(stdout, end, argv[0]);
        printf("Try '%s --help' for more information.\n", argv[0]);
        goto exit;
    }

    rv = tools_main(em);

exit:
    arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0]));

    return rv;
}
Пример #12
0
int tools_main(error_monitor_t em) {
    struct cpe_dr_generate_ctx ctx;
    struct mem_buffer buffer;
    int rv;

    ctx.m_builder = NULL;
    ctx.m_metalib = NULL;
    ctx.m_em = em;

    rv = 0;

    ctx.m_builder = dr_metalib_builder_create(NULL, em);
    if (ctx.m_builder == NULL) {
        CPE_ERROR(em, "create metalib builder fail!");
        return -1;
    }

    prepare_input(ctx.m_builder, em);

    dr_metalib_builder_analize(ctx.m_builder);

    mem_buffer_init(&buffer, 0);
    if (dr_inbuild_build_lib(
            &buffer,
            dr_metalib_bilder_lib(ctx.m_builder),
            em) == 0)
    {
        ctx.m_metalib = (LPDRMETALIB)mem_buffer_make_continuous(&buffer, 0), mem_buffer_size(&buffer);

        if (ctx.m_metalib) {
            if (do_validate(&ctx) != 0) rv = -1;
            if (do_generate_h(&ctx) != 0) rv = -1;
            if (do_generate_lib_bin(&ctx) != 0) rv = -1;
            if (do_generate_lib_c(&ctx) != 0) rv = -1;
        }
    }
    else {
        rv = -1;
    }

    mem_buffer_clear(&buffer);
    dr_metalib_builder_free(ctx.m_builder);

    return rv;
}
Пример #13
0
static void inet_sch_timer_cb(EV_P_ struct ev_timer *w, int revents) {
    CURLMcode rc;
    inet_sch_manage_t mgr = (inet_sch_manage_t)w->data;

    if (mgr->m_debug >= 2) {
        CPE_INFO(
            mgr->m_em, "%s: timer: event=%d",
            inet_sch_manage_name(mgr), revents);
    }

    rc = curl_multi_socket_action(mgr->m_multi, CURL_SOCKET_TIMEOUT, 0, &mgr->m_still_running);
    if (rc != CURLM_OK) {
        CPE_ERROR(
            mgr->m_em, "%s: timer: curl_multi_socket_action fail, %d(%s)",
            inet_sch_manage_name(mgr), rc, inet_sch_curl_code_msg(rc));
    }

    inet_sch_process_multi_info(mgr);
}
Пример #14
0
int net_ep_set_fd(net_ep_t ep, int fd) {
    assert(ep);

    if (net_ep_is_open(ep)) {
        CPE_ERROR(
            ep->m_mgr->m_em, "net_mgr: ep %d: set fd to a opend ep",
            (int)ep->m_id);
        net_ep_close_i(ep, net_ep_event_close_by_error);
    }

    ep->m_fd = fd;

    ep->m_watcher.data = ep;
    ev_init(&ep->m_watcher, net_ep_cb);

    net_ep_update_events(ep, 0);

    return 0;
}
Пример #15
0
int do_validate(cpe_dr_generate_ctx_t ctx) {
    int rv;
    int i;

    rv = 0;

    for(i = 0; i < o_validate->count; ++i) {
        const char * validate_name;

        validate_name = o_validate->sval[i];
        if (strcmp(validate_name, "align") == 0) {
            if (dr_metalib_validate_align(ctx->m_em, ctx->m_metalib) != 0) {
                rv = -1;
            }
        }
        else {
            CPE_ERROR(ctx->m_em, "validate %s is unknown!", validate_name);
            rv = -1;
        }
    }

    return rv;
}
Пример #16
0
void prepare_input(dr_metalib_builder_t builder, error_monitor_t em) {
    int i;
    for(i = 0; i < input->count; ++i) {
        const char * filename;
        size_t filename_len;

        filename = input->filename[i];
        filename_len = strlen(filename);
        if (filename[filename_len - 1] == '\\' || filename[filename_len - 1] == '/') {
            ((char *)filename)[filename_len - 1] = 0;
        }

        if (dir_exist(filename, em)) {
            dir_search(&g_input_search_visitor, builder, filename, 5, em, NULL);
        }
        else if (file_exist(input->filename[i], em)) {
            dr_metalib_builder_add_file(builder, NULL, filename);
        }
        else {
            CPE_ERROR(em, "input %s not exist!", filename);
        }
    }
}
Пример #17
0
net_mgr_t
net_mgr_create(mem_allocrator_t alloc, error_monitor_t em) {
    net_mgr_t nmgr;

    nmgr = (net_mgr_t)mem_alloc(alloc, sizeof(struct net_mgr));
    if (nmgr == NULL) return NULL;
    bzero(nmgr, sizeof(struct net_mgr));

    if (cpe_range_mgr_init(&nmgr->m_ep_ids, alloc) != 0) {
        CPE_ERROR(em, "init ep ids fail!");
        mem_free(alloc, nmgr);
        return NULL;
    }

    nmgr->m_ev_loop = ev_loop_new(EVFLAG_AUTO);
    if (!nmgr->m_ev_loop) {
        CPE_ERROR(em, "net_mgr_create: create event loop fail!");
        cpe_range_mgr_fini(&nmgr->m_ep_ids);
        mem_free(alloc, nmgr);
        return NULL;
    }

    nmgr->m_alloc = alloc;
    nmgr->m_em = em;
    nmgr->m_debug = 0;
    nmgr->m_ep_page_capacity = 0;
    nmgr->m_ep_pages = NULL;

    TAILQ_INIT(&nmgr->m_chanels);

    if (cpe_hash_table_init(
            &nmgr->m_listeners,
            alloc,
            (cpe_hash_fun_t)net_listener_hash,
            (cpe_hash_cmp_t)net_listener_cmp,
            CPE_HASH_OBJ2ENTRY(net_listener, m_hh),
            256) != 0)
    {
        CPE_ERROR(em, "net_mgr_create: init listener hash list fail!");
        cpe_range_mgr_fini(&nmgr->m_ep_ids);
        mem_free(alloc, nmgr);
        return NULL;
    }

    if (cpe_hash_table_init(
            &nmgr->m_connectors,
            alloc,
            (cpe_hash_fun_t)net_connector_hash,
            (cpe_hash_cmp_t)net_connector_cmp,
            CPE_HASH_OBJ2ENTRY(net_connector, m_hh),
            256) != 0)
    {
        CPE_ERROR(em, "net_mgr_create: init connector hash list fail!");
        cpe_hash_table_fini(&nmgr->m_listeners);
        cpe_range_mgr_fini(&nmgr->m_ep_ids);
        mem_free(alloc, nmgr);
        return NULL;
    }

    return nmgr;
}
Пример #18
0
dr_dm_data_t
dr_dm_data_create(dr_dm_manage_t mgr, const void * data, size_t data_size, const char ** duplicate_index) {
    char * buf;
    dr_dm_data_t role;
    size_t data_capacity;
    dr_dm_data_id_t role_id;
    int generate_role_id;
    size_t index_count;
    struct cpe_hash_it index_it;
    struct dr_dm_data_index * index;
    size_t i;

    index_count = cpe_hash_table_count(&mgr->m_indexes);

    if (duplicate_index) *duplicate_index = NULL;

    if (mgr->m_role_meta == NULL) {
        CPE_ERROR(
            mgr->m_em, "%s: dr_dm_data_create: role meta not exist!",
            dr_dm_manage_name(mgr));
        return NULL;
    }

    if (mgr->m_id_index == NULL) {
        CPE_ERROR(
            mgr->m_em, "%s: dr_dm_data_create: role id entry not exist!",
            dr_dm_manage_name(mgr));
        return NULL;
    }

    data_capacity = dr_meta_size(mgr->m_role_meta);
    if (data_size > data_capacity) {
        CPE_ERROR(
            mgr->m_em, "%s: dr_dm_data_create: data too long, data_size=%d, data_capacity=%d!",
            dr_dm_manage_name(mgr), (int)data_size, (int)data_capacity);
        return NULL;
    }

    generate_role_id = 0;
    role_id = dr_entry_read_int64(data, mgr->m_id_index->m_entry);
    if (role_id == 0) {
        if (mgr->m_id_generate) {
            if (gd_id_generator_generate(&role_id, mgr->m_id_generate) != 0) {
                CPE_ERROR(
                    mgr->m_em, "%s: dr_dm_data_create: generate id from %s fail!",
                    dr_dm_manage_name(mgr), gd_id_generator_name(mgr->m_id_generate));
                return NULL;
            }
            else {
                generate_role_id = 1;
            }
        }
    }

    buf = (char *)mem_alloc(
        mgr->m_alloc,
        sizeof(struct cpe_hash_entry) * index_count
        + sizeof(struct dr_dm_data)
        + data_capacity);
    if (buf == NULL) return NULL;

    role = (dr_dm_data_t)(buf + sizeof(struct cpe_hash_entry) * index_count);

    role->m_mgr = mgr;

    memcpy(dr_dm_data_data(role), data, data_capacity);

    if (generate_role_id) {
        if (dr_entry_set_from_int64(dr_dm_data_data(role), role_id, mgr->m_id_index->m_entry, NULL) != 0) {
            CPE_ERROR(
                mgr->m_em, "%s: dr_dm_data_create: set generated id to data fail!",
                dr_dm_manage_name(mgr));
            mem_free(mgr->m_alloc, buf);
            return NULL;
        }
    }

    for(i = 0; i < index_count; ++i) {
        cpe_hash_entry_init(((struct cpe_hash_entry*)buf) + i);
    }

    cpe_hash_it_init(&index_it, &mgr->m_indexes);
    while((index = cpe_hash_it_next(&index_it))) {
        if (dr_dm_data_index_add(index, role) != 0) {
            struct dr_dm_data_index * index_fall_back;

            CPE_ERROR(
                mgr->m_em, "%s: dr_dm_data_create: add to index %s: duplicate!",
                dr_dm_manage_name(mgr), dr_entry_name(index->m_entry));

            if (duplicate_index) *duplicate_index = dr_dm_data_index_name(index);

            cpe_hash_it_init(&index_it, &mgr->m_indexes);
            while((index_fall_back = cpe_hash_it_next(&index_it)) && index_fall_back != index) {
                dr_dm_data_index_remove(index_fall_back, role);
            }
            
            mem_free(mgr->m_alloc, buf);
            return NULL;
        }
    }

    return role;
}