int initServer(int *argcp, char **argv) { int socketlisten; struct sockaddr_in addresslisten; struct event accept_event; int reuse = 1; event_init(); socketlisten = socket(AF_INET, SOCK_STREAM, 0); if (socketlisten < 0) { fprintf(stderr, "Failed to create listen socket"); return 1; } memset(&addresslisten, 0, sizeof(addresslisten)); addresslisten.sin_family = AF_INET; addresslisten.sin_addr.s_addr = INADDR_ANY; addresslisten.sin_port = htons(25000); if (bind(socketlisten, (struct sockaddr *)&addresslisten, sizeof(addresslisten)) < 0) { fprintf(stderr, "Failed to bind"); return 1; } if (listen(socketlisten, 5) < 0) { fprintf(stderr, "Failed to listen to socket"); return 1; } setsockopt(socketlisten, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)); setnonblock(socketlisten); event_set(&accept_event, socketlisten, EV_READ|EV_PERSIST, accept_callback, NULL); event_add(&accept_event, NULL); event_dispatch(); close(socketlisten); return 0; }
int listen(int sockfd, int backlog) { struct fdtab_entry *e = fdtab_get(sockfd); switch(e->type) { case FDTAB_TYPE_UNIX_SOCKET: POSIXCOMPAT_DEBUG("listen(%d, %d)\n", sockfd, backlog); struct _unix_socket *us = e->handle; errval_t err = unixsock_export(us, unixsock_listening, unixsock_connected, get_default_waitset(), IDC_EXPORT_FLAGS_DEFAULT); if(err_is_fail(err)) { DEBUG_ERR(err, "unixsock_export failed"); return -1; } while(us->u.passive.listen_iref == NULL_IREF) { // XXX: Should wait only on monitor event_dispatch(get_default_waitset()); } us->passive = true; us->u.passive.max_backlog = backlog; us->u.passive.backlog = calloc(backlog, sizeof(struct unixsock_binding *)); char str[128]; snprintf(str, 128, "%"PRIuIREF, us->u.passive.listen_iref); err = vfs_write(us->vfs_handle, str, strlen(str), NULL); if(err_is_fail(err)) { USER_PANIC_ERR(err, "vfs_write"); } break; case FDTAB_TYPE_LWIP_SOCKET: lwip_mutex_lock(); int ret = lwip_listen(e->fd, backlog); lwip_mutex_unlock(); return ret; default: return -1; } return 0; }
static void http_negative_content_length_test(void) { short port = -1; struct evhttp_connection *evcon = NULL; struct evhttp_request *req = NULL; test_ok = 0; fprintf(stdout, "Testing HTTP Negative Content Length: "); http = http_setup(&port, NULL); evcon = evhttp_connection_new("127.0.0.1", port); if (evcon == NULL) { fprintf(stdout, "FAILED\n"); exit(1); } /* * At this point, we want to schedule a request to the HTTP * server using our make request method. */ req = evhttp_request_new(http_request_bad, NULL); /* Cause the response to have a negative content-length */ evhttp_add_header(req->output_headers, "X-Negative", "makeitso"); /* We give ownership of the request to the connection */ if (evhttp_make_request(evcon, req, EVHTTP_REQ_GET, "/test") == -1) { fprintf(stdout, "FAILED\n"); exit(1); } event_dispatch(); evhttp_free(http); if (test_ok != 1) { fprintf(stdout, "FAILED\n"); exit(1); } fprintf(stdout, "OK\n"); }
static void http_multi_line_header_test(void) { struct bufferevent *bev; int fd; const char *http_start_request; short port = -1; test_ok = 0; fprintf(stdout, "Testing HTTP Server with multi line: "); http = http_setup(&port, NULL); fd = http_connect("127.0.0.1", port); /* Stupid thing to send a request */ bev = bufferevent_new(fd, http_readcb, http_writecb, http_errorcb, NULL); http_start_request = "GET /test HTTP/1.1\r\n" "Host: somehost\r\n" "Connection: close\r\n" "X-Multi: aaaaaaaa\r\n" " a\r\n" "\tEND\r\n" "X-Last: last\r\n" "\r\n"; bufferevent_write(bev, http_start_request, strlen(http_start_request)); event_dispatch(); bufferevent_free(bev); EVUTIL_CLOSESOCKET(fd); evhttp_free(http); if (test_ok != 4) { fprintf(stdout, "FAILED\n"); exit(1); } fprintf(stdout, "OK\n"); }
static void test_bufferevent_filters_impl(int use_pair) { struct bufferevent *bev1 = NULL, *bev2 = NULL; char buffer[8333]; int i; test_ok = 0; if (use_pair) { struct bufferevent *pair[2]; tt_assert(0 == bufferevent_pair_new(NULL, 0, pair)); bev1 = pair[0]; bev2 = pair[1]; } else { bev1 = bufferevent_socket_new(NULL, pair[0], 0); bev2 = bufferevent_socket_new(NULL, pair[1], 0); } for (i = 0; i < sizeof(buffer); i++) buffer[i] = i; bev1 = bufferevent_filter_new(bev1, NULL, bufferevent_output_filter, 0, NULL, NULL); bev2 = bufferevent_filter_new(bev2, bufferevent_input_filter, NULL, 0, NULL, NULL); bufferevent_setcb(bev1, NULL, writecb, errorcb, NULL); bufferevent_setcb(bev2, readcb, NULL, errorcb, NULL); bufferevent_disable(bev1, EV_READ); bufferevent_enable(bev2, EV_READ); /* insert some filters */ bufferevent_write(bev1, buffer, sizeof(buffer)); event_dispatch(); if (test_ok != 2) test_ok = 0; end: bufferevent_free(bev1); bufferevent_free(bev2); }
END_TEST START_TEST(test_ws_error_2) { parse_message(__parser_info, __buf, MESSAGE); __waiting_error = WS_CLOSING_FRAME; parse_closing_frame(__parser_info, __buf); event_dispatch(); __waiting_error = WS_PARSE_ERROR; parse_message(__parser_info, __buf, MESSAGE); __waiting_call_count = 3; __waiting_call_info = ERROR_CALL | MESSAGE_CALL; }
int main (int argc, char* argv[]) { errval_t err; init(); struct waitset *ws = get_default_waitset(); while (1) { err = event_dispatch(ws); if (err_is_fail(err)) { DEBUG_ERR(err, "in event_dispatch"); break; } } return EXIT_FAILURE; }
int main(void) { event_init(); CClient *client = new CClient; if( client->open( CONNECT_ADDR, CONNECT_PORT ) < 0 ){ return 0; } struct timeval t; timerclear( &t ); struct event ev; evtimer_set( &ev, oneshot_send, client ); evtimer_add( &ev, &t ); event_dispatch(); return 0; }
int main (int argc, char **argv) { struct event signal_int; /* Initalize the event library */ event_init(); /* Initalize one event */ event_set(&signal_int, SIGINT, EV_SIGNAL|EV_PERSIST, signal_cb, &signal_int); event_add(&signal_int, NULL); event_dispatch(); return (0); }
int create_fildes(const char *path, int mode, struct file *f) { struct fildes *fd = get_free_fildes(); if(fd == NULL) { fd = (struct fildes*)kalloc(sizeof(struct fildes)); fd->fd_num = current_proc->p_nextfd++; add_fildes(fd); } fd->fd_file = f; fd->fd_pos = 0; fd->fd_flags = 0; fd->fd_owner = current_proc; fd->fd_mode = mode; strcpy(fd->fd_name, path); f->f_refs++; event_dispatch(FILDES_OPEN, fd); return fd->fd_num; }
int main(int argc, char *argv[]) { int ch, sfd; char *iface_ip = REGMAILD_ADDR; int as_daemon = 1; Signal(SIGPIPE, SIG_IGN); chdir(BBSHOME); attach_SHM(); /* Give up root privileges: no way back from here */ setgid(BBSGID); setuid(BBSUID); while ( (ch = getopt(argc, argv, "i:hD")) != -1 ) switch( ch ){ case 'i': iface_ip = optarg; break; case 'D': as_daemon = 0; break; case 'h': default: fprintf(stderr, "usage: %s [-D] [-i [interface_ip]:port]\n", argv[0]); return 1; } if ( (sfd = tobind(iface_ip)) < 0 ) return 1; if (as_daemon) daemonize(BBSHOME "/run/regmaild.pid", BBSHOME "/log/regmaild.log"); regmaildb_open(&g_Db, EMAILDB_PATH); reload_unambiguous_user_list(); event_init(); event_set(&ev_listen, sfd, EV_READ | EV_PERSIST, listen_cb, &ev_listen); event_add(&ev_listen, NULL); fprintf(stderr, "start dispatch.\r\n"); event_dispatch(); return 0; }
int main(int argc, char **argv) { struct event evfifo; struct stat st; 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); } socket = open(fifo, O_RDONLY | O_NONBLOCK, 0); if (socket == -1) { perror("open"); exit(1); } fprintf(stderr, "Write data to %s\n", fifo); /* Initialize the event library */ event_init(); /* Initialize one event */ event_set(&evfifo, socket, EV_READ, fifo_read, &evfifo); /* Add it to the active events, without a timeout */ event_add(&evfifo, NULL); event_dispatch(); return 0; }
static errval_t descq_deregister(struct devq* q, regionid_t rid) { errval_t err, err2; err2 = SYS_ERR_OK; struct descq* queue = (struct descq*) q; err = queue->binding->rpc_tx_vtbl.deregister_region(queue->binding, rid, &err2); if (err_is_fail(err)) { queue->resend_args = rid; while(err_is_fail(err)) { err = queue->binding->register_send(queue->binding, get_default_waitset(), MKCONT(try_deregister, queue)); if (err_is_fail(err)) { event_dispatch(get_default_waitset()); } } } return err2; }
//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); }
int main(int argc, char *argv[]) { parse_command_line(argc, argv); main_init(); TRACE(TRACE_DEBUG, "%s", "Entering mainloop\n"); /* Enter our mainloop */ event_dispatch(); while(1) { sleep(100); } main_exit(); TRACE(TRACE_DEBUG, "%s", "leaving mainloop, goodbye!\n"); return 0; }
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"); setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr_on, sizeof(reuseaddr_on)); 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; /* 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; }
//超时事件测试 void timer_test() { // 初始化 base=event_init(); struct event evTime; // 设置定时事件 evtimer_set(&evTime, onTime, &evTime); struct timeval tv; tv.tv_sec = 10; tv.tv_usec = 0; // 添加定时事件 event_add(&evTime, &tv); //设置为base事件 event_base_set(base, &evTime); // 事件调度循环 event_dispatch(); event_base_free(base); }
/* * Closes a file and frees any kernel resources * associated with it * @param fd The file descriptor */ int close(int fd) { struct fildes *f = get_fildes(fd); if(f) { f->fd_file->f_refs--; event_dispatch(FILDES_CLOSE, f); f->fd_flags = F_CLOSED; if(f->fd_file->close != NULL) { f->fd_file->close(f); } if(f->fd_file->f_refs <= 0) { //fclose(f); } } else { return -1; } }
server::server() { int listen_fd; struct sockaddr_in listen_addr; int reuseaddr_on = 1; /* The socket accept event. */ struct event ev_accept; /* Initialize libevent. */ event_init(); /* Create our listening socket. This is largely boiler plate * code that I'll abstract away in the future. */ listen_fd = socket(AF_INET, SOCK_STREAM, 0); if (listen_fd < 0) err(1, "listen failed"); if (setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr_on, sizeof(reuseaddr_on)) == -1) err(1, "setsockopt 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"); /* 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, this->on_accept, NULL); event_add(&ev_accept, NULL); /* Start the libevent event loop. */ event_dispatch(); }
errval_t domain_thread_join(struct thread *thread, int *retval) { coreid_t core_id = thread->coreid; if (disp_get_core_id() == core_id) { return thread_join(thread, retval); } else { struct domain_state *domain_state = get_domain_state(); errval_t err; if (domain_state->b[core_id] == NULL) { return LIB_ERR_NO_SPANNED_DISP; } struct interdisp_binding *b = domain_state->b[core_id]; struct join_thread_req *req = malloc(sizeof(*req)); req->reply_received = false; // use special waitset to make sure loop exits properly. struct waitset ws, *old_ws = b->waitset; waitset_init(&ws); b->change_waitset(b, &ws); err = b->tx_vtbl.join_thread_request(b, NOP_CONT, (genvaddr_t)(lvaddr_t)thread, (genvaddr_t)(lvaddr_t)req); if (err_is_fail(err)) { return err; } while (!req->reply_received) { event_dispatch(&ws); } // change waitset back b->change_waitset(b, old_ws); if (retval) { *retval = req->retval; } err = req->err; free(req); return err; } }
int main() { // ??? event_init(); struct event ev_time; // ?????? evtimer_set(&ev_time, onTime, &ev_time); struct timeval tv; tv.tv_sec = 1; tv.tv_usec = 0; // ?????? event_add(&ev_time, &tv); // ???? event_dispatch(); return 0; }
static void wait_for_lwip(void) { errval_t r; int ans; while ((ans = is_lwip_loaded()) > 0) { // printf("is_lwip_loaded returned %d\n", ans); ++stats[ans]; /* if(ans == 1) { printf("stopping the benchmark as no more pbufs\n"); stop_benchmark(); } */ r = event_dispatch(ws); if (err_is_fail(r)) { DEBUG_ERR(r, "in event_dispatch"); abort(); } } // end while: lwip_loaded ++stats[ans]; } // end function: wait_for_lwip
static void slaves_finalize(void) { int err; /* notify slaves */ for (int sid=0; sid < SlState.num_slaves; sid++) { struct slave *sl = SlState.slaves + sid; do { err = sl->b->tx_vtbl.slave_finish(sl->b, NOP_CONT); } while (err_no(err) == FLOUNDER_ERR_TX_BUSY); assert(err_is_ok(err)); } /* wait for their replies */ do { err = event_dispatch(get_default_waitset()); assert(err_is_ok(err)); } while (SlState.num_finished < SlState.num_slaves); }
static gboolean window_key_pressed(GtkWidget *widget, GdkEventKey *event, gpointer user_data) { gu_window_t *gw = user_data; if(event->keyval == GDK_F12) event_dispatch(event_create_action(ACTION_SWITCH_UI)); if(event->keyval == GDK_F11) { if(gw->gw_fullwindow) { if(gw->gw_fullscreen) { gtk_window_unfullscreen(GTK_WINDOW(gw->gw_window)); } else { gtk_window_fullscreen(GTK_WINDOW(gw->gw_window)); } } } return FALSE; }
int main(int argc, char **argv) { event_init(); struct sockaddr_in sa; struct bufferevent *bev; int fd; unsigned ip; inet_aton("213.248.62.7",&ip); sa.sin_addr = *((struct in_addr *) &ip); sa.sin_family = AF_INET; sa.sin_port = htons(22); bzero(&sa.sin_zero, 8); fd=socket(AF_INET, SOCK_STREAM, 0); setnb(fd); connect(fd, (struct sockaddr *) & sa, sizeof (struct sockaddr)); bev = bufferevent_new(fd, OnBufferedRead, OnBufferedWrite, OnBufferedError, NULL); bufferevent_enable(bev, EV_READ); bufferevent_settimeout(bev,10,10); event_dispatch(); return 0; }
int main(int argc, char const *argv[]) { int node_id; const char* tapioca_config; const char* paxos_config; if (argc != 4) { printf("Usage: %s <node id> <tapioca config> <paxos config>\n", argv[0]); exit(1); } node_id = atoi(argv[1]); tapioca_config = argv[2]; paxos_config = argv[3]; event_init(); http_init(); event_dispatch(); return 0; }
void * urlparser(void *none) { Surl *url = NULL; Url *ourl = NULL; map<string, string>::const_iterator itr; //event_base * base = event_base_new(); //evdns_base * dnsbase = evdns_base_new(base, 1); //event_base_loop(base,EVLOOP_NONBLOCK); while(1) { pthread_mutex_lock(&sq_lock); while (surl_queue.empty()) { pthread_cond_wait(&sq_cond, &sq_lock); } url = surl_queue.front(); surl_queue.pop(); pthread_mutex_unlock(&sq_lock); ourl = surl2ourl(url); itr = host_ip_map.find(ourl->domain); if (itr == host_ip_map.end()) { /* not found */ /* dns resolve */ event_base * base = event_init(); evdns_init(); evdns_resolve_ipv4(ourl->domain, 0, dns_callback, ourl); event_dispatch(); event_base_free(base); //evdns_base_resolve_ipv4(dnsbase, ourl->domain, 0, dns_callback, ourl); //event_base_loop(base, EVLOOP_ONCE | EVLOOP_NONBLOCK); } else { ourl->ip = strdup(itr->second.c_str()); push_ourlqueue(ourl); } } //evdns_base_free(dnsbase, 0); //event_base_free(base); return NULL; }
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(); }
/* * RPC wrapper functions */ static errval_t acpi_get_pcie_confspace__rpc(struct acpi_rpc_client *_rpc, acpi_errval_t *err, uint64_t *address, uint16_t *segment, uint8_t *startbus, uint8_t *endbus) { errval_t _err = SYS_ERR_OK; assert(!(_rpc->rpc_in_progress)); assert((_rpc->async_error) == SYS_ERR_OK); _rpc->rpc_in_progress = true; _rpc->reply_present = false; // call send function _err = ((((_rpc->b)->tx_vtbl).get_pcie_confspace_call)(_rpc->b, NOP_CONT)); if (err_is_fail(_err)) { goto out; } // wait for message to be sent and reply or error to be present while (((!(_rpc->reply_present)) || (!(((_rpc->b)->can_send)(_rpc->b)))) && ((_rpc->async_error) == SYS_ERR_OK)) { _err = event_dispatch(&(_rpc->rpc_waitset)); if (err_is_fail(_err)) { _err = err_push(_err, LIB_ERR_EVENT_DISPATCH); goto out; } } if (err_is_fail(_rpc->async_error)) { _err = (_rpc->async_error); _rpc->async_error = SYS_ERR_OK; goto out; } // grab reply variables out of binding struct acpi_binding *_binding = _rpc->b; *err = (((_binding->rx_union).get_pcie_confspace_response).err); *address = (((_binding->rx_union).get_pcie_confspace_response).address); *segment = (((_binding->rx_union).get_pcie_confspace_response).segment); *startbus = (((_binding->rx_union).get_pcie_confspace_response).startbus); *endbus = (((_binding->rx_union).get_pcie_confspace_response).endbus); out: _rpc->rpc_in_progress = false; return(_err); }
static errval_t usb_manager_transfer_status__rpc(struct usb_manager_rpc_client *_rpc, uint32_t tid, uint32_t *ret_error, uint32_t *ret_actlen, uint32_t *ret_length, uint32_t *ret_actframes, uint32_t *ret_numframes) { errval_t _err = SYS_ERR_OK; assert(!(_rpc->rpc_in_progress)); assert((_rpc->async_error) == SYS_ERR_OK); _rpc->rpc_in_progress = true; _rpc->reply_present = false; // call send function _err = ((((_rpc->b)->tx_vtbl).transfer_status_call)(_rpc->b, NOP_CONT, tid)); if (err_is_fail(_err)) { goto out; } // wait for message to be sent and reply or error to be present while (((!(_rpc->reply_present)) || (!(((_rpc->b)->can_send)(_rpc->b)))) && ((_rpc->async_error) == SYS_ERR_OK)) { _err = event_dispatch(&(_rpc->rpc_waitset)); if (err_is_fail(_err)) { _err = err_push(_err, LIB_ERR_EVENT_DISPATCH); goto out; } } if (err_is_fail(_rpc->async_error)) { _err = (_rpc->async_error); _rpc->async_error = SYS_ERR_OK; goto out; } // grab reply variables out of binding struct usb_manager_binding *_binding = _rpc->b; *ret_error = (((_binding->rx_union).transfer_status_response).ret_error); *ret_actlen = (((_binding->rx_union).transfer_status_response).ret_actlen); *ret_length = (((_binding->rx_union).transfer_status_response).ret_length); *ret_actframes = (((_binding->rx_union).transfer_status_response).ret_actframes); *ret_numframes = (((_binding->rx_union).transfer_status_response).ret_numframes); out: _rpc->rpc_in_progress = false; return(_err); }