void on_accept(int sock, short event, void* arg) { struct sockaddr_in cli_addr; int newfd, sin_size; // read_ev must allocate from heap memory, otherwise the program would crash from segmant fault // 如果是在栈上分配,那么当函数返回时变量占用的内存会被释放, // 因此事件主循环event_base_dispatch会访问无效的内存而导致进程崩溃(即crash) struct sock_ev* ev = (struct sock_ev*)malloc(sizeof(struct sock_ev)); ev->read_ev = (struct event*)malloc(sizeof(struct event)); ev->write_ev = (struct event*)malloc(sizeof(struct event)); sin_size = sizeof(struct sockaddr_in); // 4. accept:接受客户端请求,建立连接 // 如果accept成功返回,则服务器与客户已经正确建立连接了,此时服务器通过accept返回的套接字来完成与客户的通信。 newfd = accept(sock, (struct sockaddr*)&cli_addr, &sin_size); // 在代表客户的描述字newfd上监听可读事件,当有数据到达时调用on_read函数 event_set(ev->read_ev, newfd, EV_READ|EV_PERSIST, on_read, ev); // ev作为参数传递给了on_read函数 event_base_set(base, ev->read_ev); event_add(ev->read_ev, NULL); }
/* * Setup a worker thread */ static rstatus_t thread_setup(struct thread_worker *t) { rstatus_t status; t->base = event_base_new(); if (t->base == NULL) { log_error("event init failed: %s", strerror(errno)); return MC_ERROR; } /* listen for notifications from other threads */ event_set(&t->notify_event, t->notify_receive_fd, EV_READ | EV_PERSIST, thread_libevent_process, t); event_base_set(t->base, &t->notify_event); status = event_add(&t->notify_event, 0); if (status < 0) { log_error("event add failed: %s", strerror(errno)); return MC_ERROR; } status = thread_setup_stats(t); if (status != MC_OK) { return status; } t->kbuf = klog_buf_create(); if (t->kbuf == NULL) { log_error("klog buf create failed: %s", strerror(errno)); return MC_ENOMEM; } conn_cq_init(&t->new_cq); t->suffix_cache = cache_create("suffix", CAS_SUFFIX_SIZE, sizeof(char *)); if (t->suffix_cache == NULL) { log_error("cache create of suffix cache failed: %s", strerror(errno)); return MC_ENOMEM; } return MC_OK; }
//int main (int argc, char **argv){ int main (void){ struct event ev; int socket; char device[] = "/dev/simplex.0"; socket = open (device, O_RDWR | O_NONBLOCK, 0); if (socket == -1) { perror("open"); exit (1); } fprintf(stderr, "polling device %s\n", device); event_init(); event_set(&ev, socket, EV_READ, server_read, &ev); event_add(&ev, NULL); event_dispatch(); return (0); }
void gen_traffic_accept(int fd, short events, void *arg) { struct listener *l; struct sockaddr_storage ss; struct timeval pause; struct reader *r; socklen_t len; int s; l = arg; pause.tv_sec = 1; pause.tv_usec = 0; len = sizeof(ss); s = accept(fd, (struct sockaddr *)&ss, &len); if (s == -1) { switch (errno) { case EINTR: case EWOULDBLOCK: case ECONNABORTED: return; case EMFILE: case ENFILE: event_del(&l->ev); evtimer_add(&l->pause, &pause); return; default: err(1, "%s", "accept"); } } if (ioctl(s, FIONBIO, &on) == -1) err(1, "%s", "reader ioctl(FIONBIO)"); r = calloc(1, sizeof(*r)); if (r == NULL) errx(1, "%s", "cannot calloc reader"); r->fd = s; event_set(&r->ev, s, EV_READ | EV_PERSIST, gen_traffic_request, r); event_add(&r->ev, NULL); }
void tmate_encoder_init(struct tmate_encoder *encoder, tmate_encoder_write_cb *callback, void *userdata) { msgpack_packer_init(&encoder->pk, encoder, &on_encoder_write); encoder->buffer = evbuffer_new(); encoder->ready_callback = callback; encoder->userdata = userdata; if (!encoder->buffer) tmate_fatal("Can't allocate buffer"); event_set(&encoder->ev_buffer, -1, EV_READ | EV_PERSIST, on_encoder_buffer_ready, encoder); event_add(&encoder->ev_buffer, NULL); encoder->ev_active = false; }
/** * init the plugin with the parsed config */ static int network_mysqld_master_plugin_apply_config(chassis *chas, chassis_plugin_config *config) { network_mysqld_con *con; network_socket *listen_sock; if (!config->address) config->address = g_strdup(":4041"); if (!config->master_username) config->master_username = g_strdup("root"); if (!config->master_password) config->master_password = g_strdup("secret"); /** * create a connection handle for the listen socket */ con = network_mysqld_con_new(); network_mysqld_add_connection(chas, con); con->config = config; config->listen_con = con; listen_sock = network_socket_new(); con->server = listen_sock; /* set the plugin hooks as we want to apply them to the new connections too later */ network_mysqld_server_connection_init(con); /* FIXME: network_socket_set_address() */ if (0 != network_address_set_address(listen_sock->dst, config->address)) { return -1; } /* FIXME: network_socket_bind() */ if (0 != network_socket_bind(listen_sock)) { return -1; } /** * call network_mysqld_con_accept() with this connection when we are done */ event_set(&(listen_sock->event), listen_sock->fd, EV_READ|EV_PERSIST, network_mysqld_con_accept, con); event_base_set(chas->event_base, &(listen_sock->event)); event_add(&(listen_sock->event), NULL); return 0; }
int32_t iothread_start( struct iothread * self, uint8_t index, iothreads_t parent ) { self->index = index; self->parent = parent; self->sets = evsets_create(); if ( self->sets == NULL ) { iothread_stop(self); return -1; } self->cmdevent = event_create(); self->queue = msgqueue_create( MSGQUEUE_DEFAULT_SIZE ); if ( self->queue == NULL || self->cmdevent == NULL ) { iothread_stop(self); return -2; } // 初始化命令事件 event_set( self->cmdevent, msgqueue_popfd(self->queue), EV_READ|EV_PERSIST ); event_set_callback( self->cmdevent, iothread_on_command, self ); evsets_add( self->sets, self->cmdevent, 0 ); // 启动线程 pthread_attr_t attr; pthread_attr_init( &attr ); // assert( pthread_attr_setstacksize( &attr, THREAD_DEFAULT_STACK_SIZE ) ); pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_DETACHED ); int32_t rc = pthread_create(&(self->id), &attr, iothread_main, self); pthread_attr_destroy( &attr ); if ( rc != 0 ) { iothread_stop(self); return -3; } return 0; }
void network_init(unsigned short port) { struct KSOCK_svr_opt opt; struct event *ev; int listen_fd; opt.addr = KSOCK_INADDR_ANY; opt.port = port; opt.backlog = 5; listen_fd = KSOCK_svr_listen_tcp(&opt); event_init(); ev = malloc(sizeof(struct event)); event_set(ev, listen_fd, EV_READ|EV_PERSIST, network_listen_callback, ev); event_add(ev, NULL); g_data.listen_fd = listen_fd; printf("listen port: %d\n", port); }
void on_accept(int sock,short event,void *arg) { struct sockaddr_in cli_addr; int newfd = -1; socklen_t sockaddrlen=sizeof(struct sockaddr); int err = 0; sock_ev* ev = new sock_ev; ev->read_ev = new struct event; ev->write_ev = new struct event; newfd = accept(sock,(struct sockaddr *)&cli_addr,&sockaddrlen); if ( -1 == newfd ) { debug_log("accept client failed",errno); return ; } event_set(ev->read_ev,newfd,EV_READ|EV_PERSIST,on_read,ev); event_base_set(base,ev->read_ev); event_add(ev->read_ev,NULL); }
struct tmuxpeer * proc_add_peer(struct tmuxproc *tp, int fd, void (*dispatchcb)(struct imsg *, void *), void *arg) { struct tmuxpeer *peer; peer = xcalloc(1, sizeof *peer); peer->parent = tp; peer->dispatchcb = dispatchcb; peer->arg = arg; imsg_init(&peer->ibuf, fd); event_set(&peer->event, fd, EV_READ, proc_event_cb, peer); log_debug("add peer %p: %d (%p)", peer, fd, arg); proc_update_event(peer); return (peer); }
static gboolean lua_tcp_make_connection (struct lua_tcp_cbdata *cbd) { int fd; rspamd_inet_address_set_port (cbd->addr, cbd->port); fd = rspamd_inet_address_connect (cbd->addr, SOCK_STREAM, TRUE); if (fd == -1) { msg_info ("cannot connect to %s", rspamd_inet_address_to_string (cbd->addr)); return FALSE; } cbd->fd = fd; event_set (&cbd->ev, cbd->fd, EV_WRITE, lua_tcp_handler, cbd); event_base_set (cbd->ev_base, &cbd->ev); event_add (&cbd->ev, &cbd->tv); return TRUE; }
bool SocketListen::socket_listen(string ip, int port) { struct sockaddr_in sin; sin.sin_family = AF_INET; sin.sin_port = htons(port); sin.sin_addr.s_addr = INADDR_ANY; int fd = socket(AF_INET, SOCK_STREAM, 0); fd_listen_ = fd; if (fd == INVALID_SOCKET || fd == SOCKET_ERROR) { std::cout << __func__ << " create socket error" << std::endl; return false; } int reuseaddr = 1; int key = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&reuseaddr, sizeof(reuseaddr)); if (key != 0) { std::cout << __func__<< " setsockopt error errno = "<< errno << " key = "<< key <<std::endl; return false; } if ( bind(fd, (struct sockaddr*)&sin, sizeof(sin) ) != 0) { std::cout << __func__<< " bind error errno = "<< errno << std::endl; return false; } if (listen(fd, 65535) != 0) { std::cout << __func__<< " listen error errno = "<< errno << std::endl; return false; } evutil_make_socket_nonblocking(fd); event_set(&ev_, fd, EV_READ | EV_PERSIST, OnAccept, this); event_base_set(base_, &ev_); event_add(&ev_, 0); char info[100]; sprintf(info, "Listen Port %d", port); CreateThread(info); }
/* * Set up a thread's information. */ static void setup_thread(LIBEVENT_THREAD *me) { //初始化worker线程的libevent me->base = event_init(); if (! me->base) { fprintf(stderr, "Can't allocate event base\n"); exit(1); } /* Listen for notifications from other threads */ //设置事件,监听与主线程的通信,事件处理函数为thread_libevent_process event_set(&me->notify_event, me->notify_receive_fd, EV_READ | EV_PERSIST, thread_libevent_process, me); event_base_set(me->base, &me->notify_event); //将事件添加到libevent的事件循环中 if (event_add(&me->notify_event, 0) == -1) { fprintf(stderr, "Can't monitor libevent notify pipe\n"); exit(1); } //创建一个空队列,用于接收主线程发送过来的CQ_ITEM me->new_conn_queue = malloc(sizeof(struct conn_queue)); if (me->new_conn_queue == NULL) { perror("Failed to allocate memory for connection queue"); exit(EXIT_FAILURE); } //初始化CQ_ITEM队列 cq_init(me->new_conn_queue); if (pthread_mutex_init(&me->stats.mutex, NULL) != 0) { perror("Failed to initialize mutex"); exit(EXIT_FAILURE); } me->suffix_cache = cache_create("suffix", SUFFIX_SIZE, sizeof(char*), NULL, NULL); if (me->suffix_cache == NULL) { fprintf(stderr, "Failed to create suffix cache\n"); exit(EXIT_FAILURE); } }
void pcap_event_init(client_conn_t * conn) { struct bpf_program filterp; bpf_u_int32 maskp, netp; char errbuf[PCAP_ERRBUF_SIZE]; if (pcap_lookupnet(conn->start_header.dev, &netp, &maskp, errbuf) < 0) goto pcap_err; if ((conn->descr = pcap_open_live(conn->start_header.dev, conn->start_header.snaplen, 1, 100, errbuf)) == NULL) goto pcap_err; if (conn->start_header.bpf != NULL) { if (pcap_compile(conn->descr, &filterp, conn->start_header.bpf, 0, netp) < 0) goto pcap_err; pcap_setfilter(conn->descr, &filterp); } if (pcap_setnonblock(conn->descr, 1, errbuf) < 0) goto pcap_err; if ((conn->pcap_fd = pcap_get_selectable_fd(conn->descr)) <= 0) goto pcap_err; event_set(&conn->pcap_event, conn->pcap_fd, EV_READ | EV_PERSIST, (void *) pcap_driver, (void *) conn); event_add(&conn->pcap_event, 0); return; pcap_err: LOG("pcap err %s\n", errbuf); free_client_conn(conn); return; }
struct NeubotPoller * NeubotPoller_construct(void) { struct NeubotPoller *self; struct event_base *base; int retval; base = event_init(); if (base == NULL) return (NULL); if (evdns_init() != 0) return (NULL); self = (struct NeubotPoller *) calloc(1, sizeof(*self)); if (self == NULL) return (NULL); self->base = base; self->dnsbase = evdns_get_global_base(); if (self->dnsbase == NULL) abort(); #ifndef WIN32 event_set(&self->evsignal, SIGINT, EV_SIGNAL, NeubotPoller_sigint, self); retval = event_add(&self->evsignal, NULL); if (retval != 0) goto failure; #endif return (self); failure: #ifndef WIN32 event_del(&self->evsignal); #endif free(self); return (NULL); }
int connect_server(struct jsonrpc_server *server) { struct sockaddr_in server_addr; struct hostent *hp; server_addr.sin_family = AF_INET; server_addr.sin_port = htons(server->port); hp = gethostbyname(server->host); if (hp == NULL) { LM_ERR("gethostbyname(%s) failed with h_errno=%d.\n", server->host, h_errno); handle_server_failure(server); return -1; } memcpy(&(server_addr.sin_addr.s_addr), hp->h_addr, hp->h_length); int sockfd = socket(AF_INET,SOCK_STREAM,0); if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in))) { LM_WARN("Failed to connect to %s on port %d... %s\n", server->host, server->port, strerror(errno)); handle_server_failure(server); return -1; } if (set_non_blocking(sockfd) != 0) { LM_WARN("Failed to set socket (%s:%d) to non blocking.\n", server->host, server->port); handle_server_failure(server); return -1; } server->socket = sockfd; server->status = JSONRPC_SERVER_CONNECTED; struct event *socket_ev = pkg_malloc(sizeof(struct event)); CHECK_MALLOC(socket_ev); event_set(socket_ev, sockfd, EV_READ | EV_PERSIST, socket_cb, server); event_add(socket_ev, NULL); server->ev = socket_ev; return 0; }
void set_event(void) { struct event evfifo; struct stat st; const char *fifo = "event.fifo"; int socket; if (lstat (fifo, &st) == 0) { if ((st.st_mode & S_IFMT) == S_IFREG) { errno = EEXIST; perror("lstat"); exit (1); } } unlink (fifo); if (mkfifo (fifo, 0600) == -1) { perror("mkfifo"); exit (1); } /* Linux pipes are broken, we need O_RDWR instead of O_RDONLY */ socket = open (fifo, O_RDWR | O_NONBLOCK, 0); if (socket == -1) { perror("open"); exit (1); } fprintf(stderr, "Write data to %s\n", fifo); /* Initalize the event library */ event_init(); arg_t arg; arg.t = this; arg.e = &evfifo; event_set(&evfifo, socket, EV_READ, Test::run, &arg); event_add(&evfifo, NULL); event_dispatch(); }
int evsignal_init(struct event_base *base) { int i; /* * Our signal handler is going to write to one end of the socket * pair to wake up our event loop. The event loop then scans for * signals that got delivered. */ if (evutil_socketpair( AF_UNIX, SOCK_STREAM, 0, base->sig.ev_signal_pair) == -1) { #ifdef WIN32 /* Make this nonfatal on win32, where sometimes people have localhost firewalled. */ event_warn("%s: socketpair", __func__); #else event_err(1, "%s: socketpair", __func__); #endif return -1; } FD_CLOSEONEXEC(base->sig.ev_signal_pair[0]); FD_CLOSEONEXEC(base->sig.ev_signal_pair[1]); base->sig.sh_old = NULL; base->sig.sh_old_max = 0; base->sig.evsignal_caught = 0; memset(&base->sig.evsigcaught, 0, sizeof(sig_atomic_t)*NSIG); /* initialize the queues for all events */ for (i = 0; i < NSIG; ++i) TAILQ_INIT(&base->sig.evsigevents[i]); evutil_make_socket_nonblocking(base->sig.ev_signal_pair[0]); event_set(&base->sig.ev_signal, base->sig.ev_signal_pair[1], EV_READ | EV_PERSIST, evsignal_cb, &base->sig.ev_signal); base->sig.ev_signal.ev_base = base; base->sig.ev_signal.ev_flags |= EVLIST_INTERNAL; return 0; }
void on_accept(int fd, short ev, void *arg) { int client_fd; struct sockaddr_in client_addr; socklen_t client_len = sizeof(client_addr); struct client *client; client_fd = accept(fd, (struct sockaddr *)&client_addr, &client_len); if (client_fd == -1) { warn("accept failed"); return; } if (setnonblock(client_fd) < 0) { warn("failed to set client socket non-blocking"); } client = calloc(1, sizeof(*client)); if (client == NULL) { err(1, "malloc failed"); } event_set(&client->ev_read, client_fd, EV_READ|EV_PERSIST, on_read, client); event_add(&client->ev_read, NULL); }
void connection_accept(int fd, short event, void *arg) { struct sockaddr_in clientaddr; socklen_t len = sizeof(clientaddr); int cfd; if ((cfd = accept(fd, (struct sockaddr *)&clientaddr, &len)) < 0 ) return; struct client_state *cs = calloc(1, sizeof(struct client_state)); cs->state = FSM_ENTER; cs->evb = evbuffer_new(); event_set(&cs->ev, cfd, EV_READ, (void *) connection_client, cs); event_add(&cs->ev, &tv); clients++; if (clients >= MAX_CLIENTS) { event_del(&ev); } }
/** * setup the notification-fd of a event-thread * * all event-threads listen on the same notification pipe * * @see chassis_event_handle() */ int chassis_event_threads_init_thread(chassis_event_thread_t *thread, chassis *chas) { thread->event_base = event_base_new(); thread->chas = chas; int fds[2]; if (pipe(fds)) { int err; err = errno; g_log_dbproxy(g_error, "evutil_socketpair() failed: %s (%d)", g_strerror(err), err); } thread->notify_receive_fd = fds[0]; thread->notify_send_fd = fds[1]; event_set(&(thread->notify_fd_event), thread->notify_receive_fd, EV_READ | EV_PERSIST, chassis_event_handle, thread); event_base_set(thread->event_base, &(thread->notify_fd_event)); event_add(&(thread->notify_fd_event), NULL); return 0; }
void on_read(int sock, short event, void* arg) { struct event* write_ev; int size; char* buffer = (char*)malloc(MEM_SIZE); size = (int)recv(sock, buffer, MEM_SIZE, 0); buffer[size] = '\0'; printf("receive data:%s, size:%d\n", buffer, size); if (size == 0) { buffer[0] = '\0'; event_del((struct event*)arg); free(arg); close(sock); return; } write_ev = (struct event*) malloc(sizeof(struct event));; event_set(write_ev, sock, EV_WRITE, on_write, buffer); event_base_set(base, write_ev); event_add(write_ev, NULL); }
//Initialize sockets and related events static int init_pro_network() { // Send buffer for talking to acceptors to_acceptors = udp_sendbuf_new(PAXOS_ACCEPTORS_NET); if(to_acceptors == NULL) { printf("Error creating proposer->acceptors network sender\n"); return PROPOSER_ERROR; } // Message receive event for_proposer = udp_receiver_new(PAXOS_PROPOSERS_NET); if (for_proposer == NULL) { printf("Error creating proposer network receiver\n"); return PROPOSER_ERROR; } event_set(&proposer_msg_event, for_proposer->sock, EV_READ|EV_PERSIST, pro_handle_newmsg, NULL); event_add(&proposer_msg_event, NULL); return 0; }
/* * Set up a thread's information. */ static void setup_thread(LIBEVENT_THREAD *me) { if (! me->base) { me->base = event_init(); if (! me->base) { fprintf(stderr, "Can't allocate event base\n"); exit(1); } } /* Listen for notifications from other threads */ event_set(&me->notify_event, me->notify_receive_fd, EV_READ | EV_PERSIST, thread_libevent_process, me); event_base_set(me->base, &me->notify_event); if (event_add(&me->notify_event, 0) == -1) { fprintf(stderr, "Can't monitor libevent notify pipe\n"); exit(1); } cq_init(&me->new_conn_queue); }
static void setup_dispatcher(struct event_base *main_base, void (*dispatcher_callback)(int, short, void *)) { memset(&dispatcher_thread, 0, sizeof(dispatcher_thread)); dispatcher_thread.type = DISPATCHER; dispatcher_thread.base = main_base; dispatcher_thread.thread_id = pthread_self(); if (!create_notification_pipe(&dispatcher_thread)) { exit(1); } /* Listen for notifications from other threads */ event_set(&dispatcher_thread.notify_event, dispatcher_thread.notify[0], EV_READ | EV_PERSIST, dispatcher_callback, &dispatcher_callback); event_base_set(dispatcher_thread.base, &dispatcher_thread.notify_event); if (event_add(&dispatcher_thread.notify_event, 0) == -1) { settings.extensions.logger->log(EXTENSION_LOG_WARNING, NULL, "Can't monitor libevent notify pipe\n"); exit(1); } }
int main () { struct event ev_accept; g_print("server_proc_main init .\n"); int listenfd = create_socket( NULL, 9009, SOCK_STREAM); if (listenfd < 0) { g_print("tcp_listen failed!\n"); return -1; } g_print("listenfd is %d\n", listenfd); // initialize libevent. event_init (); /* We now have a listeing socket, we create a read event to * be notified when a client connects. */ time_slot_t *ts = (time_slot_t *)calloc(1,sizeof(time_slot_t)); ts->tv.tv_sec=1; ts->tv.tv_usec=0; evtimer_set(&ts->ev_timeout, timeout_cb, ts /*&ev_timeout*/); evtimer_add(&ts->ev_timeout, &ts->tv); event_set (&ev_accept, listenfd, EV_READ | EV_PERSIST, conn_accept, NULL); struct timeval tvaccept; tvaccept.tv_sec=3; tvaccept.tv_usec=3; event_add (&ev_accept, &tvaccept); event_dispatch (); return 0; }
void conn_accept (int sockfd, short event, void* arg) { if(event == EV_TIMEOUT) { g_print("%d :accept timeout %d\n", sockfd, event); return; } g_print("%d :accept %d\n", sockfd, event); struct sockaddr_in cliaddr; g_print("%s(): fd = %d, event = %d.\n", __func__, sockfd, event); socklen_t len = sizeof (struct sockaddr_in); /* Accept the new connection. */ int connfd = accept (sockfd, (struct sockaddr*)&cliaddr, &len); if (connfd < 0) { g_print("accept failed! (%s)\n", strerror(errno)); return; } connection_t *conn = conn_new(); conn->sockfd = connfd; conn->tv.tv_sec = 5; //timeout_set(&conn->ev_read, timeout_cb, conn); event_set(&conn->ev_read, connfd, EV_READ, conn_input, conn); if (event_add (&conn->ev_read, NULL) == -1) { return; } timeout_add(&conn->ev_read, &conn->tv); g_print("Accepted connection from %s, socket=%d\n", inet_ntoa(cliaddr.sin_addr), connfd); }
/* * Set up a thread's information. */ static void setup_thread(LIBEVENT_THREAD *me) { me->base = event_init(); if (! me->base) { fprintf(stderr, "Can't allocate event base\n"); exit(1); } #ifdef DUP_AWARE event_priority_init(NUM_PRIORITIES); #endif /* Listen for notifications from other threads */ event_set(&me->notify_event, me->notify_receive_fd, EV_READ | EV_PERSIST, thread_libevent_process, me); event_base_set(me->base, &me->notify_event); if (event_add(&me->notify_event, 0) == -1) { fprintf(stderr, "Can't monitor libevent notify pipe\n"); exit(1); } me->new_conn_queue = malloc(sizeof(struct conn_queue)); if (me->new_conn_queue == NULL) { perror("Failed to allocate memory for connection queue"); exit(EXIT_FAILURE); } cq_init(me->new_conn_queue); if (pthread_mutex_init(&me->stats.mutex, NULL) != 0) { perror("Failed to initialize mutex"); exit(EXIT_FAILURE); } me->suffix_cache = cache_create("suffix", SUFFIX_SIZE, sizeof(char*), NULL, NULL); if (me->suffix_cache == NULL) { fprintf(stderr, "Failed to create suffix cache\n"); exit(EXIT_FAILURE); } }
/* * Set up a thread's information. */ static void setup_thread(LIBEVENT_THREAD *me) { me->base = event_init(); if (! me->base) { fprintf(stderr, "Can't allocate event base\n"); exit(1); } /* Listen for notifications from other threads */ //为管道设置读事件监听,thread_libevent_process为回调函数 event_set(&me->notify_event, me->notify_receive_fd, EV_READ | EV_PERSIST, thread_libevent_process, me); event_base_set(me->base, &me->notify_event); if (event_add(&me->notify_event, 0) == -1) { fprintf(stderr, "Can't monitor libevent notify pipe\n"); exit(1); } //为新线程创建连接CQ链表 me->new_conn_queue = malloc(sizeof(struct conn_queue)); if (me->new_conn_queue == NULL) { perror("Failed to allocate memory for connection queue"); exit(EXIT_FAILURE); } //初始化线程控制器内的CQ链表 cq_init(me->new_conn_queue); if (pthread_mutex_init(&me->stats.mutex, NULL) != 0) { perror("Failed to initialize mutex"); exit(EXIT_FAILURE); } //创建cache me->suffix_cache = cache_create("suffix", SUFFIX_SIZE, sizeof(char*), NULL, NULL); if (me->suffix_cache == NULL) { fprintf(stderr, "Failed to create suffix cache\n"); exit(EXIT_FAILURE); } }
int main(int argc, char **argv) { int listen_fd; struct sockaddr_in listen_addr; struct event ev_accept; int reuseaddr_on; /* Initialize libevent. */ event_init(); /* Create our listening socket. */ listen_fd = socket(AF_INET, SOCK_STREAM, 0); if (listen_fd < 0) err(1, "listen failed"); memset(&listen_addr, 0, sizeof(listen_addr)); listen_addr.sin_family = AF_INET; listen_addr.sin_addr.s_addr = INADDR_ANY; listen_addr.sin_port = htons(SERVER_PORT); if (bind(listen_fd, (struct sockaddr *)&listen_addr, sizeof(listen_addr)) < 0) err(1, "bind failed"); if (listen(listen_fd, 5) < 0) err(1, "listen failed"); reuseaddr_on = 1; setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr_on, sizeof(reuseaddr_on)); /* Set the socket to non-blocking, this is essential in event * based programming with libevent. */ if (setnonblock(listen_fd) < 0) err(1, "failed to set server socket to non-blocking"); /* We now have a listening socket, we create a read event to * be notified when a client connects. */ event_set(&ev_accept, listen_fd, EV_READ | EV_PERSIST, on_accept, NULL); event_add(&ev_accept, NULL); /* Start the event loop. */ event_dispatch(); return 0; }