static void
mln_ipc_fd_handler_master_process(mln_event_t *ev, mln_fork_t *f)
{
mln_tcp_conn_t *tc = &(f->conn);
while (1) {
while (f->error_bytes) {
f->error_bytes = mln_ipc_discard_bytes(tc, f->error_bytes);
}
switch (f->state) {
case STATE_IDLE:
{
if (mln_ipc_get_buf_with_len(tc, &(f->msg_len), M_F_LENLEN) < 0) {
return;
}
f->state = STATE_LENGTH;
}
case STATE_LENGTH:
{
if (f->msg_content == NULL) {
f->msg_content = malloc(f->msg_len);
if (f->msg_content == NULL) {
f->error_bytes = f->msg_len;
f->state = STATE_IDLE;
break;
}
}
if (mln_ipc_get_buf_with_len(tc, f->msg_content, f->msg_len) < 0) {
return;
}
memcpy(&(f->msg_type), f->msg_content, M_F_TYPELEN);
f->state = STATE_IDLE;
mln_ipc_handler_t ih;
ih.type = f->msg_type;
mln_rbtree_node_t *rn = mln_rbtree_search(master_ipc_tree, \
master_ipc_tree->root, \
&ih);
if (!mln_rbtree_null(rn, master_ipc_tree)) {
mln_ipc_handler_t *ihp = (mln_ipc_handler_t *)(rn->data);
if (ihp->handler != NULL)
ihp->handler(ev, \
f, \
f->msg_content+M_F_TYPELEN, \
f->msg_len-M_F_TYPELEN, \
&(ihp->data));
}
free(f->msg_content);
f->msg_content = NULL;
break;
}
default:
mln_log(error, "No such state!\n");
abort();
}
}
}
static void
mln_ipc_fd_handler_worker_process(mln_event_t *ev, mln_tcp_conn_t *tc)
{
while (1) {
while (child_error_bytes) {
child_error_bytes = mln_ipc_discard_bytes(tc, child_error_bytes);
}
switch (child_state) {
case STATE_IDLE:
{
if (mln_ipc_get_buf_with_len(tc, &(cur_msg_len), M_F_LENLEN) < 0) {
return;
}
child_state = STATE_LENGTH;
}
case STATE_LENGTH:
{
if (child_msg_content == NULL) {
child_msg_content = (mln_u8ptr_t)malloc(cur_msg_len);
if (child_msg_content == NULL) {
child_error_bytes = cur_msg_len;
child_state = STATE_IDLE;
break;
}
}
if (mln_ipc_get_buf_with_len(tc, child_msg_content, cur_msg_len) < 0) {
return;
}
memcpy(&cur_msg_type, child_msg_content, M_F_TYPELEN);
child_state = STATE_IDLE;
mln_ipc_handler_t ih;
ih.type = cur_msg_type;
mln_rbtree_node_t *rn = mln_rbtree_search(worker_ipc_tree, \
worker_ipc_tree->root, \
&ih);
if (!mln_rbtree_null(rn, worker_ipc_tree)) {
mln_ipc_handler_t *ihp = (mln_ipc_handler_t *)(rn->data);
if (ihp->handler != NULL)
ihp->handler(ev, \
tc, \
child_msg_content+M_F_TYPELEN, \
cur_msg_len-M_F_TYPELEN, \
&(ihp->data));
}
free(child_msg_content);
child_msg_content = NULL;
break;
}
default:
mln_log(error, "No such state!\n");
abort();
}
}
}
static mln_conf_domain_t *
mln_conf_search_domain(mln_conf_t *cf, char *domain_name)
{
mln_string_t str;
mln_rbtree_node_t *rn;
mln_conf_domain_t tmp;
mln_string_set(&str, domain_name);
tmp.domain_name = &str;
rn = mln_rbtree_search(cf->domain, cf->domain->root, &tmp);
if (mln_rbtree_null(rn, cf->domain)) return NULL;
return (mln_conf_domain_t *)(rn->data);
}
static mln_conf_cmd_t *
mln_conf_search_cmd(mln_conf_domain_t *cd, char *cmd_name)
{
mln_string_t str;
mln_conf_cmd_t cmd;
mln_rbtree_node_t *rn;
cmd.cmd_name = &str;
mln_string_set(&str, cmd_name);
rn = mln_rbtree_search(cd->cmd, cd->cmd->root, &cmd);
if (mln_rbtree_null(rn, cd->cmd)) return NULL;
return (mln_conf_cmd_t *)(rn->data);
}
/*mln_set_worker_ipc_handler*/
void mln_set_worker_ipc_handler(mln_ipc_handler_t *ih)
{
mln_rbtree_node_t *rn = mln_rbtree_search(worker_ipc_tree, \
worker_ipc_tree->root, \
ih);
if (rn->data != NULL) {
mln_log(error, "IPC type '%d' already existed.\n", ih->type);
abort();
}
rn = mln_rbtree_new_node(worker_ipc_tree, ih);
if (rn == NULL) {
mln_log(error, "No memory.\n");
abort();
}
mln_rbtree_insert(worker_ipc_tree, rn);
}
int mln_conf_load(void)
{
gConf = mln_conf_init();
if (gConf == NULL) return -1;
mln_rbtree_node_t *rn;
mln_conf_domain_t *cd, tmp;
tmp.domain_name = &default_domain;
rn = mln_rbtree_search(gConf->domain, gConf->domain->root, &tmp);
cd = (mln_conf_domain_t *)(rn->data);
mln_s32_t ret = _mln_conf_load(gConf, cd);
mln_conf_destroy_lex(gConf);
if (ret < 0) {
mln_conf_destroy(gConf);
gConf = NULL;
return -1;
}
return 0;
}
