void my_epoll::add_event(int fd){
struct epoll_event ev;
ev.events = EPOLLIN|EPOLLET;
ev.data.fd = fd;
epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev);
set_noblock(fd);
}
/**
* Embeds a socket in a ssl connection.
* @param socket the socket to be used.
* @return The ssl connection or NULL if an error occured.
*/
int embed_ssl_socket(ssl_connection *ssl, int socket) {
int ssl_error;
time_t ssl_time;
if (!ssl)
return FALSE;
if (!ssl_initialized)
start_ssl();
if (socket >= 0) {
ssl->socket = socket;
} else {
LogError("%s: Socket error!\n", prog);
goto sslerror;
}
if ((ssl->handler = SSL_new (ssl->ctx)) == NULL) {
LogError("%s: Cannot initialize the SSL handler -- %s\n", prog, SSLERROR);
goto sslerror;
}
set_noblock(ssl->socket);
if ((ssl->socket_bio = BIO_new_socket(ssl->socket, BIO_NOCLOSE)) == NULL) {
LogError("%s: Cannot generate IO buffer -- %s\n", prog, SSLERROR);
goto sslerror;
}
SSL_set_bio(ssl->handler, ssl->socket_bio, ssl->socket_bio);
ssl_time = time(NULL);
while ((ssl_error = SSL_connect (ssl->handler)) < 0) {
if ((time(NULL) - ssl_time) > SSL_TIMEOUT) {
LogError("%s: SSL service timeout!\n", prog);
goto sslerror;
}
if (!handle_error(ssl_error, ssl))
goto sslerror;
if (!BIO_should_retry(ssl->socket_bio))
goto sslerror;
}
ssl->cipher = (char *) SSL_get_cipher(ssl->handler);
if (! update_ssl_cert_data(ssl)) {
LogError("%s: Cannot get the SSL server certificate!\n", prog);
goto sslerror;
}
return TRUE;
sslerror:
cleanup_ssl_socket(ssl);
return FALSE;
}
static struct ISIL_EV_TASK *create_enc_task_ev( int fd )
{
struct ISIL_EV_ARG_T *ev_arg;
struct ISIL_EV_TASK *ev_task;
if( fd <= 0 ) {
return NULL;
}
ev_task = ev_task_minit();
if(!ev_task) {
fprintf(stderr,"ev_task_minit err .\n");
return NULL;
}
set_noblock(fd);
SET_EV_TASK_FD(ev_task, fd);
#ifdef ENCUSEMULTITHREAD
if(enc_task_thr_alloc_task(ev_task) < 0 ) {
ev_task->release(ev_task);
return NULL;
}
reg_ev_task_callback(ev_task ,NULL, put_date_to_data_list);
#else
struct ISIL_TASK_MGT *task_mgt =get_glb_task_mgt();
task_mgt->put_ev_task_to_act(task_mgt,ev_task);
reg_ev_task_callback(ev_task ,NULL, put_date_to_consumer_cb);
#endif
ev_arg = get_ev_task_arg(ev_task);
reg_ev_to_loop( ev_arg ,GET_EV_TASK_FD(ev_task), EVENT_READ| EVENT_PERSIST,NULL , data_handle_ev_cb ,ev_task);
return ev_task;
}
bool
No1SocketClient::create_socket()
{
m_sock_fd = ::socket(AF_INET, SOCK_STREAM, 0);
if (m_sock_fd < 0)
{
GLOBAL_LOG_SEV(error, "Failed to create socket: " << strerror(errno));
return false;
}
if (!set_noblock(m_sock_fd))
{
GLOBAL_LOG_SEV(error, "Failed to set noblock!!!!");
return false;
}
struct sockaddr_in client_addr;
client_addr.sin_family = AF_INET;
client_addr.sin_addr.s_addr = htons(INADDR_ANY);
client_addr.sin_port = htons(0);
if (bind(m_sock_fd, (struct sockaddr*)(&client_addr), sizeof(struct sockaddr)) < 0)
{
GLOBAL_LOG_SEV(error, "Failed to bind socket: " << strerror(errno));
return false;
}
struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_aton(m_remote_addr.data(), &(server_addr.sin_addr));
server_addr.sin_port = htons(m_remote_port);
if (connect(m_sock_fd, (struct sockaddr*)(&server_addr), sizeof(struct sockaddr)) < 0)
{
GLOBAL_LOG_SEV(error, "Failed to connect to server: " << strerror(errno));
return false;
}
return true;
}
int main(int argc, char **argv) {
int err;
sigset_t oldmask;
pthread_t tid;
sigemptyset(&mask);
sigaddset(&mask, SIGPIPE); //向信号集中添加SIGPIPE
if ((err = pthread_sigmask(SIG_BLOCK, &mask, &oldmask)) != 0)
log_exit(err, "SIG_BLOCK error");
err = pthread_create(&tid, NULL, sig_handler, 0);
if (err != 0)
log_exit(err, "Cannot create thread!");
init_config();
int listenfd = initserver();
set_noblock(listenfd);
threadpool_t *tp = threadpool_create(8);
main_loop(tp, listenfd);
threadpool_join(tp);
exit(0);
}
int
udp_sock_server(char *host, int port)
{
int fd;
int ret;
fd = socket(AF_INET, SOCK_DGRAM, 0);
if (fd == -1) {
char errbuf[1024];
strerror_r(errno, errbuf, 1024);
DERROR("create socket error: %s\n", errbuf);
return -1;
}
set_noblock(fd);
struct sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_port = htons((short)port);
if (host == NULL || host[0] == 0) {
sin.sin_addr.s_addr = htonl(INADDR_ANY);
}else{
sin.sin_addr.s_addr = inet_addr(host);
}
memset(&(sin.sin_zero), 0, sizeof(sin.sin_zero));
DINFO("bind to: %d\n", port);
ret = bind(fd, (struct sockaddr *)&sin, sizeof(sin));
if (ret == -1) {
char errbuf[1024];
strerror_r(errno, errbuf, 1024);
DERROR("bind error: %s\n", errbuf);
close(fd);
return -1;
}
DINFO("----------fd: %d\n", fd);
return fd;
}
/**
* Embeds an accepted server socket in an existing ssl connection.
* @param ssl ssl connection
* @param socket the socket to be used.
* @return TRUE, or FALSE if an error has occured.
*/
int embed_accepted_ssl_socket(ssl_connection *ssl, int socket) {
int ssl_error;
time_t ssl_time;
ASSERT(ssl);
ssl->socket = socket;
if (!ssl_initialized)
start_ssl();
if (!(ssl->handler = SSL_new(ssl->ctx))) {
LogError("%s: Cannot initialize the SSL handler -- %s\n", prog, SSLERROR);
return FALSE;
}
if (socket < 0) {
LogError("%s: Socket error!\n", prog);
return FALSE;
}
set_noblock(ssl->socket);
if (!(ssl->socket_bio = BIO_new_socket(ssl->socket, BIO_NOCLOSE))) {
LogError("%s: Cannot generate IO buffer -- %s\n", prog, SSLERROR);
return FALSE;
}
SSL_set_bio(ssl->handler, ssl->socket_bio, ssl->socket_bio);
ssl_time = time(NULL);
while ((ssl_error = SSL_accept(ssl->handler)) < 0) {
if ((time(NULL) - ssl_time) > SSL_TIMEOUT) {
LogError("%s: SSL service timeout!\n", prog);
return FALSE;
}
if (!handle_error(ssl_error, ssl))
return FALSE;
if (!BIO_should_retry(ssl->socket_bio))
return FALSE;
}
ssl->cipher = (char *)SSL_get_cipher(ssl->handler);
if (!update_ssl_cert_data(ssl) && ssl->clientpemfile) {
LogError("%s: The client did not supply a required client certificate!\n",
prog);
return FALSE;
}
if (SSL_get_verify_result(ssl->handler) > 0) {
LogError("%s: Verification of the certificate has failed!\n", prog);
return FALSE;
}
return TRUE;
}
/**
* Embeds a socket in a ssl connection.
* @param socket the socket to be used.
* @return The ssl connection or NULL if an error occured.
*/
int embed_ssl_socket (ssl_connection *ssl, int socket) {
#ifdef HAVE_OPENSSL
int ssl_error;
time_t ssl_time;
if ( ssl == NULL ) {
return FALSE;
}
if (!ssl_initilized) {
start_ssl();
}
if ( socket >= 0 ) {
ssl->socket= socket;
} else {
log("%s: embed_ssl_socket (): Socket error!\n", prog);
goto sslerror;
}
if ((ssl->handler= SSL_new (ssl->ctx)) == NULL ) {
handle_ssl_error("embed_ssl_socket()");
log("%s: embed_ssl_socket (): Cannot initialize the SSL handler!\n",
prog);
goto sslerror;
}
set_noblock(ssl->socket);
if((ssl->socket_bio= BIO_new_socket(ssl->socket, BIO_NOCLOSE)) == NULL) {
handle_ssl_error("embed_ssl_socket()");
log("%s: embed_ssl_socket (): Cannot generate IO buffer!\n", prog);
goto sslerror;
}
SSL_set_bio(ssl->handler, ssl->socket_bio, ssl->socket_bio);
ssl_time=time(NULL);
while((ssl_error= SSL_connect (ssl->handler)) < 0) {
if((time(NULL)-ssl_time) > SSL_TIMEOUT) {
log("%s: embed_ssl_socket (): SSL service timeout!\n",
prog);
goto sslerror;
}
if (!handle_connection_error(ssl_error, ssl, "embed_ssl_socket()", SSL_TIMEOUT)) {
goto sslerror;
}
if (!BIO_should_retry(ssl->socket_bio)) {
goto sslerror;
}
}
ssl->cipher= (char *) SSL_get_cipher(ssl->handler);
if (! update_ssl_cert_data(ssl)) {
log("%s: embed_ssl_socket (): Cannot get the SSL server certificate!\n",
prog);
goto sslerror;
}
return TRUE;
sslerror:
cleanup_ssl_socket(ssl);
return FALSE;
#else
return FALSE;
#endif
}
/**
* Embeds an accepted server socket in an existing ssl connection.
* @param ssl ssl connection
* @param socket the socket to be used.
* @return TRUE, or FALSE if an error has occured.
*/
int embed_accepted_ssl_socket(ssl_connection *ssl, int socket) {
#ifdef HAVE_OPENSSL
int ssl_error;
time_t ssl_time;
ASSERT(ssl);
ssl->socket=socket;
if(!ssl_initilized) {
start_ssl();
}
if((ssl->handler= SSL_new(ssl->ctx)) == NULL) {
handle_ssl_error("embed_accepted_ssl_socket()");
log("%s: embed_accepted_ssl_socket(): Cannot initialize the"
" SSL handler!\n", prog);
goto sslerror;
}
if(socket < 0) {
log("Socket error!\n");
goto sslerror;
}
set_noblock(ssl->socket);
if((ssl->socket_bio= BIO_new_socket(ssl->socket, BIO_NOCLOSE)) == NULL) {
handle_ssl_error("embed_accepted_ssl_socket()");
log("%s: embed_accepted_ssl_socket(): Cannot generate IO buffer!\n",
prog);
goto sslerror;
}
SSL_set_bio(ssl->handler, ssl->socket_bio, ssl->socket_bio);
ssl_time= time(NULL);
while((ssl_error= SSL_accept(ssl->handler)) < 0) {
if((time(NULL)-ssl_time) > SSL_TIMEOUT) {
log("%s: embed_accepted_ssl_socket(): SSL service timeout!\n",
prog);
goto sslerror;
}
if (!handle_connection_error(ssl_error, ssl,
"embed_accepted_ssl_socket()", SSL_TIMEOUT)) {
goto sslerror;
}
if (!BIO_should_retry(ssl->socket_bio)) {
goto sslerror;
}
}
ssl->cipher= (char *) SSL_get_cipher(ssl->handler);
if(!update_ssl_cert_data(ssl) && (ssl->clientpemfile != NULL)) {
log("%s: The client did not supply a required client certificate!\n",
prog);
goto sslerror;
}
if (SSL_get_verify_result(ssl->handler)>0) {
log("%s: Verification of the certificate has failed!\n",
prog);
goto sslerror;
}
return TRUE;
sslerror:
return FALSE;
#else
return FALSE;
#endif
}
int connect_to_server(int fd, struct sockaddr_in serv_addr){
int ret = 0;
if (set_noblock(fd)){
set_noblock(fd);
}
ret = -1;
if ((ret = connect(fd, (struct sockaddr *) &serv_addr, sizeof(serv_addr))) != 0) {
if (errno != EINPROGRESS){
LOG("Connection is under building error=%d, %s\n", errno, strerror(errno));
goto SEL_ERROR;
}
else {
struct timeval tm = {5, 0};
fd_set wset;
FD_ZERO(&wset);
FD_SET(fd,&wset);
while (1) {
int res = select(fd+1,NULL,&wset,NULL,&tm);
if(res < 0)
{
if(ret == -1 && errno == EINTR)
continue;
LOG("network error in connect\n");
goto SEL_ERROR;
}
else if(res == 0)
{
LOG("connect time out\n");
goto SEL_ERROR;
}
else
{
if(FD_ISSET(fd,&wset))
{
int err = 0;
int len = sizeof(err);
getsockopt(fd, SOL_SOCKET, SO_ERROR, (char*)&err, (socklen_t *)&len);
if (0 == err) {
//LOG("connect succeed.\n");
goto SEL_SUCC;
} else {
LOG("connect failed due to error %d.\n", err);
goto SEL_ERROR;
}
}
else
{
LOG("other error when select:%s\n",strerror(errno));
goto SEL_ERROR;
}
}
}
}
}
SEL_ERROR:
if(set_blocking(fd)){
set_blocking(fd);
}
return -1;
SEL_SUCC:
if(set_blocking(fd)){
set_blocking(fd);
}
return 0;
}
int create_alarm_ev(unsigned int chipid )
{
int fd;
struct ISIL_EV_TASK * ev_task;
struct ISIL_EV_ARG_T *ev_arg;
IO_NODE_MGT *io_mgt = NULL;
io_mgt = get_io_node_mgt_by_type_id(chipid , NODE_TYPE_VI);
if( !io_mgt ) {
fprintf( stderr,"get_io_node_mgt_by_type_id err .\n");
return -1;
}
#if 0
if(io_mgt->is_enable != 1 ) {
fprintf( stderr,"io_mgt is_enable err .\n");
return -1;
}
#endif
if(io_mgt->priv) {
DEBUG_FUNCTION();
return 0;
}
fd = io_mgt->fd;
if( fd <= 0 ) {
DEBUG_FUNCTION();
return -1;
}
DEBUG_FUNCTION();
ev_task = ev_task_minit();
if(!ev_task) {
fprintf(stderr,"ev_task_minit err .\n");
return -1;
}
DEBUG_FUNCTION();
io_mgt->priv = (void *)ev_task;
set_noblock(fd);
SET_EV_TASK_FD(ev_task, fd);
fprintf(stderr,"Alarm fd[%d].\n",fd);
chip_fd_map[chipid] = fd;
struct ISIL_TASK_MGT *task_mgt =get_glb_task_mgt();
task_mgt->put_ev_task_to_act(task_mgt,ev_task);
reg_ev_task_callback(ev_task ,NULL, put_alarm_to_consumer_cb);
ev_arg = get_ev_task_arg(ev_task);
if( !ev_arg ) {
return -1;
}
reg_ev_to_loop( ev_arg ,GET_EV_TASK_FD(ev_task), EVENT_READ| EVENT_PERSIST,NULL , alarm_handle_ev_cb ,ev_task);
DEBUG_FUNCTION();
return 0;
}
int
tcp_socket_connect(char *host, int port, int timeout, int block)
{
int fd;
int ret;
fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd == -1) {
char errbuf[1024];
strerror_r(errno, errbuf, 1024);
DERROR("create socket error: %s\n", errbuf);
return -1;
}
if (block == FALSE)
set_noblock(fd);
struct linger ling = {1, 0};
ret = setsockopt(fd, SOL_SOCKET, SO_LINGER, (void *)&ling, sizeof(ling));
if (ret != 0) {
char errbuf[1024];
strerror_r(errno, errbuf, 1024);
DERROR("setsockopt LINGER error: %s\n", errbuf);
return -1;
}
int flags = 1;
ret = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (void*)&flags, sizeof(flags));
if (ret != 0) {
char errbuf[1024];
strerror_r(errno, errbuf, 1024);
DERROR("setsockopt NODELAY error: %s\n", errbuf);
return -1;
}
ret = setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&flags, sizeof(flags));
if (ret != 0) {
char errbuf[1024];
strerror_r(errno, errbuf, 1024);
DERROR("setsockopt KEEPALIVE error: %s\n", errbuf);
return -1;
}
struct sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_port = htons((short)port);
if (NULL == host || 0 == host[0]) {
sin.sin_addr.s_addr = htonl(INADDR_ANY);
}else{
sin.sin_addr.s_addr = inet_addr(host);
}
DINFO("connect to %s:%d\n", host, port);
do {
ret = connect(fd, (struct sockaddr*)&sin, sizeof(sin));
} while (ret == -1 && errno == EINTR);
DINFO("ret: %d\n", ret);
if (ret == -1) {
if (errno == EINPROGRESS || errno == EALREADY || errno == EWOULDBLOCK || errno == 0 || errno == EISCONN)
return fd;
char errbuf[1024];
strerror_r(errno, errbuf, 1024);
DWARNING("connect error: %s\n", errbuf);
close(fd);
return -1;
}
return fd;
}
int main(int argc,char *argv[])
{
if(argc != 3){
printf("please use:%s [ip] [port]",argv[0]);
exit(1);
}
int listen_sock = creat_socket(argv[1],argv[2]);
int epoll_fd = epoll_create(256);
if(epoll_fd < 0){
perror("epoll creat");
exit(6);
}
struct epoll_event ep_ev;
ep_ev.events = EPOLLIN;//数据的读取
ep_ev.data.fd = listen_sock;
//添加关心的事件
if(epoll_ctl(epoll_fd,EPOLL_CTL_ADD,listen_sock,&ep_ev) < 0){
perror("epoll_ctl");
exit(7);
}
struct epoll_event ready_ev[128];//申请空间来放就绪的事件。
int maxnum = 128;
int timeout = 1000;//设置超时时间，若为-1，则永久阻塞等待。
int ret = 0;
int done = 0;
while(!done){
switch(ret = epoll_wait(epoll_fd,ready_ev,maxnum,timeout)){
case -1:
perror("epoll_wait");
break;
case 0:
printf("time out...\n");
break;
default://至少有一个事件就绪
{
int i = 0;
for(;i < ret;++i){
//判断是否为监听套接字，是的话accept
int fd = ready_ev[i].data.fd;
if((fd == listen_sock) && (ready_ev[i].events & EPOLLIN)){
struct sockaddr_in remote;
socklen_t len = sizeof(remote);
int accept_sock = accept(listen_sock,(struct sockaddr*)&remote,&len);
if(accept_sock < 0){
perror("accept");
continue;
}
printf("accept a client..[ip]: %s,[port]: %d\n",inet_ntoa(remote.sin_addr),ntohs(remote.sin_port));
//将新的事件添加到epoll集合中
ep_ev.events = EPOLLIN | EPOLLET;
ep_ev.data.fd = accept_sock;
set_noblock(accept_sock);
if(epoll_ctl(epoll_fd,EPOLL_CTL_ADD,accept_sock,&ep_ev) < 0){
perror("epoll_ctl");
close(accept_sock);
}
}
else{//普通IO
if(ready_ev[i].events & EPOLLIN){
//申请空间同时存文件描述符和缓冲区地址
char buf[102400];
memset(buf,'\0',sizeof(buf));
ssize_t _s = recv(fd,buf,sizeof(buf)-1,0);
if(_s < 0){
perror("recv");
continue;
}else if(_s == 0){
printf("remote close..\n");
//远端关闭了，进行善后
epoll_ctl(epoll_fd,EPOLL_CTL_DEL,fd,NULL);
close(fd);
}else{
//读取成功，输出数据
printf("client# %s",buf);
fflush(stdout);
//将事件改写为关心事件，进行回写
ep_ev.data.fd = fd;
ep_ev.events = EPOLLOUT | EPOLLET;
//在epoll实例中更改同一个事件
epoll_ctl(epoll_fd,EPOLL_CTL_MOD,fd,&ep_ev);
}
}else if(ready_ev[i].events & EPOLLOUT){
const char*msg = "HTTP/1.1 200 OK \r\n\r\n<h1> hi girl </h1>\r\n";
send(fd,msg,strlen(msg),0);
epoll_ctl(epoll_fd,EPOLL_CTL_DEL,fd,NULL);
close(fd);
}
}
}
}
break;
}
}
close(listen_sock);
return 0;
}
