示例#1
0
文件: io.c 项目: CPFL/gxen
int libxenvchan_write(struct libxenvchan *ctrl, const void *data, size_t size)
{
	int avail;
	if (!libxenvchan_is_open(ctrl))
		return -1;
	if (ctrl->blocking) {
		size_t pos = 0;
		while (1) {
			avail = fast_get_buffer_space(ctrl, size - pos);
			if (pos + avail > size)
				avail = size - pos;
			if (avail)
				pos += do_send(ctrl, data + pos, avail);
			if (pos == size)
				return pos;
			if (libxenvchan_wait(ctrl))
				return -1;
			if (!libxenvchan_is_open(ctrl))
				return -1;
		}
	} else {
		avail = fast_get_buffer_space(ctrl, size);
		if (size > avail)
			size = avail;
		if (size == 0)
			return 0;
		return do_send(ctrl, data, size);
	}
}
示例#2
0
int libvchan_wait(libvchan_t *ctrl) {
    int ret = -2; /* invalid, so can be distinguished from real
                     libxenvchan_wait return code */
    struct xs_handle *xs;

    if (ctrl->xenvchan->is_server && libxenvchan_is_open(ctrl->xenvchan) == 2) {
        /* In case of vchan server waiting for a client, we'll not receive any
         * notification if the remote domain dies before connecting. Because of
         * that, check periodically if remote domain is still alive while
         * waiting for a connection. Actually this doesn't cover all the cases
         * - if remote domain is still alive, but remote process dies before
         * connecting, we'll also not receive any notification. But this, in
         * most cases, can be solved by application using libvchan.
         *
         * During normal operation this shouldn't be long - in most cases vchan
         * client will connect almost instantly. So this sleep(10) loop will
         * not hurt. Alternativelly it could be implemented with
         * xs_watch("@releaseDomain"), but such approach will slow down most
         * common execution path (xs_open+xs_watch even if client connects
         * right away).
         */
        while (ret == -2 && libxenvchan_is_open(ctrl->xenvchan) == 2) {
            fd_set rd_set;
            struct timeval tv = { 10, 0 };
            int vchan_fd = libxenvchan_fd_for_select(ctrl->xenvchan);
            FD_ZERO(&rd_set);
            FD_SET(vchan_fd, &rd_set);
            switch (select(vchan_fd+1, &rd_set, NULL, NULL, &tv)) {
                case 0:
                    if (!libvchan__check_domain_alive(ctrl->xc_handle, ctrl->remote_domain))
                        return -1;
                    break;
                case 1:
                    /* break the loop */
                    ret = -1;
                    break;
                default:
                    if (errno == EINTR)
                        break;
                    perror("select");
                    return -1;
            }
        }
    }
    ret = libxenvchan_wait(ctrl->xenvchan);
    if (ctrl->xs_path) {
        /* remove xenstore entry at first client connection */
        xs = xs_open(0);
        if (xs) {
            /* if xenstore connection failed just do not remove entries, but do
             * not abort whole function, especially still free the memory
             */
            xs_rm(xs, 0, ctrl->xs_path);
            xs_close(xs);
        }
        free(ctrl->xs_path);
        ctrl->xs_path = NULL;
    }
    return ret;
}
示例#3
0
void receiveForever(struct libxenvchan *chan){
  int size;
  char * msg;
  int i = 0;

  while(1){ 
    libxenvchan_wait(chan);
    msg = vchan_receive(chan,&size);
    printf("Received: ");
    for(i = 0; i< size; i++){
      printf("%c",msg[i]);
    }
     printf("\n");
  }

}
示例#4
0
文件: io.c 项目: CPFL/gxen
int libxenvchan_read(struct libxenvchan *ctrl, void *data, size_t size)
{
	while (1) {
		int avail = fast_get_data_ready(ctrl, size);
		if (avail && size > avail)
			size = avail;
		if (avail)
			return do_recv(ctrl, data, size);
		if (!libxenvchan_is_open(ctrl))
			return -1;
		if (!ctrl->blocking)
			return 0;
		if (libxenvchan_wait(ctrl))
			return -1;
	}
}
示例#5
0
文件: io.c 项目: CPFL/gxen
/**
 * returns 0 if no buffer space is available, -1 on error, or size on success
 */
int libxenvchan_send(struct libxenvchan *ctrl, const void *data, size_t size)
{
	int avail;
	while (1) {
		if (!libxenvchan_is_open(ctrl))
			return -1;
		avail = fast_get_buffer_space(ctrl, size);
		if (size <= avail)
			return do_send(ctrl, data, size);
		if (!ctrl->blocking)
			return 0;
		if (size > wr_ring_size(ctrl))
			return -1;
		if (libxenvchan_wait(ctrl))
			return -1;
	}
}
示例#6
0
int main(int argc, char *argv[])
{

	//Vchan Prep
	struct libxenvchan *chan = 0;
	int selfId; // domainID of this node;
	int otherId;
	int client= 0;
	 xentoollog_logger_stdiostream * xc_logger;

  	xc_logger = createDebugLogger();

	selfId =getDomId();
	fprintf(stdout,"Client: Domain Id: %d\n", selfId);

	if(argc != 3){
		fprintf(stderr,"Error: Usage ./Client [server-0, client-1] [other domId]\n");
		exit(1);
	}  

	sscanf(argv[1],"%d",&client);
	sscanf(argv[2],"%d",&otherId);

	if (!client){
    		chan = vchan_server_init((xentoollog_logger *) xc_logger,otherId);
  	}else{
     		chan = vchan_client_init((xentoollog_logger *)xc_logger, otherId);
  	}



	//Sockets Prep

	int listenfd = 0, connfd = 0;
	struct sockaddr_in serv_addr; 
	char recvBuff[1024];
	int n = 0;

	char sendBuff[1024];
	time_t ticks; 

	listenfd = socket(AF_INET, SOCK_STREAM, 0);
	memset(&serv_addr, '0', sizeof(serv_addr));
	memset(sendBuff, '0', sizeof(sendBuff)); 

	serv_addr.sin_family = AF_INET;
	serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	serv_addr.sin_port = htons(5000); 

	bind(listenfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)); 

	printf("\n Waiting for a client...\n");
	listen(listenfd, 10); 
	printf("\n 1\n");

	while(1)
	{
	printf("\n 2\n");
		connfd = accept(listenfd, (struct sockaddr*)NULL, NULL); 
	printf("\n 3\n");

		ticks = time(NULL);

		while(1)
		{


			//GET REQUEST
			printf("Waiting for request from Attester\n");
			int size;
			char * msg;
			int i = 0;

			libxenvchan_wait(chan);
			msg = vchan_receive(chan,&size);
			printf("Received: ");
			for(i = 0; i< size; i++){
				printf("%c",msg[i]);
			}
			printf("\n");

			//ISSUE REQUEST
			printf("Sending request message to Measurer\nsent: ");

			memset(sendBuff, 0, sizeof(sendBuff));
			snprintf(sendBuff, sizeof(sendBuff), msg);
			if(fputs(sendBuff, stdout) == EOF)
			{
	    			printf("\n Error : Fputs error\n");
			} 
			write(connfd, sendBuff, sizeof(sendBuff)); 

			//GET RESPONSE
			printf("Waiting for response from Measurer\n");

			n = read(connfd, recvBuff, sizeof(recvBuff));
			recvBuff[n] = 0;
			if(fputs(recvBuff, stdout) == EOF)
			{
				printf("\n Error : Fputs error\n");
			} 

			if(n < 0)
			{
				printf("\n Read error \n");
			} 

			//SEND RESPONSE TO ATTESTER
			printf("Sending response to Attester\n");
			//char * tmp = (char *) malloc(256 * sizeof(char));
		     	//printf("Enter text to send:\n");
		     	//fgets(tmp, 256, stdin);
		     	vchan_send(chan,recvBuff, strlen(recvBuff)); 

		}

		close(connfd);
		sleep(1);
	}
}