tt_result_t tt_xdoc_render_file(IN tt_xdoc_t *xd, IN const tt_char_t *path, IN OPT tt_xdoc_render_attr_t *attr) { TT_ASSERT(xd != NULL); TT_ASSERT(path != NULL); pugi::xml_document *p = static_cast<pugi::xml_document *>(xd->p); TT_ASSERT(p != NULL); tt_xdoc_render_attr_t __attr; if (attr == NULL) { tt_xdoc_render_attr_default(&__attr); attr = &__attr; } __xw_file xwf(path); p->save(xwf, attr->indent, __render_option(attr), __encoding_map[attr->encoding]); if (xwf.error()) { TT_ERROR("fail to render xml"); return TT_FAIL; } return TT_SUCCESS; }
tt_result_t tt_dll_create_ntv(IN tt_dll_ntv_t *dll, IN const tt_char_t *path, IN OPT tt_dll_attr_t *attr) { void *handle; DWORD dwFlags = 0; wchar_t *w_path; TT_ASSERT(dll != NULL); TT_ASSERT(path != NULL); // may set mode according to attr; // dwFlags |= ...; w_path = tt_wchar_create(path, 0, NULL); if (w_path == NULL) { return TT_FAIL; } handle = LoadLibraryExW(w_path, NULL, dwFlags); tt_wchar_destroy(w_path); if (handle == NULL) { TT_ERROR_NTV("LoadLibraryExW failed: %s"); return TT_FAIL; } dll->handle = handle; return TT_SUCCESS; }
tt_result_t tt_xdoc_render(IN tt_xdoc_t *xd, IN tt_u8_t *buf, IN tt_u32_t len, IN OPT tt_xdoc_render_attr_t *attr) { TT_ASSERT(xd != NULL); TT_ASSERT(buf != NULL); pugi::xml_document *p = static_cast<pugi::xml_document *>(xd->p); TT_ASSERT(p != NULL); tt_xdoc_render_attr_t __attr; if (attr == NULL) { tt_xdoc_render_attr_default(&__attr); attr = &__attr; } __xw_mem xwm(buf, len); p->save(xwm, attr->indent, __render_option(attr), __encoding_map[attr->encoding]); if (xwm.error()) { TT_ERROR("fail to render xml"); return TT_FAIL; } return TT_SUCCESS; }
tt_sshmsg_t *tt_sshmsg_create(IN tt_u32_t msg_id, IN tt_u32_t msg_len, IN tt_sshmsg_itf_t *itf) { tt_sshmsg_t *msg; TT_ASSERT(itf != NULL); TT_ASSERT(itf->render_prepare != NULL); TT_ASSERT(itf->render != NULL); TT_ASSERT(itf->parse != NULL); msg_len += sizeof(tt_sshmsg_t); msg = (tt_sshmsg_t *)tt_malloc(msg_len); tt_memset(msg, 0, msg_len); if (msg != NULL) { msg->msg_id = msg_id; msg->msg_private = 0; tt_atomic_s32_set(&msg->ref, 1); tt_buf_init(&msg->buf, NULL); msg->itf = itf; // flags are all set to 0 if ((msg->itf->create != NULL) && !TT_OK(msg->itf->create(msg))) { tt_buf_destroy(&msg->buf); tt_free(msg); return NULL; } } return msg; }
tt_result_t tt_ecdsa_load(IN tt_ecdsa_t *dsa, IN tt_pk_t *pk) { mbedtls_ecdsa_context *ctx; mbedtls_ecp_keypair *ec; int e; TT_ASSERT(dsa != NULL); TT_ASSERT(pk != NULL); if (tt_pk_get_type(pk) != TT_ECKEY) { TT_ERROR("pk is not ec key"); return TT_FAIL; } ctx = &dsa->ctx; ec = mbedtls_pk_ec(pk->ctx); e = mbedtls_ecdsa_from_keypair(ctx, ec); if (e != 0) { tt_crypto_error("fail to copy ec key"); mbedtls_ecdsa_free(ctx); return TT_FAIL; } return TT_SUCCESS; }
tt_u32_t __sh_on_cmd(IN tt_cli_t *cli, IN void *param, IN const tt_char_t *line, IN tt_buf_t *output) { tt_shell_t *sh = TT_CONTAINER(cli, tt_shell_t, cli); const tt_char_t *name; tt_shcmd_t *cmd; tt_cfgobj_t *co; if (line[0] == 0) { return TT_CLIOC_NOOUT; } sh->arg_num = 0; if (!TT_OK(__parse_arg(sh, (tt_char_t *)line)) || (sh->arg_num == 0)) { tt_buf_putf(output, "bad input: ", line); return TT_CLIOC_OUT; } name = sh->arg[0]; // run as a command cmd = tt_shcmd_find(name); if (cmd != NULL) { TT_ASSERT(cmd->run != NULL); TT_ASSERT(sh->arg_num > 0); // exclude the command name return cmd->run(sh, sh->arg_num - 1, &sh->arg[1], output); } // run as a executable object co = tt_cfgpath_p2n(sh->root, sh->current, name, (tt_u32_t)tt_strlen(name)); if (co == NULL) { tt_buf_putf(output, "not found: %s", name); return TT_CLIOC_OUT; } else if (co->type != TT_CFGOBJ_EXE) { tt_buf_putf(output, "not executable: %s", name); return TT_CLIOC_OUT; } else { tt_u32_t rp, wp; tt_result_t result; tt_u32_t status = TT_CLIOC_NOOUT; tt_buf_backup_rwp(output, &rp, &wp); result = tt_cfgexe_run(TT_CFGOBJ_CAST(co, tt_cfgexe_t), sh->arg_num - 1, &sh->arg[1], tt_g_sh_line_sep, output, &status); if (TT_OK(result)) { return status; } else { tt_buf_restore_rwp(output, &rp, &wp); tt_buf_putf(output, "%s: failed", name); return TT_CLIOC_OUT; } } }
void tt_console_set_color(IN tt_console_color_t foreground, IN tt_console_color_t background) { TT_ASSERT(TT_CONSOLE_COLOR_VALID(foreground)); TT_ASSERT(TT_CONSOLE_COLOR_VALID(background)); tt_console_set_color_ntv(foreground, background); }
tt_result_t tt_console_config(IN tt_console_attr_t *attr) { TT_ASSERT(attr != NULL); TT_ASSERT(TT_CONSOLE_IMODE_VALID(attr->input_mode)); TT_ASSERT(TT_CONSOLE_OMODE_VALID(attr->output_mode)); return tt_console_config_ntv(attr); }
void tt_sshmsg_chopc_set_pktsize(IN tt_sshmsg_t *msg, IN tt_u32_t packet_size) { tt_sshmsg_chopc_t *chopc; TT_ASSERT(msg != NULL); TT_ASSERT(msg->msg_id == TT_SSH_MSGID_CHANNEL_OPEN_CONFIRMATION); chopc = TT_SSHMSG_CAST(msg, tt_sshmsg_chopc_t); chopc->packet_size = packet_size; }
tt_result_t __put_arg(IN tt_shell_t *sh, IN tt_char_t *arg) { TT_ASSERT(sh->arg_num <= sh->arg_size); if ((sh->arg_num == sh->arg_size) && !TT_OK(__expand_arg(sh))) { return TT_FAIL; } TT_ASSERT(sh->arg_num < sh->arg_size); sh->arg[sh->arg_num++] = arg; return TT_SUCCESS; }
void tt_sshmsg_chopc_set_sndchnum(IN tt_sshmsg_t *msg, IN tt_u32_t snd_chnum) { tt_sshmsg_chopc_t *chopc; TT_ASSERT(msg != NULL); TT_ASSERT(msg->msg_id == TT_SSH_MSGID_CHANNEL_OPEN_CONFIRMATION); chopc = TT_SSHMSG_CAST(msg, tt_sshmsg_chopc_t); chopc->snd_chnum = snd_chnum; }
void TTValue::test() { // Test == operator (was broken prior to 2009-12-03) // TODO: replace with test-assertions TTValue a = TTValue(2); TTValue c = TTValue(2); TTValue b = TTValue(33); TT_ASSERT("== comparison for the same value", bool(a == c)); TT_ASSERT("== comparison for different values", !bool(a == b)); }
void __sshmsg_destroy(IN tt_sshmsg_t *msg) { TT_ASSERT(msg != NULL); TT_ASSERT(msg->itf != NULL); if ((msg->itf != NULL) && (msg->itf->destroy != NULL)) { msg->itf->destroy(msg); } tt_buf_destroy(&msg->buf); tt_free(msg); }
void tt_sshmsg_glbreq_set_wantreply(IN tt_sshmsg_t *msg, IN tt_bool_t want_reply) { tt_sshmsg_glbreq_t *gr; TT_ASSERT(msg != NULL); TT_ASSERT(msg->msg_id == TT_SSH_MSGID_GLOBAL_REQUEST); gr = TT_SSHMSG_CAST(msg, tt_sshmsg_glbreq_t); gr->want_reply = want_reply; }
tt_result_t tt_cli_output(IN tt_cli_t *cli, IN tt_u8_t *ev, IN tt_u32_t ev_num) { TT_ASSERT(cli != NULL); TT_ASSERT(ev != NULL); if (ev_num == 0) { return TT_SUCCESS; } if (cli->itf.send == NULL) { return TT_SUCCESS; } return cli->itf.send(cli, cli->itf.param, ev, ev_num); }
void *tt_dll_symbol_ntv(IN tt_dll_ntv_t *dll, IN const tt_char_t *symbol_name) { FARPROC sym; TT_ASSERT(dll != NULL); TT_ASSERT(symbol_name != NULL); sym = GetProcAddress(dll->handle, symbol_name); if (sym == NULL) { TT_ERROR_NTV("GetProcAddress failed"); return NULL; } return sym; }
tt_result_t tt_xdoc_parse_file(IN tt_xdoc_t *xd, IN const tt_char_t *path, IN OPT tt_xdoc_parse_attr_t *attr) { TT_ASSERT(xd != NULL); TT_ASSERT(path != NULL); pugi::xml_document *p; if (xd->p != NULL) { p = static_cast<pugi::xml_document *>(xd->p); p->reset(); } else { p = new pugi::xml_document(); if (p == NULL) { TT_ERROR("fail to new xml doc"); return TT_FAIL; } } tt_xdoc_parse_attr_t __attr; if (attr == NULL) { tt_xdoc_parse_attr_default(&__attr); attr = &__attr; } tt_buf_t buf; tt_buf_init(&buf, NULL); if (!TT_OK(tt_fcontent_buf(path, &buf)) || !TT_OK(tt_buf_put_u8(&buf, 0))) { tt_buf_destroy(&buf); p->reset(); return TT_FAIL; } pugi::xml_parse_result r; r = p->load_buffer(TT_BUF_RPOS(&buf), TT_BUF_RLEN(&buf), __parse_option(attr), __encoding_map[attr->encoding]); tt_buf_destroy(&buf); if (!r) { TT_ERROR("fail to parse xml: %s", r.description()); p->reset(); return TT_FAIL; } xd->p = p; return TT_SUCCESS; }
void tt_console_run(IN tt_cons_ev_handler_t ev_handler, IN void *param, IN tt_bool_t local) { TT_ASSERT(ev_handler != NULL); if (!TT_OK(tt_atomic_s32_cas(&tt_s_console_running, 0, 1))) { TT_ERROR("console is already running"); return; } tt_s_console_ev_handler = ev_handler; tt_s_console_param = param; if (local) { __console_run(); } else { tt_thread_attr_t attr; tt_thread_attr_default(&attr); attr.detached = TT_TRUE; if (tt_thread_create(__console_thread, NULL, &attr) == NULL) { TT_ERROR("fail to craete console thread"); } } }
tt_u32_t tt_ptrvec_find_range(IN tt_ptrvec_t *pvec, IN tt_ptr_t p, IN tt_u32_t from_idx, IN tt_u32_t to_idx) { tt_u32_t i; TT_ASSERT_ALWAYS(from_idx <= to_idx); if (from_idx >= pvec->count) { return TT_POS_NULL; } if (to_idx >= pvec->count) { to_idx = pvec->count; } TT_ASSERT(pvec->cmp != NULL); for (i = from_idx; i < to_idx; ++i) { if (pvec->cmp(pvec->ptr[i], p) == 0) { return i; } } return TT_POS_NULL; }
tt_result_t __def_on_enter(IN tt_cli_t *cli) { tt_buf_t *outbuf = &cli->outbuf; const tt_char_t *cmd = tt_cline_cstr(&cli->cline); tt_u32_t status; // echo the enter TT_DO(tt_buf_put_u8(outbuf, TT_CLI_EV_ENTER)); if (cmd[0] != 0) { status = __cli_on_cmd(cli, cmd, outbuf); } else { status = TT_CLIOC_NOOUT; } tt_cline_reset(&cli->cline); if (status == TT_CLIOC_NOOUT) { if (cli->read_mode == __CLI_NOT_READ) { // no output, so no need print a crlf TT_DO(cli->newline(cli, TT_FALSE, TT_TRUE, TT_TRUE)); } return TT_SUCCESS; } else if (status == TT_CLIOC_OUT) { if (cli->read_mode == __CLI_NOT_READ) { TT_DO(cli->newline(cli, TT_TRUE, TT_TRUE, TT_TRUE)); } return TT_SUCCESS; } else { TT_ASSERT(status == TT_CLIOC_END); if (__cli_on_quit(cli, outbuf)) { TT_DO(tt_buf_put_u8(outbuf, TT_CLI_EV_ENTER)); } return TT_E_END; } }
tt_result_t __def_newline(IN tt_cli_t *cli, IN tt_bool_t crlf, IN tt_bool_t prefix, IN tt_bool_t line) { tt_buf_t *outbuf = &cli->outbuf; if (crlf) { TT_DO(tt_buf_put_u8(outbuf, TT_CLI_EV_ENTER)); } if (prefix) { TT_DO(tt_buf_put(outbuf, (tt_u8_t *)tt_string_cstr(&cli->prefix), tt_string_len(&cli->prefix))); } if (line) { tt_string_t *s = &cli->cline.line; tt_u32_t s_len = tt_string_len(s); TT_DO(tt_buf_put(outbuf, (tt_u8_t *)tt_string_cstr(s), s_len)); TT_ASSERT(cli->cline.cursor <= s_len); TT_DO( tt_buf_put_rep(outbuf, TT_CLI_EV_LEFT, s_len - cli->cline.cursor)); } return TT_SUCCESS; }
tt_bool_t __do_read_write(IN tt_io_ev_t *io_ev) { __dskt_t *dskt = TT_CONTAINER(io_ev, __dskt_t, ev); uint32_t events = io_ev->epev->events; ares_socket_t rs, ws; TT_ASSERT(dskt->status = __DNS_READ_WRITE); dskt->status = __DNS_NULL; if (events & ~EPOLLOUT) { // read if it sees any ev other than EPOLLOUT(EPOLLIN, error, etc.) rs = __DSKT_IDX(dskt); } else { rs = ARES_SOCKET_BAD; } if (events & EPOLLOUT) { ws = __DSKT_IDX(dskt); } else { ws = ARES_SOCKET_BAD; } ares_process_fd(dskt->ch, rs, ws); return TT_TRUE; }
void __worker_io(IN tt_io_ev_t *io_ev) { TT_ASSERT(TT_IO_WORKER_EV_VALID(io_ev->ev)); // the only event is TT_IO_WORKER_EXIT tt_free(io_ev); tt_thread_exit(); }
void tt_sh_attr_default(IN tt_sh_attr_t *attr) { TT_ASSERT(attr != NULL); attr->exit_msg = "exiting..."; tt_cli_attr_default(&attr->cli_attr); }
void tt_io_worker_destroy(IN tt_io_worker_t *w) { TT_ASSERT(w != NULL); if (w->thread != NULL) { tt_thread_wait(w->thread); } }
TTValue::operator TTObject*() const { TT_ASSERT(ttvalue_cast_to_object_ptr, *type == kTypeObject); if (*type == kTypeObject) return data->object; else return NULL; }
tt_result_t tt_sshmsg_uab_set_banner(IN tt_sshmsg_t *msg, IN const tt_char_t *banner) { tt_sshmsg_uab_t *uab; TT_ASSERT(msg != NULL); TT_ASSERT(msg->msg_id == TT_SSH_MSGID_USERAUTH_BANNER); TT_ASSERT(banner != NULL); uab = TT_SSHMSG_CAST(msg, tt_sshmsg_uab_t); tt_buf_reset_rwp(&uab->banner); TT_DO(tt_buf_put(&uab->banner, (tt_u8_t *)banner, (tt_u32_t)tt_strlen(banner))); return TT_SUCCESS; }
void tt_sshsvr_state_kexdh(IN struct tt_sshsvrconn_s *svrconn, IN tt_sshsvr_event_t event, IN void *param, OUT tt_sshsvr_action_t *svract) { tt_result_t result; TT_ASSERT(event < TT_SSHSVREV_NUM); switch (event) { case TT_SSHSVREV_PACKET: { __svr_kexdh_packet(svrconn, (tt_sshmsg_t *)param, svract); return; } break; case TT_SSHSVREV_KEXDH_REPLY: { tt_sshmsg_t *newkeys; result = __svr_kexdh_reply(svrconn, param); if (!TT_OK(result)) { svract->new_event = TT_SSHSVREV_DISCONNECT; return; } // send SSH_MSG_NEWKEYS newkeys = tt_sshms_newkeys_create(); if (newkeys == NULL) { svract->new_event = TT_SSHSVREV_DISCONNECT; return; } if (!TT_OK(tt_sshsvrconn_send(svrconn, newkeys))) { tt_sshmsg_release(newkeys); svract->new_event = TT_SSHSVREV_DISCONNECT; return; } svrconn->ms_newkeys_out = TT_TRUE; if (svrconn->ms_newkeys_in) { svract->new_state = TT_SSHSVRST_KEX_DONE; // remove unnecessary things tt_sshctx_clear(&svrconn->ctx); return; } return; } break; default: { TT_SSH_EV_IGNORED(TT_SSHSVRST_KEXDH, event); return; } break; } }
void tt_list_insert_after(IN tt_lnode_t *pos, IN tt_lnode_t *node) { tt_list_t *lst = pos->lst; TT_ASSERT(node->lst == NULL); TT_ASSERT(lst != NULL); node->prev = pos; node->next = pos->next; node->lst = lst; if (pos->next != NULL) { pos->next->prev = node; } else { lst->tail = node; } pos->next = node; ++lst->count; }
void tt_console_attr_default(IN tt_console_attr_t *attr) { TT_ASSERT(attr != NULL); attr->input_mode = TT_CONSOLE_IMODE_DEFAULT; attr->output_mode = TT_CONSOLE_OMODE_DEFAULT; // default subst: '.' attr->unprintable_substitutor = '.'; }