コード例 #1
0
ファイル: server.c プロジェクト: abyxcos/MoboRoboSim
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;
}
コード例 #2
0
ファイル: sockets.c プロジェクト: achreto/barrelfish
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;
}
コード例 #3
0
ファイル: regress_http.c プロジェクト: AllanXiang/Source
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");
}
コード例 #4
0
ファイル: regress_http.c プロジェクト: AllanXiang/Source
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");
}
コード例 #5
0
ファイル: regress_bufferevent.c プロジェクト: kjg/libevent
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);

}
コード例 #6
0
ファイル: check_ws_parser.c プロジェクト: iantropov/libws
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;
}
コード例 #7
0
ファイル: xcorecapserv.c プロジェクト: CoryXie/BarrelfishOS
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;

}
コード例 #8
0
ファイル: main.cpp プロジェクト: utahta/sendbuffer-overflow
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;
}
コード例 #9
0
ファイル: signal-test.c プロジェクト: CSU-GH/okl4_3.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);
}
コード例 #10
0
ファイル: fildes.c プロジェクト: GruntTheDivine/infinity
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;
}
コード例 #11
0
ファイル: regmaild.c プロジェクト: OmniBus/hkday-pttbbs
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;
}
コード例 #12
0
ファイル: event-test.c プロジェクト: plding/libevent
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;
}
コード例 #13
0
ファイル: desc_queue.c プロジェクト: BarrelfishOS/barrelfish
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;
}
コード例 #14
0
ファイル: server.c プロジェクト: faggion/sample-codes
//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);
}
コード例 #15
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;
}
コード例 #16
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;
}
コード例 #17
0
ファイル: test.c プロジェクト: weiweikaikai/My_libevent
//超时事件测试
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);
}
コード例 #18
0
ファイル: fildes.c プロジェクト: GruntTheDivine/infinity
/*
 * 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;
    }
}
コード例 #19
0
ファイル: server.cpp プロジェクト: roFilip/COMP8005_A2
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();
}
コード例 #20
0
ファイル: domain.c プロジェクト: MichaelFQuigley/barrelfish
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;
    }
}
コード例 #21
0
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;   
}  
コード例 #22
0
ファイル: udp_test.c プロジェクト: CoryXie/BarrelfishOS
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
コード例 #23
0
ファイル: master.c プロジェクト: huiweics/arrakis
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);
}
コード例 #24
0
ファイル: gu.c プロジェクト: Cy-4AH/showtime
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;
}
コード例 #25
0
ファイル: ssh4.c プロジェクト: kalloc/tester
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;
}
コード例 #26
0
ファイル: tapioca.c プロジェクト: atomic77/mosql-storage
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;
}
コード例 #27
0
ファイル: url.cpp プロジェクト: DennyDL/spiderPro
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;
}
コード例 #28
0
ファイル: event-test2.cpp プロジェクト: feeblefakie/misc
  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();
  }
コード例 #29
0
/*
 * 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);
}
コード例 #30
0
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);
}