Пример #1
0
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);
}
Пример #2
0
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);
}
Пример #3
0
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;
}
Пример #4
0
Файл: rsp.c Проект: balrawat/rsp
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;
}
Пример #5
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;
}
Пример #6
0
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);
}
Пример #7
0
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);
}
Пример #8
0
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;
}
Пример #9
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);	
}
Пример #10
0
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;
}
Пример #11
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;
}
Пример #12
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;
}
Пример #13
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;
}
Пример #14
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);
			} 
		} 
	} 

}
Пример #15
0
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;
}
Пример #16
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;
}