result base_to_config(instance id, xmlnode x, void *arg) { if (id == NULL) { jid j = jid_new(xmlnode_pool(x), xmlnode_get_data(x)); log_debug("base_to_config validating configuration\n"); if (j == NULL) { xmlnode_put_attrib(x, "error", "'to' tag must contain a jid to send log data to"); log_debug("Invalid Configuration for base_to"); return r_ERR; } return r_PASS; } log_debug("base_to configuring instance %s", id->id); if (id->type != p_LOG) { log_alert(NULL, "ERROR in instance %s: <to>..</to> element only allowed in log sections", id->id); return r_ERR; } register_phandler(id, o_DELIVER, base_to_deliver, (void *) xmlnode_get_data(x)); return r_DONE; }
void workloop(void *t) { Loop* me = (Loop*)t; log_info("%s starting.", me->name); LoopData loop; loop.count = 0; loop.period = start_period / n_worker; loop.deadline = abs_start + loop.period*me->id; // entering primary mode rt_task_set_mode(0, T_WARNSW, NULL);/* Ask Xenomai to warn us upon switches to secondary mode. */ RTIME now = rt_timer_read(); while(loop.deadline < now) loop.deadline += loop.period; while(bTesting) { rt_task_sleep_until(loop.deadline);//blocks ///////////////////// if(!bTesting) break; now = rt_timer_read(); loop.jitter = now - loop.deadline;//measure jitter /* Begin "work" ****************************************/ me->work(); //rt_task_sleep(100000000); //for debugging /* End "work" ******************************************/ RTIME t0 = now;//use an easy to remember var now = rt_timer_read(); // Post work book keeping /////////////////////////////// //to report how much the work took loop.t_work = now - t0; if(me->loopdata_q.push(loop)) { } else { /* Have to throw away data; need to alarm! */ log_alert("Loop data full"); } if(!me->late_q.isEmpty()// Manage the late q && me->late_q[0].count < (loop.count - 100)) { me->late_q.pop(); // if sufficiently old, forget about it } loop.deadline += loop.period; if(now > loop.deadline) { // Did I miss the deadline? // How badly did I miss the deadline? // Definition of "badness": just a simple count over the past N loop if(me->late_q.isFull()) { //FATAL log_fatal("Missed too many deadlines"); break; } } /* decrement the period by a fraction */ loop.period -= dec_ppm ? loop.period / (1000000 / dec_ppm) : 0; if(loop.period < 1000000) break; /* Limit at 1 ms for now */ ++loop.count; } rt_task_set_mode(T_WARNSW, 0, NULL);// popping out of primary mode log_info("%s exiting.", me->name); }
/* match will find a child in the parent, and either replace (if it's an insert) or remove (if data is NULL) */ int xdb_act(xdbcache xc, jid owner, char *ns, char *act, char *match, xmlnode data) { xdbrequest_p cur; struct timeval tv; if (xc->shutdown) return 1; if (xc == NULL || owner == NULL || ns == NULL) { log_alert("xdb_set", "Programming Error: xdb_set() called with NULL\n"); return 1; } log_debug("XDB SET"); cur = malloc(sizeof(xdbrequest_t)); memset(cur, 0, sizeof(xdbrequest_t)); cur->set = 1; cur->data = data; cur->ns = ns; cur->owner = owner; cur->act = act; cur->match = match; gettimeofday(&tv, NULL); cur->sent = tv.tv_sec; SEM_LOCK(xc->sem); cur->id = xc->id++; cur->next = xc->first; xc->first = cur; SEM_UNLOCK(xc->sem); /* send it on it's way */ xdb_deliver(xc->i, cur, 0); cur->external = 1; /* if it hasn't already returned, we should block here until it returns */ while (cur->preblock != 1) usleep(10); /* if it didn't actually get set, flag that */ if (cur->data == NULL) { free(cur); return 1; } xmlnode_free(cur->data); free(cur); return 0; }
/* ****************************************************************************** * dcs_read_version -- *//** * * \brief This routine reads the version from the flash file * * \return dove_status * *****************************************************************************/ static void dcs_read_version() { FILE *fp = NULL; int error = -1; do { memset(dsa_version_string, 0, DSA_VERSION_MAX_LENGTH); fp = fopen(DSA_VERSION_FILE, "r"); if(fp == NULL) { log_alert(PythonDataHandlerLogLevel, "Version file not found [%s]", DSA_VERSION_FILE); break; } // read the file and populate the global if(fgets(dsa_version_string, 120, fp) == NULL) { log_alert(PythonDataHandlerLogLevel, "Cannot read ROLE File %s, probably corrupted", DSA_VERSION_FILE); break; } show_print("DSA Version: %s", dsa_version_string); log_notice(PythonDataHandlerLogLevel, "DSA Version: %s", dsa_version_string); error = 0; }while(0); if (fp) { fclose(fp); } if (error) { //Put fake version in sprintf(dsa_version_string, "0.0.0 Thur Jan 1 0:0:0 UDT 1970"); log_emergency(PythonDataHandlerLogLevel, "Generating Fake DSA Version: %s", dsa_version_string); } return; }
void *fast_mtq_thread(void *arg) { fast_mtq f_mtq = (fast_mtq) arg; register fast_mtq_elem e; void *cb_arg; cb_arg = f_mtq->arg; if (f_mtq->start_cb) { cb_arg = (f_mtq->start_cb) (cb_arg); } log_debug("fast mtq thread start"); while (1) { /* check if something to resolv */ SEM_LOCK(f_mtq->sem); e = NULL; if (f_mtq->shutdown != 2) { if ((!(f_mtq->first)) && (!(f_mtq->shutdown))) { COND_WAIT(f_mtq->cond, f_mtq->sem); } /* get element */ e = f_mtq->first; if (e) { f_mtq->first = e->mtq_next; f_mtq->queue--; f_mtq->queue2--; } } SEM_UNLOCK(f_mtq->sem); if (e) { (f_mtq->cb) (cb_arg, (void *) e); } else { if (f_mtq->shutdown) break; } } log_alert("mtq", "fast mtq thread stop %d [%d][%d]", f_mtq->shutdown, f_mtq->queue, f_mtq->queue2); if (f_mtq->stop_cb) { (f_mtq->stop_cb) (cb_arg); } return NULL; }
static void dps_heartbeat_main(void *pDummy) { struct timespec ts; struct timeval tp; int it; int rc; Py_Initialize(); while (TRUE) { pthread_mutex_lock(&dps_heartbeat_mp); it = dps_heartbeat_sample_interval; gettimeofday(&tp, NULL); /* Convert from timeval to timespec */ ts.tv_sec = tp.tv_sec; ts.tv_nsec = tp.tv_usec * 1000; ts.tv_sec += it; rc = pthread_cond_timedwait(&dps_heartbeat_cv, &dps_heartbeat_mp, &ts); if (rc == ETIMEDOUT) { pthread_mutex_unlock(&dps_heartbeat_mp); if(dps_heartbeat_send && controller_location_set)/* Whether to send heartbeat */ { /* Send Heartbeat to DOVE Controller*/ log_info(RESTHandlerLogLevel, "Send Heartbeat to Dove Controller"); //Send the heartbeat is NOT success as the correct repsponse is not received yet //set it in response handler when received a HTTP_OK last_heartbeat_to_dmc_is_success = 0; dps_heartbeat_send_to_dove_controller(); dps_heartbeat_to_dmc_send_count ++; } /* Check if we need registration to DMC again */ if(get_dps_appliance_registration_needed()) { log_info(RESTHandlerLogLevel, "Send DCS appliance registration to DMC!"); dps_appliance_registration(); if (dcs_role_assigned) { log_alert(RESTHandlerLogLevel, "DCS: Sending Query to DMC for list of Nodes"); dps_rest_client_query_dove_controller_cluster_info(); } } continue; } pthread_mutex_unlock(&dps_heartbeat_mp); } Py_Finalize(); return; }
void warn_upon_switch(int sig __attribute__((unused))) { #if BACKTRACE // couldn't compile this for some reason; TODO void *bt[32]; int nentries; /* Dump a backtrace of the frame which caused the switch to secondary mode: */ nentries = backtrace(bt,sizeof(bt) / sizeof(bt[0])); backtrace_symbols_fd(bt,nentries,fileno(stdout)); #else log_alert("Switched to 2ndary mode\n"); #endif }
/** resend packets. heartbeat thread */ result xdb_thump(void *arg) { xdbcache xc = (xdbcache)arg; xdbcache cur, next; int now = time(NULL); pthread_mutex_lock(&(xc->sem)); /* spin through the cache looking for stale requests */ cur = xc->next; while(cur != xc) { next = cur->next; /* really old ones get wacked */ if((now - cur->sent) > 30) { /* remove from ring */ cur->prev->next = cur->next; cur->next->prev = cur->prev; /* make sure it's null as a flag for xdb_set's */ cur->data = NULL; /* free the thread! */ cur->preblock = 1; cur = next; continue; } /* resend the waiting ones every so often */ if((now - cur->sent) > 10) { log_alert(ZONE,"Resend xdb packet"); xdb_deliver(xc->i, cur,1); } /* cur could have been free'd already on it's thread */ cur = next; } pthread_mutex_unlock(&(xc->sem)); return r_DONE; }
/** resend packets. heartbeat thread */ result xdb_thump(void *arg) { xdbcache xc = (xdbcache) arg; xdbrequest_p cur, next, last; struct timeval tv; time_t now; if (xc->shutdown) return r_UNREG; gettimeofday(&tv, NULL); now = tv.tv_sec; SEM_LOCK(xc->sem); /* spin through the cache looking for stale requests */ for (last = NULL, cur = xc->first; cur;) { next = cur->next; if ((cur->external) && ((now - cur->sent) > 30)) { if (!last) xc->first = next; else last->next = next; cur->data = NULL; cur->preblock = 1; } else { last = cur; if ((cur->external) && ((now - cur->sent) > 10)) { log_alert("xdb", "Resend xdb packet"); xdb_deliver(xc->i, cur, 1); } } cur = next; } SEM_UNLOCK(xc->sem); return r_DONE; }
/* ****************************************************************************** * dcs_write_role_to_file -- *//** * * \brief This routine write the role to the file * * \param role * * \return dove_status * *****************************************************************************/ static void dcs_write_role_to_file(int role) { FILE *fp = NULL; char role_string[16]; char path[100] = {'\0'}; sprintf(path, "%s/%s", getenv("HOME"), DCS_ROLE_FILE); if((fp = fopen(path,"w")) == NULL) { log_alert(PythonClusterDataLogLevel, "[ERROR] in opening(write) ROLE file [%s]", path); }else{ sprintf(role_string, "%d", role); fputs(role_string, fp); log_notice(PythonClusterDataLogLevel, "Wrote Role %d to file %s",role, path); fclose(fp); } return; }
/* deliver threads, when offline user or server */ void js_deliver_thread_hander(void *arg, void *value) { jsmi si = (jsmi) arg; packet_thread_p pt = (packet_thread_p) value; /* */ if ((pt->jp) && (pt->p)) { log_debug("Get user Simple packet"); js_outgoing_packet(si, pt->jp, pt->p); return; } if (!pt->p) { log_debug("SImple packet"); js_deliver_local(si, pt->jp); return; } log_alert("fatal", "error - unknown state"); }
result base_file_config(instance id, xmlnode x, void *arg) { basefile bf; if(id == NULL) { log_debug(ZONE,"base_file_config validating configuration"); if (xmlnode_get_data(x) == NULL) { log_debug(ZONE,"base_file_config error: no filename provided."); xmlnode_put_attrib(x,"error","'file' tag must contain a filename to write to"); return r_ERR; } return r_PASS; } log_debug(ZONE,"base_file configuring instance %s",id->id); if(id->type != p_LOG) { log_alert(NULL,"ERROR in instance %s: <file>..</file> element only allowed in log sections", id->id); return r_ERR; } bf = pmalloco(id->p,sizeof(_basefile)); bf->filename = pstrdup(id->p,xmlnode_get_data(x)); bf->yesterday.tm_mday = -1; bf->last_time = 0; bf->f = NULL; pthread_mutex_init(&(bf->sem),NULL); /* Register a handler for this instance... */ register_phandler(id, o_DELIVER, base_file_deliver, (void*)bf); pool_cleanup(id->p, _base_file_shutdown, (void*)bf); return r_DONE; }
/** Shut down transport, kill all sessions */ void it_shutdown(void *arg) { iti ti = (iti) arg; log_alert(ZONE,"JIT Transport, shutting down"); ti->shutdown = 1; /* wait */ usleep(1000); if (ti->sessions_count) { SEM_LOCK(ti->sessions_sem); wpxhash_walk(ti->sessions,it_sessions_end,NULL); SEM_UNLOCK(ti->sessions_sem); } while (ti->sessions_count > 0) usleep(100); wpxhash_free(ti->sessions); ti->sessions = NULL; }
xdbcache xdb_cache(instance id) { xdbcache xc; if (id == NULL) { log_alert("xdb", "Programming Error: xdb_cache() called with NULL\n"); return NULL; } xc = pmalloco(id->p, sizeof(_xdbcache)); xc->i = id; /* flags it as the top of the ring too */ xc->first = NULL; /* init ring */ SEM_INIT(xc->sem); /* register the handler in the instance to filter out xdb results */ register_phandler(id, o_PRECOND, xdb_results, (void *) xc); /* heartbeat to keep a watchful eye on xdb_cache */ register_beat(10, xdb_thump, (void *) xc); register_shutdown_first(xdb_shutdown, (void *) xc); return xc; }
static void dps_heartbeat_send_to_dove_controller() { json_t *js_res = NULL; char dps_heartbeat_uri[MAX_URI_LEN]; sprintf (dps_heartbeat_uri, DPS_DOVE_CONTROLLER_DPS_HEARTBEAT_URI, dps_node_uuid); log_debug(RESTHandlerLogLevel, "Enter"); do { js_res = dps_form_json_heartbeat(); if(js_res == NULL) { log_alert(RESTHandlerLogLevel, "Can not form json for heartbeat"); break; } dps_rest_client_json_send_to_dove_controller(js_res, dps_heartbeat_uri, EVHTTP_REQ_PUT); } while(0); log_debug(RESTHandlerLogLevel, "Exit"); return; }
int main(int argc, char **argv) { liao_log("liao_server", LOG_PID|LOG_NDELAY, LOG_MAIL); if (argc != 3) { usage(argv[0]); exit(0); } if (chdir(LIAO_HOME) == -1) { log_alert("cannot start: unable to switch to home directory"); exit(0); } snprintf(msg_id, sizeof(msg_id), "00000000"); char cfg_file[MAX_LINE] = CFG_FILE; int c; const char *args = "c:h"; while ((c = getopt(argc, argv, args)) != -1) { switch (c) { case 'c': snprintf(cfg_file, sizeof(cfg_file), "%s", optarg); break; case 'h': default: usage(argv[0]); exit(0); } } // 处理配置文件 if (conf_init(cfg_file)) { fprintf(stderr, "Unable to read control files:%s\n", cfg_file); log_error("Unable to read control files:%s", cfg_file); exit(1); } /* // 检查队列目录 if (strlen(config_st.queue_path) <= 0) { fprintf(stderr, "Unable to read queue path.\n"); log_error("Unable to read queue path."); exit(1); } if ( access(config_st.queue_path, F_OK) ) { fprintf(stderr, "Queue path:%s not exists:%s, so create it.\n", config_st.queue_path, strerror(errno)); log_error("Queue path:%s not exists:%s, so create it.", config_st.queue_path, strerror(errno)); umask(0); mkdir(config_st.queue_path, 0777); }*/ online_d = dictionary_new(atoi(config_st.max_works) + 1); child_st = (struct childs *)malloc((atoi(config_st.max_works) + 1) * sizeof(struct childs)); if (!child_st) { log_error("malloc childs [%d] failed:[%d]%s", (atoi(config_st.max_works) + 1), errno, strerror(errno)); exit(1); } int i = 0; for (i=0; i<(atoi(config_st.max_works) + 1); i++) { child_st[i].used = 0; child_st[i].pid = -1; child_st[i].client_fd = -1; child_st[i].pipe_r_in = -1; child_st[i].pipe_r_out = -1; child_st[i].pipe_w_in = -1; child_st[i].pipe_w_out = -1; memset(child_st[i].mid, 0, sizeof(child_st[i].mid)); child_st[i].mfp_out = NULL; } // 开始服务 int connfd, epfd, sockfd, n, nread; struct sockaddr_in local, remote; socklen_t addrlen; // 初始化buffer char buf[BUF_SIZE]; size_t pbuf_len = 0; size_t pbuf_size = BUF_SIZE + 1; char *pbuf = (char *)calloc(1, pbuf_size); if (pbuf == NULL) { log_error("calloc fail: size[%d]", pbuf_size); exit(1); } // 创建listen socket int bind_port = atoi(config_st.bind_port); if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { log_error("socket failed:[%d]:%s", errno, strerror(errno)); exit(1); } if (setnonblocking(listenfd) > 0) { exit(1); } bzero(&local, sizeof(local)); local.sin_family = AF_INET; local.sin_addr.s_addr = htonl(INADDR_ANY); local.sin_port = htons(bind_port); if (bind(listenfd, (struct sockaddr *)&local, sizeof(local)) < 0) { log_error("bind local %d failed:[%d]%s", bind_port, errno, strerror(errno)); exit(1); } log_info("bind local %d succ", bind_port); if (listen(listenfd, atoi(config_st.max_works)) != 0) { log_error("listen fd[%d] max_number[%d] failed:[%d]%s", listenfd, atoi(config_st.max_works), errno, strerror(errno)); exit(1); } // 忽略pipe信号 sig_pipeignore(); // 捕抓子进程退出信号 sig_catch(SIGCHLD, sigchld); // epoll create fd epoll_event_num = atoi(config_st.max_works) + 1; epoll_evts = NULL; epoll_fd = -1; epoll_nfds = -1; int epoll_i = 0; epoll_evts = (struct epoll_event *)malloc(epoll_event_num * sizeof(struct epoll_event)); if (epoll_evts == NULL) { log_error("alloc epoll event failed"); _exit(111); } epoll_fd = epoll_create(epoll_event_num); if (epoll_fd == -1) { log_error("epoll_create max_number[%d] failed:[%d]%s", epoll_event_num, errno, strerror(errno)); exit(1); } struct epoll_event ev; ev.events = EPOLLIN; ev.data.fd = listenfd; if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, ev.data.fd, &ev) == -1) { log_error("epoll_ctl: listen_socket failed:[%d]%s", errno, strerror(errno)); exit(1); } epoll_num_running = 1; for (;;) { epoll_nfds = epoll_wait(epoll_fd, epoll_evts, epoll_event_num, -1); if (epoll_nfds == -1) { if (errno == EINTR) { // 收到中断信号 log_info("epoll_wait recive EINTR signal, continue"); continue; } _exit(111); } log_debug("epoll_num_running:%d nfds:%d", epoll_num_running, epoll_nfds); for (epoll_i = 0; epoll_i < epoll_nfds; epoll_i++) { sig_childblock(); int evt_fd = epoll_evts[epoll_i].data.fd; if (evt_fd == listenfd) { if ((connfd = accept(listenfd, (struct sockaddr *) &remote, &addrlen)) > 0) { char *ipaddr = inet_ntoa(remote.sin_addr); log_info("accept client:%s", ipaddr); char greetting[512] = {0}; char hostname[1024] = {0}; if (gethostname(hostname, sizeof(hostname)) != 0) { snprintf(hostname, sizeof(hostname), "unknown"); } // 取客户端IP,Port char client_ip[20] = {0}; char client_port[20] = {0}; struct sockaddr_in sa; int len = sizeof(sa); if (!getpeername(connfd, (struct sockaddr *)&sa, &len)) { snprintf(client_ip, sizeof(client_ip), "%s", inet_ntoa(sa.sin_addr)); snprintf(client_port, sizeof(client_port), "%d", ntohs(sa.sin_port)); } // 取一个新的client int i = new_idx_from_child_st(); if (i == -1) { log_error("new_idx_from_client_st fail: maybe client queue is full."); // send error snprintf(greetting, sizeof(greetting), "%s ERR %s%s", TAG_GREET, hostname, DATA_END); write(connfd, greetting, strlen(greetting)); log_debug("send fd[%d]:%s", connfd, greetting); continue; } child_st[i].used = 1; int pir[2]; int piw[2]; if (pipe(pir) == -1) { log_error("unable to create pipe:%s", strerror(errno)); // send error snprintf(greetting, sizeof(greetting), "%s ERR %s%s", TAG_GREET, hostname, DATA_END); write(connfd, greetting, strlen(greetting)); log_debug("send fd[%d]:%s", connfd, greetting); continue; } if (pipe(piw) == -1) { log_error("unable to create pipe:%s", strerror(errno)); close(pir[0]); close(pir[1]); pir[0] = -1; pir[1] = -1; // send error snprintf(greetting, sizeof(greetting), "%s ERR %s%s", TAG_GREET, hostname, DATA_END); write(connfd, greetting, strlen(greetting)); log_debug("send fd[%d]:%s", connfd, greetting); continue; } log_debug("create pir[0]:%d pir[1]:%d", pir[0], pir[1]); log_debug("create piw[0]:%d piw[1]:%d", piw[0], piw[1]); // 当程序执行exec函数时本fd将被系统自动关闭,表示不传递给exec创建的新进程 //fcntl(pir[0], F_SETFD, FD_CLOEXEC); //fcntl(piw[1], F_SETFD, FD_CLOEXEC); int f = fork(); if (f < 0) { log_error("fork fail:%s", strerror(errno)); close(pir[0]); close(pir[1]); pir[0] = -1; pir[1] = -1; close(piw[0]); close(piw[1]); piw[0] = -1; piw[1] = -1; child_st[i].used = 0; // send error snprintf(greetting, sizeof(greetting), "%s ERR %s%s", TAG_GREET, hostname, DATA_END); write(connfd, greetting, strlen(greetting)); log_debug("send fd[%d]:%s", connfd, greetting); continue; } struct timeval tm; gettimeofday(&tm, NULL); snprintf(child_st[i].mid, sizeof(child_st[i].mid), "%05u%u", (uint32_t)tm.tv_usec, (uint32_t)f); snprintf(msg_id, sizeof(msg_id), "%s", child_st[i].mid); if (f == 0) { // 子进程 close(pir[0]); close(piw[1]); close(listenfd); char _cmid[512] = {0}; char _cchild_st[512] = {0}; char _ccip[20] = {0}; char _ccport[20] = {0}; snprintf(_cmid, sizeof(_cmid), "-m%s", child_st[i].mid); snprintf(_cchild_st, sizeof(_cchild_st), "-c%s", config_st.child_cf); snprintf(_ccip, sizeof(_ccip), "-i%s", client_ip); snprintf(_ccport, sizeof(_ccport), "-p%s", client_port); char *args[6]; args[0] = "./liao_command"; args[1] = _cmid; args[2] = _cchild_st; args[3] = _ccip; args[4] = _ccport; args[5] = 0; if (fd_move(0, connfd) == -1) { log_info("%s fd_move(0, %d) failed:%d %s", child_st[i].mid, connfd, errno, strerror(errno)); _exit(111); } if (fd_move(1, pir[1]) == -1) { log_info("%s fd_move(pipe_w, %d) failed:%d %s", child_st[i].mid, pir[1], errno, strerror(errno)); _exit(111); } if (fd_move(2, piw[0]) == -1) { log_info("%s fd_move(pipe_r, %d) failed:%d %s", child_st[i].mid, piw[0], errno, strerror(errno)); _exit(111); } if (execvp(*args, args) == -1) { log_error("execp fail:%s", strerror(errno)); _exit(111); } //if (error_temp(errno)) // _exit(111); log_debug("execp succ"); _exit(100); } close(connfd); child_st[i].pipe_r_in = pir[0]; close(pir[1]); pir[1] = -1; child_st[i].pipe_r_out = -1; child_st[i].pipe_w_out = piw[1]; close(piw[0]); piw[0] = -1; child_st[i].pipe_w_in = -1; child_st[i].pid = f; if (setnonblocking(child_st[i].pipe_r_in) != 0) { log_error("setnonblocking fd[%d] failed", child_st[i].pipe_r_in); } struct epoll_event pipe_in_ev; pipe_in_ev.events = EPOLLIN | EPOLLET; pipe_in_ev.data.fd = child_st[i].pipe_r_in; if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, pipe_in_ev.data.fd, &pipe_in_ev) == -1) { log_error("epoll_ctl client fd[%d] EPOLL_CTL_ADD failed:[%d]%s", pipe_in_ev.data.fd, errno, strerror(errno)); } log_debug("epoll_add fd[%d]", pipe_in_ev.data.fd); } else if (connfd == -1) { if (errno != EAGAIN && errno != ECONNABORTED && errno != EPROTO && errno != EINTR) { log_error("accept failed:[%d]%s", errno, strerror(errno)); } continue; } } else if (epoll_evts[epoll_i].events & EPOLLIN) { int ci = get_idx_with_sockfd(evt_fd); if (ci < 0) { log_error("socket fd[%d] get_idx_with_sockfd fail", evt_fd); continue; } log_debug("%s get event EPOLLIN: epoll_i[%d] fd[%d] get d_i[%d] fd[%d], used[%d]", child_st[ci].mid, epoll_i, epoll_evts[epoll_i].data.fd, child_st[ci].pipe_r_in, child_st[ci].used); // 读取内容 ---------------------- char inbuf[BUF_SIZE] = {0}; char *pinbuf = inbuf; int inbuf_size = BUF_SIZE; int inbuf_len = 0; char ch; do { i = 0; nread = read(child_st[ci].pipe_r_in, inbuf, inbuf_size); log_debug("%s read from liao_command:[%d]", child_st[ci].mid, nread); if (nread == -1) { // read error on a readable pipe? be serious //log_error("it is failed from fd[%d] read. error:%d %s", child_st[ci].fd_in, errno, strerror(errno)); //log_debug("it is failed from fd[%d] read. error:%d %s", child_st[ci].pipe_r_in, errno, strerror(errno)); break; } else if (nread > 0) { if (child_st[ci].mfp_out == NULL) { child_st[ci].mfp_out = mopen(MAX_BLOCK_SIZE, NULL, NULL); if (child_st[ci].mfp_out == NULL) { log_debug("%s mopen for body fail", child_st[ci].mid); break; } } while (i < nread) { ch = inbuf[i]; if ((inbuf_size - inbuf_len) < 2) { int r = fast_write(child_st[ci].mfp_out, inbuf, inbuf_len); if (r == 0) { log_error("%s fast_write fail", child_st[ci].mid); break; } memset(inbuf, 0, inbuf_size); inbuf_len = 0; } mybyte_copy(pinbuf + inbuf_len, 1, &ch); inbuf_len++; if (ch == '\n') { if (inbuf_len > 0) { int r = fast_write(child_st[ci].mfp_out, inbuf, inbuf_len); if (r == 0) { log_error("%s fast_write fail", child_st[ci].mid); break; } memset(inbuf, 0, inbuf_size); inbuf_len = 0; } // 处理当前指令 // ... process_system(&child_st[ci]); // ... // 处理完成后 if (child_st[ci].mfp_out != NULL) { mclose(child_st[ci].mfp_out); child_st[ci].mfp_out = NULL; child_st[ci].mfp_out = mopen(MAX_BLOCK_SIZE, NULL, NULL); if (child_st[ci].mfp_out == NULL) { log_error("mopen fail for mfp_out"); break; } } pinbuf = inbuf + 0; } i++; } } else { break; } } while (1); } else if ((epoll_evts[epoll_i].events & EPOLLHUP) && (epoll_evts[epoll_i].data.fd != listenfd)) { int ci = get_idx_with_sockfd(evt_fd); if ( ci < 0 ) { log_error("get_idx_with_sockfd(%d) fail, so not write", evt_fd); continue; } log_debug("%s get event EPOLLHUP: epoll_i[%d] fd[%d] get d_i[%d] fd[%d], used[%d]", child_st[ci].mid, epoll_i, epoll_evts[epoll_i].data.fd, child_st[ci].pipe_r_in, child_st[ci].used); epoll_delete_evt(epoll_fd, child_st[ci].pipe_r_in); continue; } } sig_childunblock(); } close(epoll_fd); close(listenfd); log_info("i'm finish"); return 0; }
/* blocks until namespace is retrieved, host must map back to this service! */ xmlnode xdb_get(xdbcache xc, jid owner, char *ns) { xdbrequest_p cur; xmlnode x; struct timeval tv; if (xc->shutdown) return NULL; if (xc == NULL || owner == NULL || ns == NULL) { if (ns) { log_alert("xdb_get", "Programming Error: xdb_get() called with NULL ns: %s\n", ns); } else { log_alert("xdb_get", "Programming Error: xdb_get() called with NULL ns: NULL\n"); } if (owner) { log_alert("owner", "%s", jid_full(owner)); } return NULL; } log_debug("XDB GET"); /* init this newx */ cur = malloc(sizeof(xdbrequest_t)); memset(cur, 0, sizeof(xdbrequest_t)); // cur->set = 0; // cur->data = NULL; cur->ns = ns; cur->owner = owner; gettimeofday(&tv, NULL); cur->sent = tv.tv_sec; SEM_LOCK(xc->sem); cur->id = xc->id++; cur->next = xc->first; xc->first = cur; SEM_UNLOCK(xc->sem); /* send it on it's way */ xdb_deliver(xc->i, cur, 0); cur->external = 1; /* if it hasn't already returned, we should block here until it returns */ while (cur->preblock != 1) usleep(10); /* newx.data is now the returned xml packet */ /* return the xmlnode inside <xdb>...</xdb> */ for (x = xmlnode_get_firstchild(cur->data); x != NULL && xmlnode_get_type(x) != NTYPE_TAG; x = xmlnode_get_nextsibling(x)); /* there were no children (results) to the xdb request, free the packet */ if (x == NULL) xmlnode_free(cur->data); free(cur); return x; }
/* ****************************************************************************** * dcs_set_service_role -- *//** * * \brief This routine starts or stops the DCS service role * * \param action 1:Activate/Set Local Node, 0:Reset Local Node * * \return dove_status * *****************************************************************************/ dove_status dcs_set_service_role(uint32_t action) { dove_status status = DOVE_STATUS_ERROR; do { if (action) { status = dcs_cluster_node_local_update(&dcs_local_ip); if (status != DOVE_STATUS_OK) { log_alert(RESTHandlerLogLevel, "ALERT! DCS Clustering cannot set local IP"); break; } status = dcs_controller_interface_start(); if (status != DOVE_STATUS_OK) { log_alert(RESTHandlerLogLevel, "ALERT! DCS Controller Interface cannot be started"); break; } status = dcs_protocol_handler_start(); if (status != DOVE_STATUS_OK) { log_alert(RESTHandlerLogLevel, "ALERT! DCS Client Server Protocol cannot be started"); break; } /* do "cluster node add" via sending "query cluster info" */ status = dcs_cluster_node_local_activate(1); if (status != DOVE_STATUS_OK) { log_alert(RESTHandlerLogLevel, "ALERT! DCS Clustering cannot activate Local Node"); break; } //Query the Controller for Cluster Information dcs_role_assigned = 1; } else { status = dcs_cluster_node_local_activate(0); if (status != DOVE_STATUS_OK) { log_alert(RESTHandlerLogLevel, "ALERT! DCS Clustering cannot deactivate Local Node"); break; } status = dcs_protocol_handler_stop(); if (status != DOVE_STATUS_OK) { log_alert(RESTHandlerLogLevel, "ALERT! DCS Client Server Protocol cannot be stopped"); dcs_cluster_node_local_activate(1); break; } status = dcs_controller_interface_stop(); if (status != DOVE_STATUS_OK) { log_alert(RESTHandlerLogLevel, "ALERT! DCS Controller Interface cannot be stopped"); dcs_cluster_node_local_activate(1); dcs_protocol_handler_start(); break; } dcs_role_assigned = 0; cluster_config_version = 0; } dcs_write_role_to_file(dcs_role_assigned); do { if (!controller_location_set) { log_info(RESTHandlerLogLevel, "Controller not set by user"); break; } if (dcs_local_ip.ip4 == htonl(INADDR_LOOPBACK)) { log_info(RESTHandlerLogLevel, "Local IP not yet set. Not point in sending query"); break; } if(get_dps_appliance_registration_needed()) { log_notice(RESTHandlerLogLevel, "DCS: Sending Appliance Registration"); dps_appliance_registration(); } /*if (action) { log_notice(RESTHandlerLogLevel, "DCS: Sending Query to DMC for list of Nodes"); dps_rest_client_query_dove_controller_cluster_info(); }*/ }while(0); }while(0); return status; }
/* ****************************************************************************** * dgadmin_rest_sync_process -- *//** * * \brief This routine starts a new sync circle. * * \retval 0 Success * \retval >0 Failure * *****************************************************************************/ static int dgadmin_rest_sync_process(void) { char *version_query_body_buf = NULL, *target_uri_body_buf = NULL, *ptr = NULL; char target_uri[DGADMIN_URI_LEN]; char new_uri[DGADMIN_URI_LEN]; enum evhttp_cmd_type cmd_type; int version; int operation; int version_create, version_update; bool more = false; int ret = DOVE_STATUS_OK; int is_tombstone=0; int is_uuid=0; int resp_code=0; char deluri[DGADMIN_URI_LEN]; do { do { /* step 1 - send version query request to DMC */ ret = dgadmin_rest_sync_version_query(&version_query_body_buf, &resp_code); if (ret != DOVE_STATUS_OK) { log_alert(ServiceUtilLogLevel, "ERROR\n"); more = false; break; } /* step 2.a - parse and extract version/uri/cmd_type from response */ memset(target_uri, 0, sizeof(target_uri)); ret = dgadmin_rest_sync_version_resp_parser(version_query_body_buf, &version, target_uri, (int *)&operation); if (ret != DOVE_STATUS_OK) { log_alert(ServiceUtilLogLevel, "ERROR\n"); more = false; break; } else { if(strlen(target_uri)==0) { g_dgwconfig_curversion = version; /* NO URI: go to next version */ more = true; break; } } if((operation == DGADMIN_REST_SYNC_OPERATION_GET)|| (operation == DGADMIN_REST_SYNC_OPERATION_DELETE)) { resp_code=0; /* step 2.b - send the GET request for target URI to DMC */ ret = dgadmin_rest_sync_target_uri_get(target_uri, &target_uri_body_buf,&resp_code); if (ret != DOVE_STATUS_OK) { if(resp_code==204) { /* content not found * SKIP this version */ g_dgwconfig_valid_curversion = g_dgwconfig_curversion; g_dgwconfig_curversion = version; more = true; } else { log_alert(ServiceUtilLogLevel, "ERROR %d\n",resp_code); more = false; } break; } memset(deluri,0,sizeof(deluri)); ret = dgadmin_rest_sync_version_get_from_buf(target_uri_body_buf, target_uri, &version_create, &version_update, &is_tombstone, &is_uuid, deluri); if (ret != DOVE_STATUS_OK) { log_alert(ServiceUtilLogLevel, "Fail to get version_create and version_update!"); more = false; break; } if(is_uuid==0) { /* SKIP this version */ g_dgwconfig_valid_curversion = g_dgwconfig_curversion; g_dgwconfig_curversion = version; more = true; break; } if (is_tombstone && (version_create != g_dgwconfig_curversion)) /* tombstoned entry ! still lets run thru create * if we are at create version; * expected change/delete version later*/ { cmd_type = EVHTTP_REQ_DELETE; if(strlen(deluri) == 0) { log_alert(ServiceUtilLogLevel, "ERROR\n"); break; } /* step 3.c - route the DELETE response to dmc agent */ ret = dgadmin_rest_sync_dmc_agent(NULL, cmd_type, deluri); if (ret != DOVE_STATUS_OK) { log_alert(ServiceUtilLogLevel, "ERROR\n"); } } else { strcpy(new_uri, target_uri); /* step 3.b - * build new uri. for example, /api/dove/dgw/xyz/1 => /api/dove/dgw/xyz * */ ptr = new_uri + strlen(target_uri); while (*ptr != '/') { ptr--; } *ptr = '\0'; cmd_type = EVHTTP_REQ_POST; log_alert(ServiceUtilLogLevel, "POST %s", new_uri); log_alert(ServiceUtilLogLevel, "%s\r\n",target_uri_body_buf); /* step 3.c - route the GET response to dmc agent */ ret = dgadmin_rest_sync_dmc_agent(target_uri_body_buf, cmd_type, new_uri); if (ret != DOVE_STATUS_OK) { log_alert(ServiceUtilLogLevel, "ERROR\n"); } } g_dgwconfig_valid_curversion = g_dgwconfig_curversion; g_dgwconfig_curversion = version; log_notice(ServiceUtilLogLevel,"curversion %d valid_curversion %d\r\n", g_dgwconfig_curversion, g_dgwconfig_valid_curversion); more = true; } #if 0 else if(operation == DGADMIN_REST_SYNC_OPERATION_DELETE) { cmd_type = EVHTTP_REQ_DELETE; ret = dgadmin_rest_sync_dmc_agent(NULL, cmd_type, target_uri); if (ret != DOVE_STATUS_OK) { log_alert(ServiceUtilLogLevel, "ERROR\n"); //break; } /* step 4 - update the cluster version if all things success */ g_dgwconfig_curversion = version; more = true; } #endif else { ret = DOVE_STATUS_NOT_SUPPORTED; log_alert(ServiceUtilLogLevel, "ERROR\n"); break; } } while(0); if (version_query_body_buf) { free(version_query_body_buf); version_query_body_buf = NULL; } if (target_uri_body_buf) { free(target_uri_body_buf); target_uri_body_buf = NULL; } /* if (ret != DOVE_STATUS_OK) { more = false; } */ } while (more); return ret; }
int main(int argc, char * const *argv) { uint32_t client_opts, send_level; const char *identity, *facility; // ASL client options client_opts = 0; // What level of messages are sent to syslogd send_level = ASL_LEVEL_NOTICE; // Sender identity. This should be NULL, as asl_open() will set this to the // name of the program. Only set this if you really need to. identity = NULL; // This should be your UTI facility = "se.hunch.asl.example"; // Options accepted by our example program int ch; static struct option longopts[] = { { "debug", no_argument, NULL, 'd' }, { "stderr", no_argument, NULL, 's' }, { "no-remote", no_argument, NULL, 'n' }, { "help", no_argument, NULL, 'h' }, { NULL, 0, NULL, '\0' } }; // Parse options while ((ch = getopt_long(argc, argv, "dsnh", longopts, NULL)) != -1) switch (ch) { case 'd': // Send all messages send_level = ASL_LEVEL_DEBUG; // This disables the remote-control mechanism for adjusting // filter levers for processes using e.g. syslog -c ... client_opts |= ASL_OPT_NO_REMOTE; break; case 's': // Print messages to stderr (adds stderr as an output file descriptor) client_opts |= ASL_OPT_STDERR; break; case 'n': // Send no messages at all. This does only affect what messages are sent // to the server and does not restrict which message are printed to // stderr, if enabled. send_level = -1; break; // Print usage and help default: usage(argv[0]); exit(1); } argc -= optind; argv += optind; // Setting ASL_OPT_NO_DELAY connects to the server immediately when calling asl_open() client_opts |= ASL_OPT_NO_DELAY; // Open connection to ASL (log_asl_client is defined in logging.h) // See /usr/include/asl.h for more details. log_asl_client = asl_open(identity, facility, client_opts); // The log_asl_client variable is used by the log_* and Log_* macros in logging.h // Handle errors from asl_open() if (log_asl_client == NULL) { perror("asl_open"); exit(2); } // Set the level for which messages are sent to the server log_set_send_filter(send_level); // Emit one message for each level log_emerg("This is a emerg-level message -- this message may propagate " "to all TTYs and/or other user interfaces"); log_alert("This is a alert-level message"); log_crit("This is a crit-level message"); log_err("This is a err-level message"); log_warn("This is a warn-level message"); log_notice("This is a notice-level message"); log_info("This is a info-level message"); log_debug("This message is a debug-level message"); // Close connection to syslogd asl_close(log_asl_client); return 0; }
void mtq_send(mtq q, pool p, mtq_callback f, void *arg) { mtqqueue mq; /* one element */ mtq mtq; /* initialization stuff */ if(mtq__master == NULL) { mtq_init(); } if(q != NULL) { mtq = q; } else { /* take next thread */ mtq__master->random++; if (mtq__master->random >= MTQ_THREADS) mtq__master->random = 0; mtq = mtq__master->all[mtq__master->random]->mtq; } /* build queue */ log_debug(ZONE,"mtq_send insert into mtq=%p",mtq); /* lock operation on queue */ SEM_LOCK(mtq->sem); /* find free memory */ mq = mtq->free_last; if (mq == NULL) { while ((mq = malloc(sizeof(_mtqqueue)))==NULL) Sleep(1000); /* it means new malloc maybe we should free this mq later ? */ log_alert(ZONE,"MTQ new queue malloc"); mq->memory = 1; mtq->length++; } else { /* take it out from queue */ mtq->free_last = mtq->free_last->prev; } mq->f = f; mq->arg = arg; mq->prev = NULL; mtq->dl++; /* if queue is empty */ if (mtq->last == NULL) mtq->last = mq; else mtq->first->prev = mq; mtq->first = mq; COND_SIGNAL(mtq->cond); SEM_UNLOCK(mtq->sem); }
/* ****************************************************************************** * dgadmin_rest_sync_version_query -- *//** * * \brief This routine sends version GET request to DMC. * * \param [out] req_body_buf A pointer to request input body buffer. * * \retval 0 Success * \retval >0 Failure * *****************************************************************************/ static int dgadmin_rest_sync_version_query(char **req_body_buf, int *resp) { struct evhttp_request *new_request = NULL; dgadmin_rest_sync_response_args_t args; char uri[DGADMIN_URI_LEN]; char host_header_str[128]; int ret = DOVE_STATUS_OK; if((!g_dmc_ipv4) || (!g_dmc_port) ) { log_alert(ServiceUtilLogLevel, "Unknown: DMC Info!\n"); return 0; } do { struct sockaddr_in sa; char *dmc_httpd_addr = NULL; /* construct a new request */ memset(&args, 0, sizeof(args)); new_request = evhttp_request_new(dgadmin_rest_sync_response_handler, &args); if (new_request == NULL) { ret = DOVE_STATUS_NO_MEMORY; log_notice(ServiceUtilLogLevel,"ERROR"); break; } sa.sin_addr.s_addr = g_dmc_ipv4; dmc_httpd_addr = inet_ntoa(sa.sin_addr); sprintf(host_header_str,"%s:%d", dmc_httpd_addr, g_dmc_port); evhttp_add_header(evhttp_request_get_output_headers(new_request), "Host", host_header_str); /* Set HTTP Authorization Field Basic YWRtaW46YWRtaW4= Base_64 Encoded Value of the String 'Basic admin:admin" */ evhttp_add_header(evhttp_request_get_output_headers(new_request), "Authorization", "Basic YWRtaW46YWRtaW4="); /* send the GET request to DMC */ memset(uri, 0, sizeof(uri)); sprintf(uri, "%s/%d", DGADMIN_REST_SYNC_VERSION_URI, g_dgwconfig_curversion); log_notice(ServiceUtilLogLevel, "Sending %s GET REQ to DMC[%s:%d]", uri, dmc_httpd_addr, g_dmc_port); ret = dove_rest_request_and_syncprocess(dmc_httpd_addr, g_dmc_port, EVHTTP_REQ_GET, uri, new_request, NULL, DGADMIN_REST_SYNC_CONNECT_TIMEOUT); *req_body_buf = args.req_body_buf; if (ret) { log_alert(ServiceUtilLogLevel, "ERROR:REST syncprocess\n"); ret = DOVE_STATUS_ERROR; break; } *resp = args.res_code; if ((args.res_code != HTTP_OK) && (args.res_code != 201)) { log_alert(ServiceUtilLogLevel, "ERROR:REST DMC changeversion respose %d\n",args.res_code); ret = DOVE_STATUS_ERROR; break; } } while (0); return ret; }
/** Start up transport. Read configuration, register callbacks. */ void icqtrans(instance i, xmlnode x) { iti ti; pool p = i->p; xmlnode config; xmlnode cur; int check; log_debug(ZONE,"ICQ Transport, initializing for section '%s'",i->id); /* create new transport instance */ ti = pmalloco(p,sizeof(_iti)); ti->i = i; ti->xc = xdb_cache(i); config = xdb_get(ti->xc,jid_new(xmlnode_pool(x),"config@-internal"),"jabber:config:icqtrans"); if (config == NULL) { log_error(i->id,"Configuration not found!"); return; } ti->registration_instructions = pstrdup(p,xmlnode_get_tag_data(config,"instructions")); if (ti->registration_instructions == NULL) { log_debug(i->id,"Registration instructions not found"); } ti->search_instructions = pstrdup(p,xmlnode_get_tag_data(config,"search")); if (ti->search_instructions == NULL) { log_debug(i->id,"Search instructions not found"); } ti->charset = pstrdup(p,xmlnode_get_tag_data(config,"charset")); if (ti->charset == NULL) { log_debug(i->id,"Charset not specified, set default to %s ",DEFAULT_CHARSET); ti->charset = pstrdup(p,DEFAULT_CHARSET); } _ucs2utf = iconv_open("UTF-8","UCS-2BE"); _win2utf = iconv_open("UTF-8",ti->charset); if (_win2utf==(iconv_t)-1) { ti->charset = pstrdup(p,DEFAULT_CHARSET); _win2utf = iconv_open("UTF-8",ti->charset); if (_win2utf==(iconv_t)-1) { log_error(i->id,"Charset error!"); return; } } _utf2win = iconv_open(ti->charset,"UTF-8"); if (_utf2win ==(iconv_t)-1) { ti->charset = pstrdup(p,DEFAULT_CHARSET); _utf2win = iconv_open(ti->charset,"UTF-8"); if (_utf2win ==(iconv_t)-1) { log_error(i->id,"Charset error!"); return; } } log_notice("config","charset %s",ti->charset); ti->msg_chat = xmlnode_get_tag(config,"chat") ? 1 : 0; if (ti->msg_chat) { log_notice("config","chat messages enabled"); } ti->web_aware = xmlnode_get_tag(config,"web") ? 1 : 0; if (ti->web_aware) { log_notice("config","web presence enabled"); } ti->own_roster = xmlnode_get_tag(config,"own_roster") ? 1 : 0; if (ti->own_roster) { log_notice("config","JIT will use own roster"); } ti->no_jabber_roster = xmlnode_get_tag(config,"no_jabber_roster") ? 1 : 0; if (ti->no_jabber_roster) { log_notice("config","JIT willn't get users from jabber roster"); } ti->no_x_data = xmlnode_get_tag(config,"no_xdata") ? 1 : 0; if (ti->no_x_data) { log_notice("config","JIT will not use xdata"); } cur = xmlnode_get_tag(config,"sms"); if (cur) { ti->sms_id = pstrdup(p,xmlnode_get_tag_data(cur,"host")); if (ti->sms_id) { ti->sms_show = jit_show2status(xmlnode_get_tag_data(cur,"show")); if (ti->sms_show==ICQ_STATUS_NOT_IN_LIST) { ti->sms_show = ICQ_STATUS_ONLINE; } log_notice("config","sms host %s show: %d",ti->sms_id,ti->sms_show); ti->sms_status = pstrdup(p,xmlnode_get_tag_data(cur,"status")); if (ti->sms_status) { log_debug(ZONE,"sms st %s ",ti->sms_status); } ti->sms_name = pstrdup(p,xmlnode_get_tag_data(cur,"name")); if (ti->sms_name) { log_debug(ZONE,"sms name %s",ti->sms_name); } } } ti->count_file = pstrdup(p,xmlnode_get_tag_data(config,"user_count_file")); if (ti->count_file == NULL) { ti->count_file = "icqcount"; } log_notice("config","Using %s as count log file",ti->count_file); for (cur = xmlnode_get_firstchild(xmlnode_get_tag(config,"server")); cur != NULL; cur = xmlnode_get_nextsibling(cur)) { char * port; char * host; if (xmlnode_get_type(cur) != NTYPE_TAG) continue; if ((port = xmlnode_get_attrib(cur,"port")) == NULL) continue; if ((host = xmlnode_get_data(cur)) == NULL) continue; ti->auth_hosts[ti->auth_hosts_count] = pstrdup(p,host); ti->auth_ports[ti->auth_hosts_count] = j_atoi(port,5190); log_debug(ZONE,"Host %s port %d at pos %d", ti->auth_hosts[ti->auth_hosts_count], ti->auth_ports[ti->auth_hosts_count], ti->auth_hosts_count); ti->auth_hosts_count++; if (ti->auth_hosts_count >= MAX_AUTH_HOSTS) break; } if (ti->auth_hosts_count == 0) { log_alert("err","No hosts to auth icq client !. Using default"); ti->auth_hosts[ti->auth_hosts_count] = pstrdup(p,"205.188.179.233"); ti->auth_ports[ti->auth_hosts_count] = 5190; ti->auth_hosts_count++; } /* add queue for unknown packets */ ti->q = mtq_new(i->p); ti->sessions = wpxhash_new(j_atoi(xmlnode_get_tag_data(config,"prime"),509)); ti->sessions_alt = wpxhash_new(j_atoi(xmlnode_get_tag_data(config,"prime"),509)); SEM_INIT(ti->sessions_sem); ti->vcard = xmlnode_new_tag_pool(p,"vCard"); xmlnode_put_attrib(ti->vcard,"xmlns",NS_VCARD); xmlnode_insert_node(ti->vcard,xmlnode_get_firstchild(xmlnode_get_tag(config,"vCard"))); /* default 5 hours */ ti->session_timeout = j_atoi(xmlnode_get_tag_data(config,"session_timeout"),18000); log_notice("config","session_timeout in sec : %d",ti->session_timeout); ti->reconnect = j_atoi(xmlnode_get_tag_data(config,"reconnects"),0); log_notice("config","Number of reconnects for session %d",ti->reconnect); check = j_atoi(xmlnode_get_tag_data(config,"session_check"),10); log_notice("config","JIT will check session every %d sec",check); // ti->admin = xmlnode_dup(xmlnode_get_tag(config,"admin")); ti->start = time(NULL); /* Register callbacks */ register_phandler(i,o_DELIVER,it_receive,(void *) ti); register_shutdown(it_shutdown,(void *) ti); /* Start up heartbeat thread */ register_beat(check,it_sessions_check,(void *) ti); xmlnode_free(config); }
/** Callback processing incoming Jabber packets. */ result it_receive(instance i, dpacket d, void *arg) { iti ti = (iti) arg; jpacket jp; session s; session_ref alt_s; unsigned char *user; log_debug(ti->i->id,"Packet received: %s\n",xmlnode2str(d->x)); switch(d->type) { case p_ROUTE: { /* ignore */ return r_PASS; } case p_NONE: case p_NORM: jp = jpacket_new(d->x); break; default: return r_ERR; } if (!jp->from ||/* !jp->from->user ||*/ jp->type == JPACKET_UNKNOWN /* || jpacket_subtype(jp) == JPACKET__ERROR */) { /* ignore invalid packets */ xmlnode_free(jp->x); return r_DONE; } /* JID user part should be case insensitive */ /* convert user part of from JID to lower case */ if(jp->from->user != NULL) for(user = jp->from->user; *user != '\0'; user++) if(*user < 128) *user = tolower(*user); /* Mangle "from" JID, save original attribute for XDB conversion */ xmlnode_put_attrib(jp->x, "origfrom", xmlnode_get_attrib(jp->x, "from")); xmlnode_put_attrib(jp->x, "from", jid_full(jp->from)); SEM_LOCK(ti->sessions_sem); s = (session) wpxhash_get(ti->sessions,jid_full(jid_user(jp->from))); alt_s = (session_ref) wpxhash_get(ti->sessions_alt,jp->to->user); if (s != NULL) { if (s->exit_flag) { SEM_UNLOCK(ti->sessions_sem); log_alert("exit flag","message to exiting session"); if (jp->type != JPACKET_PRESENCE){ jutil_error(jp->x,TERROR_NOTFOUND); it_deliver(ti,jp->x); } else xmlnode_free(jp->x); } else if ((alt_s != NULL) && ( (jp->type == JPACKET_MESSAGE) // all messages || ((jp->type == JPACKET_IQ) && (j_strcmp(xmlnode_get_attrib(jp->iq,"xmlns"),NS_VCARD) == -1)) // all IQs except of vCard || (jp->type == JPACKET_PRESENCE) )) { // all presences _targeted_to_specific_user_ // rewriting "to" and "from" and putting packet back on the wire xmlnode_put_attrib(jp->x, "from", jid_full(it_uin2jid(jp->p,s->uin,jp->to->server))); xmlnode_put_attrib(jp->x, "to", jid_full(alt_s->s->orgid)); SEM_UNLOCK(ti->sessions_sem); it_deliver(ti,jp->x); } else { jp->aux1 = (void *) s; mtq_send(s->q,jp->p,it_session_jpacket,(void *) jp); SEM_UNLOCK(ti->sessions_sem); } } else { SEM_UNLOCK(ti->sessions_sem); if(jpacket_subtype(jp)!=JPACKET__ERROR) it_unknown(ti,jp); else xmlnode_free(jp->x); } return r_DONE; }
/* ****************************************************************************** * dps_rest_client_fill_evhttp -- *//** * * \brief This routine crate the HTTP Request from the JSON Body * * \param req: The EVHTTP_REQUEST * \param js_res: The JSON Body of the Request * \param remote_ip_string: The DPS IP Address to send the request to. * * \return PyObject * *****************************************************************************/ static void dps_rest_client_fill_evhttp(struct evhttp_request *req, json_t *js_res, char *remote_ip_string) { char *res_body_str = NULL; struct evbuffer *retbuf = NULL; char host_header_str[64]; log_debug(RESTHandlerLogLevel, "Enter"); memset(host_header_str, 0, 64); do { if(js_res != NULL) { //add to the http request output buffer for sending res_body_str = json_dumps(js_res, JSON_PRESERVE_ORDER); if (NULL == res_body_str) { log_alert(RESTHandlerLogLevel, "JSON string is NULL or Bad"); break; } retbuf = evbuffer_new(); if (NULL == retbuf) { log_error(RESTHandlerLogLevel, "retbuf = evbuffer_new() ERROR"); break; } //add to the http request output buffer for sending log_debug(RESTHandlerLogLevel, "strlen(res_body_str) = %d, content is %s", strlen((const char *)res_body_str), res_body_str); evbuffer_add(retbuf, res_body_str, strlen((const char *)res_body_str) + 1); evbuffer_add_buffer(evhttp_request_get_output_buffer(req), retbuf); } /* No need to add "content-length, * as evhttp will add it for POST and PUT, and * GET should not have it */ log_debug(RESTHandlerLogLevel, "Remote DPS Node IP ==>> [%s : REST Port %d]", remote_ip_string, DPS_REST_HTTPD_PORT); if (DPS_REST_HTTPD_PORT != HTTPD_DEFAULT_PORT) { sprintf(host_header_str,"%s:%d", remote_ip_string, DPS_REST_HTTPD_PORT); } else { sprintf(host_header_str,"%s",remote_ip_string); } log_debug(RESTHandlerLogLevel, "host_header_str %s", host_header_str); if(evhttp_find_header(req->output_headers, "Host") == NULL) { evhttp_add_header(evhttp_request_get_output_headers(req), "Host", host_header_str); } if(evhttp_find_header(req->output_headers, "Content-Type") == NULL) { evhttp_add_header(evhttp_request_get_output_headers(req), "Content-Type", "application/json"); } } while(0); if (res_body_str) { free(res_body_str); } log_debug(RESTHandlerLogLevel, "Exit"); return; }