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 = '.';
}
