void worker_loop(int channel_fd)
{
int epoll_fd = epoll_init();
if(channel_fd < 0 || epoll_fd < 0)
exit(1);
if(epoll_add_event(epoll_fd, EPOLLIN, channel_fd) == L_HTTP_FAIL) {
printf("add channel_fd fail\n");
return;
}
while (1) {
if(worker_epoll_start(epoll_fd, MAX_CONNECTION, channel_fd) < 0) {
if(errno == EINTR)
continue;
break;
}
on_timer(epoll_fd);
}
close(channel_fd);
close(epoll_fd);
}
void master_loop()
{
int listenfd = tcp_listen();
int epoll_fd = epoll_init();
if(listenfd < 0 || epoll_fd < 0)
exit(1);
if(epoll_add_event(epoll_fd, EPOLLIN, listenfd) == L_HTTP_FAIL) {
printf("add listenfd fail\n");
return;
}
while (1) {
if(master_epoll_start(epoll_fd, MAX_CONNECTION, listenfd) < 0) {
if(errno == EINTR)
continue;
break;
}
//on_timer(epoll_fd);
}
close(listenfd);
close(epoll_fd);
}
static int start_web_server(http_conf *g)
{
int count ;
int epfd;
int fd = 0;
epoll_extra_data_t *data;
data = (epoll_extra_data_t *) malloc(sizeof(epoll_extra_data_t));
data->type = SERVERFD;
if(g->port <=0) g->port = 80;
epfd = epoll_init(MAX_CONNECT);
//while(count--){
fd = socket_listen("127.0.0.1", g->port);
// web->fd = fd;
epoll_add_fd(epfd, fd,EPOLL_R, data);
// web = web->next;
//}
g->fd = fd;
g->epfd = epfd;
return epfd;
}
int main(int argc, char* argv[])
{
if (argc != 2) {
fprintf(stderr,
"Usage: %s <config_file>\n",
argv[0]);
exit(1);
}
lua_State *L = lua_open();
if (luaL_dofile(L, argv[1]) != 0) {
fprintf(stderr, "Error parsing config file: %s\n", lua_tostring(L, -1));
exit(1);
}
char* server_port_str = get_config_opt(L, "listenPort");
char* backend_addr = get_config_opt(L, "backendAddress");
char* backend_port_str = get_config_opt(L, "backendPort");
signal(SIGPIPE, SIG_IGN);
epoll_init();
create_server_socket_handler(server_port_str,
backend_addr,
backend_port_str);
rsp_log("Started. Listening on port %s.", server_port_str);
epoll_do_reactor_loop();
return 0;
}
//initialize a base
base_t *
lt_base_init(void)
{
// res_t res;
//alloc a memory for a new base
base_t *base = malloc(sizeof(base_t));
if (!base) {
// err_realloc(base);//TODO
return NULL;
}
//epoll create a epfd , then copy it to base
// epoll_init
int epfd = epoll_init();
if (epfd == -1) {
free(base);
return NULL;
}
base->epfd = epfd;
base->readylist.eventarray = malloc(sizeof(event_t) * EVLIST_LEN);//event_t lt_alloc TODO:optimization
if (base->readylist.eventarray == NULL) {
perror("malloc ready eventarray");
return NULL;
}
base->readylist.event_len = 0;
base->activelist.eventarray = malloc(sizeof(event_t *) * EVLIST_LEN);
if (base->activelist.eventarray == NULL) {
perror("malloc active eventarray");
free(base->readylist.eventarray);
return NULL;
}
base->activelist.event_len = 0;
base->deletedlist.eventarray = malloc(sizeof(event_t *) * EVLIST_LEN);
if (base->deletedlist.eventarray == NULL) {
perror("malloc deleted eventarray");
free(base->readylist.eventarray);
free(base->deletedlist.eventarray);
return NULL;
}
//malloc(realloc(evlist->eventarray,//TODO realloc is wrong
// (sizeof(event_t)) * (evlist->event_len>>2));
//init base set // lt_base_init_set(base);
min_heap_constructor_(&base->timeheap);
//init epoll_event
//Fxxk you, libevent;
// base->epevent = malloc(INIT_EPEV*sizeof(struct epoll_event));
// if (!base->epevent) {
// fprintf(stderr, "malloc\n");
// return NULL;
// }
return base;
}
void do_epoll(int fd_server)
{
epoll_t my_epoll;
epoll_init(&my_epoll, fd_server, handler);
while(1){
epoll_wait_signal(&my_epoll);
epoll_handle(&my_epoll);
}
epoll_close(&my_epoll);
}
void do_epoll(int listenfd)
{
epoll_t pol;
epoll_init(&pol, listenfd, handle);
while(1)
{
epoll_do_wait(&pol);
epoll_handle(&pol);
}
epoll_close(&pol);
}
int start_cgi_server(http_conf *g, execute_cgi_info_manager_t * cgi_info_manager) {
epoll_extra_data_t *data ;
int epfd;
data = (epoll_extra_data_t *) palloc(cgi_info_manager->p, sizeof(epoll_extra_data_t));
data->type = CGISERVERFD;
make_fd_non_blocking(g->child_pip.in);
g->fd = g->child_pip.in;
g->epfd = epoll_init(MAX_CONNECT);
epoll_add_fd(g->epfd, g->fd, EPOLL_R, data);
return 0;
}
int main()
{
int listenfd = TcpServer("127.0.0.1", 8976);
epoll_t et;
epoll_init(&et, listenfd, &run);
while(1)
{
epoll_loop(&et);
epoll_handle_fd(&et);
}
//epoll_destroy(&et);
close(et.epoll_fd_);
close(listenfd);
}
int main(void)
{
//
std::string filepath = "/home/chao/Desktop/project/spellcorrect/conf/my.conf";
MyConf myconf(filepath);
myconf.init();
myconf.show();
std::map<std::string, std::string> my_map = myconf.get_map();
std::string sip = my_map["server_ip"];
std::string sport = my_map["server_port"];
std::stringstream ss(sport);
int iport = 0;
ss >> iport;
std::cout << iport << std::endl;
ThreadPool thp(50, 10);
thp.start();
InetAddress inetAddr(sip, iport);
Socket mySocket;
mySocket.init(0, inetAddr);
int listenfd = mySocket.get_sockfd();
epoll_t et;
epoll_init(&et, listenfd, &foo );
while(1)
{
epoll_loop(&et);
epoll_handle_fd(&et, thp);
}
epoll_destroy(&et);
return 0;
}
static int socket_epoll_init(char *sock_path, struct msg_info *msg_info)
{
int listen_sock;
int efd;
listen_sock = create_socket(sock_path);
if (listen_sock < 0) {
return -1;
}
efd = epoll_init(listen_sock);
if (efd < 0)
{
close(listen_sock);
return -1;
}
msg_info->efd = efd;
msg_info->listen_fd = listen_sock;
return 0;
}
int main(int argc, char *argv[]) {
_bcc_status bcc;
void *buf;
bool client = false;
int count_read;
int count_written;
int count_xferred;
bool e_ldone;
bool e_pwu;
int err;
int ferr;
short filenumr;
short filenums;
int inx;
int loop = 10;
char *p;
char recv_buffer[BUFSIZ];
char send_buffer[BUFSIZ];
int socka;
int sockc;
int sockl;
SB_Tag_Type tag;
short tfilenum;
int timeout = -1;
short wakeup;
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "-v", TA_Bool, TA_NOMAX, &verbose },
{ "", TA_End, TA_NOMAX, NULL }
};
ferr = file_init(&argc, &argv);
TEST_CHK_FEOK(ferr);
msfs_util_init_fs(&argc, &argv, file_debug_hook);
arg_proc_args(zargs, false, argc, argv);
util_test_start(client);
ferr = file_mon_process_startup(!client); // system messages
TEST_CHK_FEOK(ferr);
if (client) {
ferr = BFILE_OPEN_((char *) "$srv", (short) 4, &filenums,
0, 0, 1,
0, 0, 0, 0, NULL);
TEST_CHK_FEOK(ferr);
for (inx = 0; inx < loop; inx++) {
sprintf(send_buffer, "inx=%d", inx);
bcc = BWRITEREADX(filenums,
send_buffer,
(short) (strlen(send_buffer) + 1),
BUFSIZ,
&count_read,
1);
TEST_CHK_BCCEQ(bcc);
tfilenum = -1;
bcc = BAWAITIOX(&tfilenum,
&buf,
&count_xferred,
&tag,
timeout,
NULL);
TEST_CHK_BCCEQ(bcc);
}
p = strchr(send_buffer, ':');
*p = 0;
p++;
strcpy(host, send_buffer);
port = (unsigned short) atoi(p);
if (verbose)
printf("server returned host=%s, port=%d\n",
host, port);
if (verbose)
printf("client connecting up\n");
// connect up, and setup fds
epoll_init();
sockc = do_sock_connect();
pin_main = 1;
proc_register_group_pin(-1, pin_main);
epoll_add(sockc);
do_thread_create();
bcc = BWRITEREADX(filenums,
NULL,
0,
BUFSIZ,
&count_read,
1);
TEST_CHK_BCCEQ(bcc);
usleep(10000);
e_pwu = false;
e_ldone = false;
for (;;) {
wakeup = XWAIT(LDONE | PWU, -1);
if (wakeup & PWU) {
e_pwu = true;
do_io_comp();
}
if (wakeup & LDONE) {
e_ldone = true;
timeout = -1;
tfilenum = -1;
bcc = BAWAITIOX(&tfilenum,
&buf,
&count_xferred,
&tag,
timeout,
NULL);
TEST_CHK_BCCEQ(bcc);
}
if (e_ldone && e_pwu)
break;
}
do_thread_join();
if (verbose)
printf("client closing\n");
ferr = BFILE_CLOSE_(filenums, 0);
TEST_CHK_FEOK(ferr);
printf("if there were no asserts, all is well\n");
} else {
sockl = do_sock_listen();
assert(sockl != -1);
ferr = BFILE_OPEN_((char *) "$RECEIVE", 8, &filenumr,
0, 0, 1,
1, 1, // no sys msg
0, 0, NULL);
TEST_CHK_FEOK(ferr);
for (inx = 0; inx < loop; inx++) {
bcc = BREADUPDATEX(filenumr,
recv_buffer,
BUFSIZ,
&count_read,
1);
TEST_CHK_BCCEQ(bcc);
tfilenum = filenumr;
bcc = BAWAITIOX(&tfilenum,
&buf,
&count_xferred,
&tag,
timeout,
NULL);
TEST_CHK_BCCEQ(bcc);
assert(tag == 1);
sprintf(recv_buffer, "%s:%d\n", host, port);
count_read = (short) (strlen(recv_buffer) + 1);
bcc = BREPLYX(recv_buffer,
count_read,
&count_written,
0,
XZFIL_ERR_OK);
TEST_CHK_BCCEQ(bcc);
}
if (verbose)
printf("server accepting\n");
socka = do_sock_accept(sockl);
err = (int) write(socka, recv_buffer, 1);
assert(err != -1);
for (inx = 0; inx < 1; inx++) {
bcc = BREADUPDATEX(filenumr,
recv_buffer,
BUFSIZ,
&count_read,
1);
TEST_CHK_BCCEQ(bcc);
tfilenum = filenumr;
bcc = BAWAITIOX(&tfilenum,
&buf,
&count_xferred,
&tag,
timeout,
NULL);
TEST_CHK_BCCEQ(bcc);
bcc = BREPLYX(recv_buffer,
0,
&count_written,
0,
XZFIL_ERR_OK);
TEST_CHK_BCCEQ(bcc);
}
if (verbose)
printf("server closing\n");
ferr = BFILE_CLOSE_(filenumr, 0);
TEST_CHK_FEOK(ferr);
}
ferr = file_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
int main(int argc, char **argv)
{
/*
char * ptr = lyxml_data_join(1, "11.11.1.1", 22335, NULL, 0);
printf(ptr);printf("\n%ld\n", strlen(ptr));
free(ptr);
NodeInfo ni = { 222222, 111111, 8, 2000, 1, 1450, 1, 1, 1, 1, 1,
"i686", "localhost", THIS_IP };
ptr = lyxml_data_node_register(&ni, NULL, 0);
printf(ptr);printf("\n%ld\n", strlen(ptr));
free(ptr);
NodeCtrlInstance ii = { 1, LA_DOMAIN_RUN, 2, 1, "wiki-ly", 1, 1024, "aa:bb:cc:dd:ee:ff",
"", 3, "wiki", "http://localhost:8080/root.tgz",
"", THIS_IP, 1450};
ptr = lyxml_data_instance_run(&ii, NULL, 0);
printf(ptr);printf("\n%ld\n", strlen(ptr));
free(ptr);
ii.req_action = LA_DOMAIN_STOP;
ptr = lyxml_data_instance_stop(&ii, NULL, 0);
printf(ptr);printf("\n%ld\n", strlen(ptr));
free(ptr);
ptr = lyxml_data_instance_register(3, "corei5", THIS_IP, NULL, 0);
printf(ptr);printf("\n%ld\n", strlen(ptr));
free(ptr);
LYReply r = { LUOYUN_ENTITY_NODE, LUOYUN_ENTITY_CLC, 4,
LUOYUN_REPLY_STATUS_DONE, 0, "sucess" };
ptr = lyxml_data_reply(&r, NULL, 0);
printf(ptr);printf("\n%ld\n", strlen(ptr));
free(ptr);
return 0;
*/
int ret = 0;
if (epoll_init(MAX_EVENTS) != 0) {
printf("epoll_init failed\n");
return -1;
}
if (epoll_work_start(1369) != 0) {
ret = -1;
printf("epoll_start_server failed\n");
goto out;
}
/* start main event driven loop */
int i, n;
struct epoll_event events[MAX_EVENTS];
while (ret != -1) {
if (g_state == 0) {
if (mcast_send_join(1369) != 0) {
printf("mcast_send_join error\n");
break;
}
g_state = 1;
}
else if (g_state == 2) {
/* sleep for a while to allow lynode work socket starts */
printf("sleep 2 seconds before start test domain\n");
sleep(2);
if (start_test_domain() != 0) {
printf("start_test_domain error\n");
break;
}
/*
printf("sleep 2 seconds before stop test domain\n");
sleep(2);
if (stop_test_domain() != 0) {
printf("stop_test_domain error\n");
break;
}
*/
g_state = 3;
}
else if (g_state == 4) {
printf("sleep 2 seconds before stop test domain\n");
sleep(2);
if (stop_test_domain() != 0) {
printf("stop_test_domain error\n");
break;
}
g_state = 5;
}
else if (g_state == 6) {
printf("sleep 3 seconds before destroy test domain\n");
sleep(3);
if (destroy_test_domain() != 0) {
printf("destroy_test_domain error\n");
break;
}
g_state = 7;
}
else if (g_state == 8) {
printf("test passed\n");
break;
}
n = epoll_wait(g_efd, events, MAX_EVENTS, 5000);
for (i = 0; i < n; i++) {
if (events[i].events & EPOLLIN && events[i].data.fd == g_wfd) {
printf("g_wfd has data in.\n");
if (epoll_work_recv() != 0) {
printf("epoll_work_recv error\n");
ret = -1;
break;
}
}
else if (events[i].events & EPOLLIN && events[i].data.fd == g_nfd) {
printf("g_nfd has data in.\n");
if (epoll_node_recv() != 0) {
printf("epoll_node_recv error\n");
ret = -1;
break;
}
}
else if (events[i].events & EPOLLRDHUP &&
events[i].data.fd == g_wfd) {
printf("g_wfd got hup. ???\n");
ret = -1;
break;
}
else if (events[i].events & EPOLLRDHUP &&
events[i].data.fd == g_nfd) {
printf("g_nfd got hup. \n");
ret = -1;
break;
}
else {
printf("unexpected event(%d, %d). quit\n",
events[i].events, events[i].data.fd);
ret = -1;
break;
}
}
}
out:
if (g_efd != -1)
close(g_efd);
if (g_wfd != -1)
close(g_wfd);
if (g_nfd != -1) {
close(g_nfd);
ly_packet_cleanup(&g_nfd_pkt);
}
return 0;
}
int main (int argc, char **argv)
{
int port = 0;
const int poolSize = EPOLL_SIZE;
const int epollSize= EVENT_SIZE;
struct epoll_event *events;
struct epoll_event ev;
int efd=0, sfd=0, cfd=0;
int rst=0;
int rvEvents=0;
int i=0;
printf ("WEB SERVER v1.0 - build date: %s\n", __DATE__);
if (argc > 1){
port = atoi (argv[1]);
}
else {
printf ("usage: $webserver port\n");
return 0;
}
signal (SIGPIPE, SIG_IGN);
efd = epoll_init (epollSize);
if (efd < 0) {
perror (" init_epoll error");
return 0;
}
events = (struct epoll_event *) malloc(sizeof(*events) * poolSize);
if (NULL == events) {
perror (" epoll_event malloc error");
close(efd);
return 0;
}
sfd = initAcceptSock (port);
if (sfd < 0) {
perror (" init_acceptsock error");
close(efd);
close(sfd);
free(events);
return 0;
}
rst = epoll_in_add (efd, sfd);
if (rst < 0) {
perror ("epollf_in_add error");
close(efd);
close(sfd);
free(events);
return 0;
}
while (1)
{
rvEvents = epoll_wait (efd, events, poolSize, -1);
for (i = 0; i < rvEvents; i++)
{
if (events[i].data.fd == sfd) {
cfd = doAccept (efd, sfd);
}
else {
doEcho (efd, events[i].data.fd);
}
}
}
}
int main (void)
{
int err;
struct sockaddr addr;
socklen_t alen = sizeof(addr);
int lsocket, s, count;
char buf[C_CMD_BUF_SIZE];
MNLD_DATA_T *obj = &mnld_data;
lsocket = android_get_control_socket(SOCKET_MNL);
if (lsocket < 0) {
MND_ERR("fail to get socket from environment: %s\n",strerror(errno));
exit(1);
}
if (listen(lsocket, 5)) {
MND_ERR("listen on socket failed: %s\n", strerror(errno));
exit(1);
}
if (setup_signal_handler()) {
MND_ERR("setup_signal_handler: %d (%s)\n", errno, strerror(errno));
exit(1);
}
if (mnl_init()) {
MND_ERR("mnl_init: %d (%s)\n", errno, strerror(errno));
exit(1);
}
MND_MSG("listening..\n");
while(1) {
int eof, s = accept(lsocket, &addr, &alen);
if (s < 0) {
MND_ERR("Accept failed!! :%s\n", strerror(errno));
continue;
}
obj->cur_accept_socket = s;
fcntl(s, F_SETFD, FD_CLOEXEC);
if (epoll_init()) {
MND_ERR("epoll_init: %d (%s)\n", errno, strerror(errno));
exit(1);
}
MND_MSG("new connection\n");
for (;;) {
err = process();
if (err == ERR_REMOTE_HANGUP) {
MND_ERR("remote hangup (cleanup?), wait for new connection\n");
break;
} else if (err == ERR_MNL_DIED) {
MND_ERR("mnl process died, kill it\n");
kill_mnl_process();
} else if (errno == EINTR) {
continue;
} else if (err) {
MND_ERR("process data error: %d (%s)\n", errno, strerror(errno));
}
}
MND_MSG("closing connection\n");
close(s);
epoll_destroy();
}
MND_MSG("exit mnld \n!!");
return 0;
}
int main(int argc, char **argv)
{
int ret = 0;
g_ac.secret = malloc(40);
strcpy(g_ac.secret, "aabbccdd");
g_ac.challenge = malloc(40);
strcpy(g_ac.challenge, "1234567890987654321");
if (epoll_init(MAX_EVENTS) != 0) {
printf("epoll_init failed\n");
return -1;
}
if (epoll_work_start(1369) != 0) {
ret = -1;
printf("epoll_start_server failed\n");
goto out;
}
/* start main event driven loop */
int i, n;
struct epoll_event events[MAX_EVENTS];
while (ret != -1) {
if (g_state == 0) {
if (mcast_send_join(1369) != 0) {
printf("mcast_send_join error\n");
break;
}
g_state = 1;
}
else if (g_state == 2) {
/* sleep for a while to allow lynode work socket starts */
printf("sleep 2 seconds before start test domain\n");
sleep(2);
if (__query_test_osm() != 0) {
printf("__query_test_osm error\n");
break;
}
g_state = 3;
}
else if (g_state == 4) {
printf("test passed\n");
break;
}
n = epoll_wait(g_efd, events, MAX_EVENTS, 5000);
for (i = 0; i < n; i++) {
if (events[i].events & EPOLLIN && events[i].data.fd == g_wfd) {
printf("g_wfd has data in.\n");
if (epoll_work_recv() != 0) {
printf("epoll_work_recv error\n");
ret = -1;
break;
}
}
else if (events[i].events & EPOLLIN && events[i].data.fd == g_nfd) {
printf("g_nfd has data in.\n");
if (epoll_node_recv() != 0) {
printf("epoll_node_recv error\n");
ret = -1;
break;
}
}
else if (events[i].events & EPOLLRDHUP &&
events[i].data.fd == g_wfd) {
printf("g_wfd got hup. ???\n");
ret = -1;
break;
}
else if (events[i].events & EPOLLRDHUP &&
events[i].data.fd == g_nfd) {
printf("g_nfd got hup. \n");
ret = -1;
break;
}
else {
printf("unexpected event(%d, %d). quit\n",
events[i].events, events[i].data.fd);
ret = -1;
break;
}
}
}
out:
if (g_efd != -1)
close(g_efd);
if (g_wfd != -1)
close(g_wfd);
if (g_nfd != -1) {
close(g_nfd);
ly_packet_cleanup(&g_nfd_pkt);
}
return 0;
}
