Beispiel #1
0
int main(int argc, char *argv[])
{
    struct winsize ws;
    int ret, c, socket = 0, show_perm = 0;
    struct xs_handle *xsh;

#define PAD 2

    memset(&ws, 0, sizeof(ws));
    ret = ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws);
    if (!ret)
        max_width = ws.ws_col - PAD;

    while (0 < (c = getopt(argc, argv, "pswf"))) {
        switch (c) {
        case 'w':
            max_width= STRING_MAX - PAD;
            desired_width = 0;
            break;
        case 'p':
            show_perm = 1;
            break;
        case 's':
            socket = 1;
            break;
        case 'f':
            max_width = INT_MAX/2;
            desired_width = 0;
            show_whole_path = 1;
            break;
        case ':':
        case '?':
        default:
            usage(argc, argv);
            return 0;
        }
    }

    /* Adjust the width here to avoid argument order dependency */
    if ( show_perm ) {
        max_width -= 16;
    }

    xsh = socket ? xs_daemon_open() : xs_domain_open();
    if (xsh == NULL)
        err(1, socket ? "xs_daemon_open" : "xs_domain_open");

    print_dir(xsh, (argc - optind) == 1 ? argv[optind] : "/", 0, show_perm);

    return 0;
}
Beispiel #2
0
static DWORD WINAPI
thread_func(PVOID _ident)
{
    int ident;
    HANDLE h;
    int x;
    char path[4096], buf[2000];
    char *t;
    size_t l;

    ident = (int)(ULONG_PTR)_ident;
    h = xs_domain_open();
    if (!h) win_err(1, "thread %d can't start", ident);

    sprintf(path, "data/test/thread%d", ident);
    for (x = 0; x < 5000; x++) {
        if ( (ident + x) % 256 == 0)
            memset(buf, 1, sizeof(buf));
        else
            memset(buf, ident + x, sizeof(buf));
        buf[sizeof(buf)-1] = 0;
        if (!xs_write(h, path, buf))
            fail_test(__LINE__, "thread %d pass %d", ident, x);
        t = xs_read(h, path, &l);
        if (!t) {
            if (GetLastError() == ERROR_FILE_NOT_FOUND) {
                printf("ERROR_NOT_FOUND, did the VM get suspended?\n");
            } else {
                fail_test(__LINE__, "thread %d pass %d (%d)", ident, x,
                          GetLastError());
            }
        } else {
            if (l != sizeof(buf)-1)
                fail_test(__LINE__, "thread %d pass %d (%d, %d)", ident, x,
                          l, sizeof(buf)-1);
            if (strcmp(buf, t))
                fail_test(__LINE__, "thread %d pass %d", ident, x);
            free(t);
        }
    }

    xs_daemon_close(h);

    return 0;
}
Beispiel #3
0
int get_memory_size (xa_instance_t *instance)
{
    int ret = XA_SUCCESS;

    if (XA_MODE_XEN == instance->mode){
#ifdef ENABLE_XEN
        struct xs_handle *xsh = NULL;
        xs_transaction_t xth = XBT_NULL;
        char *tmp = malloc(100);
        if (NULL == tmp){
            fprintf(stderr, "ERROR: failed to allocate memory for tmp variable\n");
            ret = XA_FAILURE;
            goto error_exit;
        }
        memset(tmp, 0, 100);
        sprintf(tmp, "/local/domain/%d/memory/target",
            instance->m.xen.domain_id);
        xsh = xs_domain_open();
        instance->m.xen.size =
            strtol(xs_read(xsh, xth, tmp, NULL), NULL, 10) * 1024;
        if (0 == instance->m.xen.size){
            fprintf(stderr, "ERROR: failed to get memory size for Xen domain.\n");
            ret = XA_FAILURE;
            goto error_exit;
        }
        xa_dbprint("**set instance->m.xen.size = %d\n", instance->m.xen.size);
        if (xsh) xs_daemon_close(xsh);
#endif /* ENABLE_XEN */
    }
    else if (XA_MODE_FILE == instance->mode){
        struct stat s;

        if (fstat(fileno(instance->m.file.fhandle), &s) == -1){
            fprintf(stderr, "ERROR: Failed to stat file\n");
            ret = XA_FAILURE;
            goto error_exit;
        }
        instance->m.file.size = (uint32_t) s.st_size;
        xa_dbprint("**set instance->m.file.size = %d\n", instance->m.file.size);
    }

error_exit:
    return ret;
}
Beispiel #4
0
Datei: init.c Projekt: Fantu/Xen
static int init_xs_srv(struct libxenvchan *ctrl, int domain, const char* xs_base, int ring_ref)
{
	int ret = -1;
	struct xs_handle *xs;
	struct xs_permissions perms[2];
	char buf[64];
	char ref[16];
	char* domid_str = NULL;
	xs = xs_domain_open();
	if (!xs)
		goto fail;
	domid_str = xs_read(xs, 0, "domid", NULL);
	if (!domid_str)
		goto fail_xs_open;

	// owner domain is us
	perms[0].id = atoi(domid_str);
	// permissions for domains not listed = none
	perms[0].perms = XS_PERM_NONE;
	// other domains
	perms[1].id = domain;
	perms[1].perms = XS_PERM_READ;

	snprintf(ref, sizeof ref, "%d", ring_ref);
	snprintf(buf, sizeof buf, "%s/ring-ref", xs_base);
	if (!xs_write(xs, 0, buf, ref, strlen(ref)))
		goto fail_xs_open;
	if (!xs_set_permissions(xs, 0, buf, perms, 2))
		goto fail_xs_open;

	snprintf(ref, sizeof ref, "%d", ctrl->event_port);
	snprintf(buf, sizeof buf, "%s/event-channel", xs_base);
	if (!xs_write(xs, 0, buf, ref, strlen(ref)))
		goto fail_xs_open;
	if (!xs_set_permissions(xs, 0, buf, perms, 2))
		goto fail_xs_open;

	ret = 0;
 fail_xs_open:
	free(domid_str);
	xs_daemon_close(xs);
 fail:
	return ret;
}
Beispiel #5
0
static int get_dom_id()
{
    struct xs_handle *xsh = NULL;
    char *domid = NULL;
    int domID = -1;
    unsigned int len;

    xsh = xs_domain_open();
    if (xsh == NULL) {
        libmsg("xs_domain_open: cannot open xenstore\n");
        return -1;
    }
    domid = xs_read(xsh, XBT_NULL, "domid", &len);
    if (domid) {
        domID = atoi(domid);
        free(domid);
    }

    return domID;
}
int
xenstore_init(void)
{
	unsigned int len, domid;
	char *buf;
	char *end;

	xs = xs_domain_open();
	if (xs == NULL) {
		RTE_LOG(ERR, PMD,"%s: xs_domain_open failed\n", __func__);
		return -1;
	}
	buf = xs_read(xs, XBT_NULL, "domid", &len);
	if (buf == NULL) {
		RTE_LOG(ERR, PMD, "%s: failed read domid\n", __func__);
		return -1;
	}
	errno = 0;
	domid = strtoul(buf, &end, 0);
	if (errno != 0 || end == NULL || end == buf ||  domid == 0)
		return -1;

	RTE_LOG(INFO, PMD, "retrieved dom ID = %d\n", domid);

	dompath = xs_get_domain_path(xs, domid);
	if (dompath == NULL)
		return -1;

	xs_transaction_start(xs); /* When to stop transaction */

	if (is_xenstore_cleaned_up == 0) {
		if (xenstore_cleanup())
			return -1;
		is_xenstore_cleaned_up = 1;
	}

	return 0;
}
Beispiel #7
0
main(int argc, char **argv)
{
	struct xs_handle *xs;
	unsigned int count;
	char **vec;
	char dummy;
	if (argc != 2) {
		fprintf(stderr, "usage: %s xenstore_path\n", argv[0]);
		exit(1);
	}
	xs = xs_domain_open();
	if (!xs) {
		perror("xs_domain_open");
		exit(1);
	}
	if (!xs_watch(xs, argv[1], &dummy)) {
		perror("xs_watch");
		exit(1);
	}
	vec = xs_read_watch(xs, &count);
	free(vec);
	vec = xs_read_watch(xs, &count);
	free(vec);
}
Beispiel #8
0
main(
int argc, char **argv)
{

	vxt_db_start_arg_t         start_db_args;
	struct xs_handle *xs;
	char    token;
	char   **vec;
	char   *tail;
	int    ret;
	int    parse_result;
	int    num;
	int    domid;
	int    auth_dev;
	fd_set set;
	int    fd;
	char   target_uuid[MAX_VXT_UUID] = " ";
	int is_provision = 0;

	if (daemon(0, 0) < 0) {
		perror("daemon");
	}

	auth_dev = open(VXT_AUTH_DEVICE_NAME, O_RDWR);
	if(auth_dev < 0) {
		printf("main: Failed to open the Vxt authorization" 
		       " database device\n");
	}

	/*
	 * Start the database if it hasn't already been 
	 * started
	 */
	
	strncpy(start_db_args.db_file_name,
	        VXT_DB_DEFAULT_FILE_NAME, VXT_DB_NAME_MAX);
	
	ioctl(auth_dev, VXT_AUTH_DB_START, (void *)(long)&start_db_args);


	/* printf("The domain device %s\n", xs_domain_dev()); */
	xs = xs_domain_open();
	if (!xs) {
		perror("xs_domain_open failure");
		exit(1);
	}

	ret = xs_watch(xs,  "/vm", "vxtToken");
	if (ret == 0) {
		perror("xs_watch failed\n");
		exit(1);
	}

	fd = xs_fileno(xs);

	while (1) {

		FD_ZERO(&set);
		FD_SET(fd, &set);

		/* 
		 * Poll for data 
		 * printf("Poll for data, 0x%x\n", fd);
		 */
		if ((ret = select(fd+1, &set, NULL, NULL, NULL)) >= 0) {
			/* printf("Watch point triggered ret = 0x%x\n", ret); */
			vec = xs_read_watch(xs, &num);
			printf("\n after read watch ");
			if (!vec) error();

			parse_result =
			   xsd_vm_name(vec[XS_WATCH_PATH], target_uuid);

			if (parse_result == 1) {
				char **list;
			  	char path[64];
				int  entry_cnt;
				int  i;
				/*
				 * get a list of all the domain ids, 
				 * then check the name of each one
				 * to find the id for the specified domain
				 */
				list = xs_directory(xs, XBT_NULL,
				                    "/local/domain",
				                    &entry_cnt);
				for (i = (entry_cnt-1); i > 0; i--) {
					char *rec_uuid;
					sprintf(path,
					        "/local/domain/%s/vm",
						list[i]);
					rec_uuid = xs_read(xs, XBT_NULL,
					                   path, NULL);
					if ( rec_uuid == NULL ) {
						continue;
					}
					if (strcmp(&(rec_uuid[4]),
					           target_uuid) == 0) {
						free(rec_uuid);
						domid = atoi(list[i]);
						break;
					}
					free(rec_uuid);
				}
				free(list);
				if (i == 0) {
					free(vec);
					continue;
				}
	

				xsd_write_auth_record(auth_dev, target_uuid);
				/* 
				printf("main: call vxt_auth_db on uuid = %s\n",
				       target_uuid);
				*/

				xsd_provision_controller(xs, domid);
				is_provision = 1;
				update_vm_state(target_uuid, is_provision);

			} else if (parse_result == 2) {
				/* treating this case as deprovision */
				is_provision = 0;
				update_vm_state(target_uuid, is_provision);
			} else {
				/* target_uuid is undefined
				 * don't call update_vm_state
				 */
			}
			free(vec);
		} else {
			break;
		}
	}

	printf("returned from xs_watch, xenstore exited\n");

}
Beispiel #9
0
int read_config_file (xa_instance_t *instance)
{
    extern FILE *yyin;
    int ret = XA_SUCCESS;
    xa_config_entry_t *entry;
#ifdef ENABLE_XEN
    struct xs_handle *xsh = NULL;
    xs_transaction_t xth = XBT_NULL;
#endif /* ENABLE_XEN */
    char *tmp = NULL;

    yyin = fopen("/etc/xenaccess.conf", "r");
    if (NULL == yyin){
        fprintf(stderr, "ERROR: config file not found at /etc/xenaccess.conf\n");
        ret = XA_FAILURE;
        goto error_exit;
    }

    /* convert domain id to domain name for Xen mode */
    if (XA_MODE_XEN == instance->mode){
#ifdef ENABLE_XEN
        tmp = malloc(100);
        if (NULL == tmp){
            fprintf(stderr, "ERROR: failed to allocate memory for tmp variable\n");
            ret = XA_FAILURE;
            goto error_exit;
        }
        memset(tmp, 0, 100);
        sprintf(tmp, "/local/domain/%d/name", instance->m.xen.domain_id);
        xsh = xs_domain_open();
        instance->image_type = xs_read(xsh, xth, tmp, NULL);
        if (NULL == instance->image_type){
            fprintf(stderr, "ERROR: domain id %d is not running\n",
                    instance->m.xen.domain_id);
            ret = XA_FAILURE;
            goto error_exit;
        }
        xa_dbprint("--got domain name from id (%d ==> %s).\n",
                    instance->m.xen.domain_id, instance->image_type);
#endif /* ENABLE_XEN */
    }

    if (xa_parse_config(instance->image_type)){
        fprintf(stderr, "ERROR: failed to read config file\n");
        ret = XA_FAILURE;
        goto error_exit;
    }
    entry = xa_get_config();

    /* copy the values from entry into instance struct */
    instance->sysmap = strdup(entry->sysmap);
    xa_dbprint("--got sysmap from config (%s).\n", instance->sysmap);
    
    if (strncmp(entry->ostype, "Linux", CONFIG_STR_LENGTH) == 0){
        instance->os_type = XA_OS_LINUX;
    }
    else if (strncmp(entry->ostype, "Windows", CONFIG_STR_LENGTH) == 0){
        instance->os_type = XA_OS_WINDOWS;
    }
    else{
        fprintf(stderr, "ERROR: Unknown or undefined OS type.\n");
        ret = XA_FAILURE;
        goto error_exit;
    }

    /* Copy config info based on OS type */
    if(XA_OS_LINUX == instance->os_type){
	    xa_dbprint("--reading in linux offsets from config file.\n");
        if(entry->offsets.linux_offsets.tasks){
            instance->os.linux_instance.tasks_offset =
                 entry->offsets.linux_offsets.tasks;
        }

        if(entry->offsets.linux_offsets.mm){
            instance->os.linux_instance.mm_offset =
                entry->offsets.linux_offsets.mm;
        }

        if(entry->offsets.linux_offsets.pid){
            instance->os.linux_instance.pid_offset =
                entry->offsets.linux_offsets.pid;
        }

        if(entry->offsets.linux_offsets.pgd){
            instance->os.linux_instance.pgd_offset =
                entry->offsets.linux_offsets.pgd;
        }

        if(entry->offsets.linux_offsets.addr){
            instance->os.linux_instance.addr_offset =
                entry->offsets.linux_offsets.addr;
        }
    }
    else if (XA_OS_WINDOWS == instance->os_type){
	    xa_dbprint("--reading in windows offsets from config file.\n");
        if(entry->offsets.windows_offsets.ntoskrnl){
          instance->os.windows_instance.ntoskrnl =
                entry->offsets.windows_offsets.ntoskrnl;
        }

        if(entry->offsets.windows_offsets.tasks){
            instance->os.windows_instance.tasks_offset =
                entry->offsets.windows_offsets.tasks;
        }

        if(entry->offsets.windows_offsets.pdbase){ 
            instance->os.windows_instance.pdbase_offset =
                entry->offsets.windows_offsets.pdbase;
        }

        if(entry->offsets.windows_offsets.pid){
            instance->os.windows_instance.pid_offset =
                entry->offsets.windows_offsets.pid;
        }

        if(entry->offsets.windows_offsets.peb){
            instance->os.windows_instance.peb_offset =
                entry->offsets.windows_offsets.peb;
        }

        if(entry->offsets.windows_offsets.iba){
            instance->os.windows_instance.iba_offset =
                entry->offsets.windows_offsets.iba;
        }

        if(entry->offsets.windows_offsets.ph){
            instance->os.windows_instance.ph_offset =
                entry->offsets.windows_offsets.ph;
        }
    }

#ifdef XA_DEBUG
    xa_dbprint("--got ostype from config (%s).\n", entry->ostype);
    if (instance->os_type == XA_OS_LINUX){
        xa_dbprint("**set instance->os_type to Linux.\n");
    }
    else if (instance->os_type == XA_OS_WINDOWS){
        xa_dbprint("**set instance->os_type to Windows.\n");
    }
    else{
        xa_dbprint("**set instance->os_type to unknown.\n");
    }
#endif

error_exit:
    if (tmp) free(tmp);
    if (yyin) fclose(yyin);
#ifdef ENABLE_XEN
    if (xsh) xs_daemon_close(xsh);
#endif /* ENABLE_XEN */

    return ret;
}
Beispiel #10
0
int main()
{
    int listensock, clientsock;
    struct sockaddr_in name;
    struct sockaddr_in clientname;
    int size;
    int pid;
    int opt;

    signal(SIGCHLD, sigchl_handler);
    xs = xs_domain_open();
    if (!xs) {
        perror("xs_domain_open");
        exit (EXIT_FAILURE);
    }
#if V4V
    listensock = socket(PF_XENV4V, SOCK_STREAM, 0);
#else
    listensock = socket(PF_INET, SOCK_STREAM, 0);
#endif
    if (listensock < 0) {
	perror ("socket");
	exit (EXIT_FAILURE);
    }

    name.sin_family = AF_INET;
    name.sin_port = htons(PORT);
    name.sin_addr.s_addr = htonl(INADDR_ANY);

    opt=1;
    setsockopt(listensock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));

#if !V4V
    if (setsockopt(listensock, SOL_SOCKET, SO_BINDTODEVICE, &interface, strlen(interface))) {
        perror ("setsockopt(SO_BINDTODEVICE)");
	exit (EXIT_FAILURE);
    }
#endif

    if (bind(listensock, (struct sockaddr *)&name, sizeof(name)) < 0) {
	perror ("bind");
	exit (EXIT_FAILURE);
    }

    if (listen(listensock, 1) < 0) {
	perror("listen");
	exit(EXIT_FAILURE);
    }

    while (1) {
	size = sizeof(clientname);
	clientsock = accept(listensock,
			    (struct sockaddr *) &clientname,
			    &size);
	if (clientsock<0) {
	    if (errno == EAGAIN) {
		fprintf(stderr, "Interrupted\n");
		continue;
	    }
	    perror("accept");
	    exit(EXIT_FAILURE);
	}

	pid = fork();
	if (pid < 0) {
	    perror("fork");
	    exit(EXIT_FAILURE);
	} else if (pid == 0) {
	    doit(clientsock);
	    exit(0);
	} else {
	    close(clientsock);
	    dprintf("Spawned pid %d for connection from %s:%d\n",
		    pid, inet_ntoa(clientname.sin_addr), ntohs(clientname.sin_port));
	}
    }
}
Beispiel #11
0
Datei: init.c Projekt: Fantu/Xen
struct libxenvchan *libxenvchan_client_init(xentoollog_logger *logger, int domain, const char* xs_path)
{
	struct libxenvchan *ctrl = malloc(sizeof(struct libxenvchan));
	struct xs_handle *xs = NULL;
	char buf[64];
	char *ref;
	int ring_ref;
	unsigned int len;

	if (!ctrl)
		return 0;
	ctrl->ring = NULL;
	ctrl->event = NULL;
	ctrl->gnttab = NULL;
	ctrl->write.order = ctrl->read.order = 0;
	ctrl->is_server = 0;

	xs = xs_daemon_open();
	if (!xs)
		xs = xs_domain_open();
	if (!xs)
		goto fail;

// find xenstore entry
	snprintf(buf, sizeof buf, "%s/ring-ref", xs_path);
	ref = xs_read(xs, 0, buf, &len);
	if (!ref)
		goto fail;
	ring_ref = atoi(ref);
	free(ref);
	if (!ring_ref)
		goto fail;
	snprintf(buf, sizeof buf, "%s/event-channel", xs_path);
	ref = xs_read(xs, 0, buf, &len);
	if (!ref)
		goto fail;
	ctrl->event_port = atoi(ref);
	free(ref);
	if (!ctrl->event_port)
		goto fail;

	ctrl->gnttab = xc_gnttab_open(logger, 0);
	if (!ctrl->gnttab)
		goto fail;

// set up event channel
	if (init_evt_cli(ctrl, domain, logger))
		goto fail;

// set up shared page(s)
	if (init_gnt_cli(ctrl, domain, ring_ref))
		goto fail;

	ctrl->ring->cli_live = 1;
	ctrl->ring->srv_notify = VCHAN_NOTIFY_WRITE;

 out:
	if (xs)
		xs_daemon_close(xs);
	return ctrl;
 fail:
	libxenvchan_close(ctrl);
	ctrl = NULL;
	goto out;
}
Beispiel #12
0
int pa__init(pa_module*m) {

    struct userdata *u;
    pa_modargs *ma;
    pa_sink_new_data data;
    int backend_state;
    int ret;
    char strbuf[100];

    pa_assert(m);

    if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
        pa_log("Failed to parse module arguments.");
        goto fail;
    }

    ss = m->core->default_sample_spec;
    map = m->core->default_channel_map;

    /* user arguments override these */
    if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_DEFAULT) < 0) {
        pa_log("Invalid sample format specification or channel map");
        return 1;
    }

    /* Xen Basic init */
    xsh = xs_domain_open();
    if (xsh==NULL) {
        pa_log("xs_domain_open failed");
        goto fail;
    }
    set_state(XenbusStateUnknown);

    xch = xc_interface_open(NULL, NULL, 0);
    if (xch==0) {
        pa_log("xc_interface_open failed");
        goto fail;
    }

    xce = xc_evtchn_open(NULL, 0);
    if (xce==0) {
        pa_log("xc_evtchn_open failed");
        goto fail;
    }

    /* use only dom0 as the backend for now */
    xen_evtchn_port = xc_evtchn_bind_unbound_port(xce, 0);
    if (xen_evtchn_port == 0) {
        pa_log("xc_evtchn_bind_unbound_port failed");
    }

    /* get grant reference & map locally */
    if (alloc_gref(&gref, (void**)&ioring)) {
       pa_log("alloc_gref failed");
    };
    device_id = 0; /* hardcoded for now */

    if (register_backend_state_watch()) {
        pa_log("Xen sink: register xenstore watch failed");
    };

    publish_param_int("event-channel", xen_evtchn_port);
    publish_param_int("ring-ref", gref.gref_ids[0]);

    /* let's ask for something absurd and deal with rejection */
    ss.rate = 192000;

    publish_spec(&ss);

    ret=0;
    while (!ret) {
        backend_state = wait_for_backend_state_change();
        if (backend_state == STATE_UNDEFINED) {
            pa_log("Xen Backend is taking long to respond, still waiting...");
            continue;
        } else if (backend_state == -1) {
            pa_log("Error while waiting for backend: %s", strerror(errno));
            break;
            goto fail;
        }
        ret = state_callbacks[backend_state]();
    }
    if (ret!=NEGOTIATION_OK) {
        pa_log("Negotiation with Xen backend failed!");
        return 1;
    }

    pa_sample_spec_snprint(strbuf, 100, &ss);
    pa_log_debug("Negotiation ended, the result was: %s", strbuf);

    /* End of Phase 2, begin playback cycle */

    u = pa_xnew0(struct userdata, 1);
    u->core = m->core;
    u->module = m;
    m->userdata = u;
    pa_memchunk_reset(&u->memchunk);
    u->rtpoll = pa_rtpoll_new();
    pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
    u->write_type = 0;

    /* init ring buffer */
    ioring->prod_indx = ioring->cons_indx = 0;
    ioring->usable_buffer_space = BUFSIZE - BUFSIZE % pa_frame_size(&ss);

    pa_sink_new_data_init(&data);
    data.driver = __FILE__;
    data.module = m;
    pa_sink_new_data_set_name(&data, pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME));
    pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, "xensink");
    pa_proplist_setf(data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Xen PV audio sink");
    pa_sink_new_data_set_sample_spec(&data, &ss);
    pa_sink_new_data_set_channel_map(&data, &map);

    if (pa_modargs_get_proplist(ma, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
        pa_log("Invalid properties");
        pa_sink_new_data_done(&data);
        goto fail;
    }

    u->sink = pa_sink_new(m->core, &data, PA_SINK_LATENCY);
    pa_sink_new_data_done(&data);

    if (!u->sink) {
        pa_log("Failed to create sink.");
        goto fail;
    }

    u->sink->parent.process_msg = sink_process_msg;
    u->sink->userdata = u;

    pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
    pa_sink_set_rtpoll(u->sink, u->rtpoll);
    pa_sink_set_max_request(u->sink, ioring->usable_buffer_space);
    pa_sink_set_fixed_latency(u->sink, pa_bytes_to_usec(ioring->usable_buffer_space, &u->sink->sample_spec));

    u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1);

    if (!(u->thread = pa_thread_new("xenpv-sink", thread_func, u))) {
        pa_log("Failed to create thread.");
        goto fail;
    }

    pa_sink_put(u->sink);

    pa_modargs_free(ma);

    return 0;

fail:
    if (ma)
        pa_modargs_free(ma);

    pa__done(m);

    return -1;
}
Beispiel #13
0
int
main (int argc, char **argv)
{
  int i;
  struct xs_handle *xs;
  xs_transaction_t th;
  char *path;
  int fd;
  fd_set set;
  int er;
  char **vec;
  unsigned int num_strings;
  char * buf;
  unsigned int len;
  char *program;
  char **arguments;
  int arguments_count;
  pid_t pid;
  int j;
  char *last_value = NULL;
  int status;

  program_name = argv[0];

  i = decode_switches (argc, argv);
  
  if (argc - i < 1)
    usage(1);
  
  path = argv[i++];
  if (argc - i > 0)
  {
    program = argv[i++];
    arguments_count = argc - i;
    
    arguments = malloc(sizeof(char*) * (argc - i + 2));
    arguments[0] = program;
    for (j=0; j<arguments_count; j++)
      arguments[j + 1] = argv[i + j];
    arguments[j + 1] = NULL;
  } else
  {
    program = NULL;
    arguments = NULL;
    arguments_count = 0;
  }
  
  if (want_verbose) {
    printf("Path: %s\n", path);
    if (program)
    {
      printf("Program: %s", program);
      for (i=1; i<arguments_count + 1; i++)
        printf(" %s", arguments[i]);
      printf("\n");
    }
  }
  
  /* Get a connection to the daemon */
  xs = xs_daemon_open();
  if ( xs == NULL ) xs = xs_domain_open();
  if ( xs == NULL ) {
    error("Unable to connect to XenStore");
    exit(1);
  }

  /* Create a watch on /local/domain/0/mynode. */
  er = xs_watch(xs, path, "token");
  if ( er == 0 ) {
    error("Unable to create watch");
    exit(1);
  }

  /* We are notified of read availability on the watch via the
   * file descriptor.
   */
  fd = xs_fileno(xs);
  while (1)
  {
    FD_ZERO(&set);
    FD_SET(fd, &set);
    /* Poll for data. */
    if ( select(fd + 1, &set, NULL, NULL, NULL) > 0
         && FD_ISSET(fd, &set))
    {
      /* num_strings will be set to the number of elements in vec
       * (typically, 2 - the watched path and the token) */
      vec = xs_read_watch(xs, &num_strings);
      if ( !vec ) {
        error("Unable to read watch");
        continue;
      }
      if (want_verbose)
        printf("Path changed: %s\n", vec[XS_WATCH_PATH]);
      /* Prepare a transaction and do a read. */
      th = xs_transaction_start(xs);
      buf = xs_read(xs, th, vec[XS_WATCH_PATH], &len);
      xs_transaction_end(xs, th, false);
      if (buf)
      {
        if (last_value && strcmp(buf, last_value) == 0) {
          if (want_verbose)
            printf("Value did not change\n");
          continue;
        }
      
        if (want_verbose)
          printf("New value: %s\n", buf);
          
        if (program) {
          pid = fork();
          if (pid == 0) {
            setenv("XENSTORE_WATCH_PATH", vec[XS_WATCH_PATH], 1);
            setenv("XENSTORE_WATCH_VALUE", buf, 1);
            for (i=0; arguments[i]; i++) {
              if (strcmp(arguments[i], "%v") == 0)
                arguments[i] = buf;
              else if (strcmp(arguments[i], "%p") == 0)
                arguments[i] = vec[XS_WATCH_PATH];
            }
            execvp(program, arguments);
            error("Unable to start program");
            exit(1);
          } else {
            waitpid(pid, &status, 0);
          }
        } else {
          if (!want_verbose)
            printf("%s\n", buf);
        }
        
        if (last_value)
          free(last_value);
        last_value = buf;
      }
    }
  }
  /* Cleanup */
  close(fd);
  xs_daemon_close(xs);
  free(path);

  exit(0);
}
Beispiel #14
0
int __cdecl
main()
{
    char *vm_path, *uuid, *t;
    size_t l;
    char **contents;
    unsigned count;
    HANDLE xs_handle2;
    HANDLE event;
    HANDLE event2;
    int watch_h;
    int watch_h2;
    int i;
    DWORD status;

    xs_handle = xs_domain_open();
    if (!xs_handle)
        win_err(1, "openning xenstore interface");

    /* Try to give ourselves a clean place to start */
    xs_remove(xs_handle, "data/test");

    /* Check basic xenstore reads with relative path... */
    vm_path = xs_read(xs_handle, "vm", NULL);
    if (!vm_path)
        win_err(1, "reading vm path");
    if (vm_path[0] != '/') {
        fail_test(__LINE__, "expected vm path to be absolute, got %s",
                  vm_path);
    }

    /* and with an absolute path. */
    uuid = gather_read(&l, vm_path, "uuid", NULL);
    if (!uuid)
        win_err(1, "reading uuid");
    if (l != 36) {
        fail_test(__LINE__, "uuid length was %d bytes, expected 36");
    }
    if (strlen(uuid) != 36) {
        fail_test(__LINE__,
                  "uuid was %s, not right length (%d, should be 36), returned length %d",
                  uuid,
                  strlen(uuid),
                  l);
    }

    /* Make sure read error sets a suitable code. */
    xs_read_expected_error(__LINE__, "non_existent", ERROR_FILE_NOT_FOUND);
    xs_read_expected_error(__LINE__, "invalid\\path",
                           ERROR_INVALID_PARAMETER);
    xs_read_expected_error(__LINE__, "/local/domain/0/name",
                           ERROR_ACCESS_DENIED);

    /* Test basic xs_write functionality. */
    if (!xs_write(xs_handle, "data/test/key1", "data1")) {
        fail_test(__LINE__, "write data/test/key1 failed with %lx",
                  GetLastError());
    } else {
        t = xs_read(xs_handle, "data/test/key1", &l);
        if (!t) {
            fail_test(__LINE__, "error reading from data/test/key1: %lx",
                      GetLastError());
        } else {
            if (l != 5) {
                fail_test(__LINE__,
                          "manifest length wrong reading data/test/key1: %d should be 5.",
                          l);
            }
            if (strcmp(t, "data1")) {
                fail_test(__LINE__,
                          "got wrong data reading data/test/key1: %s should be data1.",
                          t);
            }
            free(t);
        }
    }

    xs_write_expected_error(__LINE__, "foo", "bar", ERROR_ACCESS_DENIED);
    xs_write_expected_error(__LINE__, "/foo", "bar", ERROR_ACCESS_DENIED);

    /* Try a very large write and make sure that it fails in the
       expected way. */
    t = malloc(65536);
    memset(t, 'a', 65536);
    t[65535] = 0;
    xs_write_expected_error(__LINE__,"data/test/key1", t,
                            ERROR_DISK_FULL);
    free(t);

    /* Test that read and write work for keys containing nul bytes. */
    if (!xs_write_bin(xs_handle, "data/test/key1", "xxx\0yyy", 7)) {
        fail_test(__LINE__, "failed to write nul bytes (%d)",
                  GetLastError());
    }
    t = xs_read(xs_handle, "data/test/key1", &l);
    if (!t) {
        fail_test(__LINE__, "failed to read nul bytes (%d)",
                  GetLastError());
    } else {
        if (l != 7) {
            fail_test(__LINE__, "read with nuls: expected 7, got %d.\n", l);
        } else if (memcmp(t, "xxx\0yyy", 7)) {
            fail_test(__LINE__, "bad data from read with nuls: %s",
                      t);
        }
        free(t);
    }

    if (!xs_remove(xs_handle, "data/test/key1")) {
        fail_test(__LINE__, "failed to remove data/test/key1 (%d)",
                  GetLastError());
    }

    xs_read_expected_error(__LINE__, "data/test/key1", ERROR_FILE_NOT_FOUND);

    xs_ls_expected_error(__LINE__, "data/test/key1", ERROR_FILE_NOT_FOUND);

    if (!xs_write(xs_handle, "data/test/key1", "data1")) {
        fail_test(__LINE__, "failed to rewrite data/test/key1");
    }

    contents = xs_directory(xs_handle, "data/test/key1", &count);
    if (!contents) {
        fail_test(__LINE__, "failed to ls data/test/key1: %x",
                  GetLastError());
    } else if (count != 0) {
        fail_test(__LINE__, "ls data/test/key1 had %d items", count);
        free(contents);
    } else {
        free(contents);
    }

    if (!xs_write(xs_handle, "data/test/key1/key2", "data2")) {
        fail_test(__LINE__, "failed to rewrite data/test/key1/key2");
    }

    contents = xs_directory(xs_handle, "data/test/key1", &count);
    if (!contents) {
        fail_test(__LINE__, "failed to ls data/test/key1: %x",
                  GetLastError());
    } else if (count != 1) {
        fail_test(__LINE__, "ls data/test/key1 had %d items", count);
        free(contents);
    } else if (strcmp(contents[0], "key2")) {
        fail_test(__LINE__, "ls data/test/key1 gave unexpected result %s",
                  contents[0]);
    }

    xs_remove(xs_handle, "data/test");

    /* Looks like most of the basic functionality works.  Try
     * transactions. */
    xs_handle2 = xs_domain_open();
    if (!xs_handle2) win_err(1, "couldn't re-open domain interface");

    if (!xs_write(xs_handle, "data/test/key1", "before"))
        fail_test(__LINE__, "failed to write to data/test/key1: %x",
                  GetLastError());
    if (!xs_transaction_start(xs_handle2))
        win_err(1, "couldn't open a transaction on second handle");
    if (!xs_write(xs_handle2, "data/test/key1", "after"))
        fail_test(__LINE__, "failed to write to data/test/key1 under transaction: %x",
                  GetLastError());
    if (!xs_transaction_end(xs_handle2, FALSE))
        fail_test(__LINE__, "failed to write to end transaction: %x",
                  GetLastError());
    if (strcmp(xs_read(xs_handle, "data/test/key1", NULL), "after"))
        fail_test(__LINE__, "transaction didn't stick");

    /* Now try aborting the transaction. */
    if (!xs_write(xs_handle, "data/test/key1", "before"))
        fail_test(__LINE__, "failed to write to data/test/key1: %x",
                  GetLastError());
    if (!xs_transaction_start(xs_handle2))
        win_err(1, "couldn't open a transaction on second handle");
    if (!xs_write(xs_handle2, "data/test/key1", "after"))
        fail_test(__LINE__, "failed to write to data/test/key1 under transaction: %x",
                  GetLastError());
    if (!xs_transaction_end(xs_handle2, TRUE))
        fail_test(__LINE__, "failed to write to end transaction: %x",
                  GetLastError());
    if (strcmp(xs_read(xs_handle, "data/test/key1", NULL), "before"))
        fail_test(__LINE__, "transaction didn't abort");

    /* Try to arrange that the transaction fails. */
    if (!xs_write(xs_handle, "data/test/key1", "before"))
        fail_test(__LINE__, "failed to write to data/test/key1: %x",
                  GetLastError());
    if (!xs_transaction_start(xs_handle2))
        win_err(1, "couldn't open a transaction on second handle");
    if (!xs_write(xs_handle2, "data/test/key1", "after"))
        fail_test(__LINE__, "failed to write to data/test/key1 under transaction: %x",
                  GetLastError());
    if (!xs_write(xs_handle, "data/test/key1", "other"))
        fail_test(__LINE__, "failed to write to data/test/key1: %x",
                  GetLastError());
    if (xs_transaction_end(xs_handle2, FALSE))
        fail_test(__LINE__, "transaction succeeded when it shouldn't",
                  GetLastError());
    if (strcmp(xs_read(xs_handle, "data/test/key1", NULL), "other"))
        fail_test(__LINE__, "transaction did something strange");


    if (!xs_write(xs_handle, "data/test/key1", "before1"))
        fail_test(__LINE__, "failed to write to data/test/key1: %x",
                  GetLastError());
    if (!xs_write(xs_handle, "data/test/key2", "before2"))
        fail_test(__LINE__, "failed to write to data/test/key2: %x",
                  GetLastError());
    if (!xs_transaction_start(xs_handle2))
        win_err(1, "couldn't open a transaction on second handle");
    if (!xs_write(xs_handle2, "data/test/key1", "after"))
        fail_test(__LINE__, "failed to write to data/test/key1 under transaction: %x",
                  GetLastError());
    t = xs_read(xs_handle2, "data/test/key2", NULL);
    if (!t) {
        fail_test(__LINE__,
                  "failed to read data/test/key2 under transaction: %x",
                  GetLastError());
    } else {
        if (strcmp(t, "before2"))
            fail_test(__LINE__,
                      "got wrong thing reading dtaa/test/key2 (%s)",
                      t);
        free(t);
    }
    if (!xs_write(xs_handle, "data/test/key2", "other"))
        fail_test(__LINE__, "failed to write to data/test/key1: %x",
                  GetLastError());
    if (xs_transaction_end(xs_handle2, FALSE))
        fail_test(__LINE__, "transaction succeeded when it shouldn't",
                  GetLastError());
    if (strcmp(xs_read(xs_handle, "data/test/key1", NULL), "before1"))
        fail_test(__LINE__, "transaction did something strange");

    xs_daemon_close(xs_handle2);

    /* Try a couple of transaction error cases. */
    xs_handle2 = xs_domain_open();
    if (!xs_handle2) win_err(1, "couldn't re-open domain interface a second time");
    if (!xs_transaction_start(xs_handle2))
        win_err(1, "couldn't open a transaction for re-test");
    if (xs_transaction_start(xs_handle2)) {
        fail_test(__LINE__, "openned two transactions on same handle");
    }
    xs_daemon_close(xs_handle2);

    xs_handle2 = xs_domain_open();
    if (!xs_handle2) win_err(1, "couldn't re-open domain interface a third time");
    if (xs_transaction_end(xs_handle2, FALSE)) {
        fail_test(__LINE__, "ended transaction without starting it");
    }
    if (!xs_transaction_start(xs_handle2))
        win_err(1, "couldn't open a transaction for re-test");
    if (!xs_transaction_end(xs_handle2, FALSE))
        fail_test(__LINE__, "failed to end transaction");
    if (xs_transaction_end(xs_handle2, FALSE)) {
        fail_test(__LINE__, "double-ended transaction");
    }
    xs_daemon_close(xs_handle2);


    /* Transactions appear to be working, at least in their most basic
       form.  Have a go at watches. */
    event = CreateEvent(NULL, FALSE, FALSE, NULL);
    watch_h = xs_watch(xs_handle, "data/test/key1", event);
    if (watch_h < 0) {
        fail_test(__LINE__, "couldn't watch data/test/key1");
    } else {
        while (WaitForSingleObject(event, 100) != WAIT_TIMEOUT)
            ;
        xs_write(xs_handle, "data/test/key1", "foo");
        if (WaitForSingleObject(event, INFINITE) != WAIT_OBJECT_0)
            fail_test(__LINE__, "failed wait for data/test/key1: %x",
                      GetLastError());
        xs_write(xs_handle, "data/test/key1", "foo");
        if (WaitForSingleObject(event, INFINITE) != WAIT_OBJECT_0)
            fail_test(__LINE__, "failed wait for data/test/key1: %x",
                      GetLastError());
        xs_write(xs_handle, "data/test/key1", "foo");
        if (WaitForSingleObject(event, INFINITE) != WAIT_OBJECT_0)
            fail_test(__LINE__, "failed wait for data/test/key1: %x",
                      GetLastError());
        status = WaitForSingleObject(event, 2000);
        if (status != WAIT_TIMEOUT)
            fail_test(__LINE__,
                      "should have timed out waiting for data/test/key1 (%d, %d)",
                      status,
                      GetLastError());

        if (!xs_unwatch(xs_handle, watch_h))
            fail_test(__LINE__, "failed to unwatch");
    }

    /* Create two watches on the same key, kill one of them, and then
       make sure that the other one still works. */
    watch_h = xs_watch(xs_handle, "data/test/key1/subkey", event);
    if (watch_h < 0) {
        fail_test(__LINE__, "couldn't watch data/test/key1/subkey");
    } else {
        event2 = CreateEvent(NULL, FALSE, FALSE, NULL);
        watch_h2 = xs_watch(xs_handle, "data/test/key1/subkey", event);
        if (watch_h2 < 0) {
            fail_test(__LINE__, "couldn't double watch data/test/key1/subkey");
        } else {
            if (!xs_unwatch(xs_handle, watch_h2))
                fail_test(__LINE__, "failed to unwatch h2");
            ResetEvent(event);
            xs_remove(xs_handle, "data/test/key1");
            if (WaitForSingleObject(event, 5000) != WAIT_OBJECT_0)
                fail_test(__LINE__, "failed wait for data/test/key1: %x",
                          GetLastError());
            if (!xs_unwatch(xs_handle, watch_h))
                fail_test(__LINE__, "failed to unwatch");
        }
    }

    /* Watch a node, then modify it in a transaction, and check that
       the watch fires. */
    watch_h = xs_watch(xs_handle, "data/test/key1", event);
    if (watch_h < 0) {
        fail_test(__LINE__, "couldn't watch data/test/key1");
    } else {
        for (i = 0; i < 100; i++) {
            ResetEvent(event);
            do {
                if (!xs_transaction_start(xs_handle))
                    win_err(1, "couldn't open a transaction for watch test");
                xs_write(xs_handle, "data/test/key1", "foo");
            } while (!xs_transaction_end(xs_handle, FALSE));
            if (WaitForSingleObject(event, 5000) != WAIT_OBJECT_0)
                fail_test(__LINE__, "failed wait for data/test/key1(%d): %x",
                          i, GetLastError());
        }
        if (!xs_unwatch(xs_handle, watch_h))
            fail_test(__LINE__, "failed to unwatch");
    }

    /* Make a lot of watches, make sure they all work. */
    test_many_watches();

    /* Try some different sized requests */
    test_write_sizes(4096);

    xs_daemon_close(xs_handle);

    run_stress();

    if (failed) {
        printf("failed\n");
        return 1;
    } else {
        printf("passed\n");
        return 0;
    }
}
Beispiel #15
0
/*
 * dump metrics received from xenstore to the dest file 
 */
int dump_xenstore_metrics(const char *dest_file)
{
    char *buf = NULL, *path = NULL, *metrics = NULL;
    struct xs_handle *xsh = NULL;
    unsigned int len;
    int ret = 0;
	xmlParserCtxtPtr pctxt = NULL;
	xmlDocPtr doc = NULL;
    int domid;
    FILE *fp;

    if (dest_file) {
        fp = fopen(dest_file, "w");
        if (fp == NULL) {
            libmsg("Error, unable to dump metrics from xenstore: %s\n", strerror(errno));
            return -1;
        }
    }
    else {
        fp = stdout;
    }

    if ((domid = get_dom_id()) == -1) {
        libmsg("Unable to derive domID.\n" );
        ret = -1;
        goto out;
    }

    xsh = xs_domain_open();
    if (xsh == NULL) {
        libmsg("xs_domain_open() error. errno: %d.\n", errno);
        ret = -1;
        goto out;
    }

    path = xs_get_domain_path(xsh, domid);
    if (path == NULL) {
        libmsg("xs_get_domain_path() error. domid %d.\n", 0);
        ret = -1;
        goto out;
    }
    asprintf(&buf, "%s/metrics", path);
    metrics = xs_read(xsh, XBT_NULL, buf, &len);
    if (metrics == NULL) {
        libmsg("xs_read(): uuid get error. %s.\n", buf);
        ret = -1;
        goto out;
    }

    pctxt = xmlNewParserCtxt();
    if (!pctxt || !pctxt->sax) {
      libmsg("%s(): failed to create parser \n", __func__);
      ret = -1;
      goto out;
    }

    doc = xmlCtxtReadMemory(pctxt, metrics,
                            strlen(metrics), "mdisk.xml", NULL,
                            XML_PARSE_NOENT | XML_PARSE_NONET |
                            XML_PARSE_NOWARNING);
    if (!doc) {
      libmsg("%s(): libxml failed to xenstore metrics attribute\n", __func__);
      ret = -1;
      goto out;
    }
    xmlDocFormatDump(fp, doc, 1);

out:
    if (fp && fp != stdout)
        fclose(fp);
    if (doc)
      xmlFreeDoc(doc);
    if (pctxt)
      xmlFreeParserCtxt(pctxt);
    free(path);
    free(buf);
    free(metrics);
    return ret;
}
Beispiel #16
0
main(int argc, char **argv)
{
	int ret;
	pthread_t rcv_thread;
	uint64_t  threadid;
	uint32_t  redirect_input = 0;
	char      *parse_string;
	char send_buf[RSH_BUF_SIZE];
	char input_file_name[MAX_FILE_STRING];
	int option = 0;
	int target_endpoint = 0;
	int input_commands;
	int i,j;


	if (argc < 2) {
		printf("\n\nusage ... \n\n");
		printf("\tvxt_rsh <name>\n\n");
		return -1;
	}


	i = 1;
	j = 0;
	input_commands = 0;
	input_file_name[0] = '\0';
	parse_string = NULL;
	while(i < argc) {
		/*
		 * We may parse multiple flags or options into
		 * one token if there are no spaces.  Hence
		 * the while loop below.
		 */
		while ((i < argc) && (argv[i][j] != '\0')) {
			VXTPRINT(4, "switch on, %c\n", argv[i][j]);
			switch(argv[i][j]) {
			case '-': {
				if (option) {
					VXTPRINT(4, "double option \"-\"\n");
					return command_line_error();
				}
				option = 1;
				j++;
                                break;
                        }
			case 'I': {
				if (option == 1) {
					VXTPRINT(4, "case I, "
					         "Input redirection\n");
					parse_string = input_file_name;
				}
				/*
				 * We are now in an option parse
				 * for a string, go to the option
				 * string reader, we may not have a
				 * space to separate the option letter from
				 * its string.
				 */
				ret = vxtdb_parse_option_parm(argv, argc, 
				                              parse_string,
				                              &option,
				                              &i, &j);
				if (ret != 0) {
					return ret;
				}

				if (option == 0) {
					parse_string = NULL;
				}

				break;
			}
			default:
			{
				VXTPRINT(4, "default, i %d, j %d\n",i,j);
				if (option) {
					VXTPRINT(4, "in option parsing\n");
					if (parse_string == input_file_name) {
						VXTPRINT(4, "in filestring "
						         "aquisition\n");
						strncpy(parse_string,
						        &(argv[i][j]),
						        MAX_FILE_STRING);
						option = 0;
						j=0;
						i++;
						parse_string
						   [MAX_FILE_STRING - 1] = 0;
						parse_string = NULL;
						VXTPRINT(4, "finished getting "
						         "filename after "
							 "space\n");
						break;
					} else {
						printf("\n\nUnknown Option\n");
						return command_line_error();
					}
				} else {
					if (j != 0) {
						VXTPRINT(4, "starting in the"
						         "middle of default "
						         "string\n");
						return command_line_error();
					}
					if (target_endpoint != 0) {
						return command_line_error();
					}
					target_endpoint = 1;
					target_domain = atoi(&argv[i][j]);
					i++;
				}
			}
			if (i >= argc) {
				break;
			}
			}
		}
		option = 0;
			j = 0;
			i++;

	}


 	pthread_mutex_init(&rcv_sync_lock, NULL);
	pthread_cond_init(&rcv_sync_var, NULL);
					
	VXTPRINT(4, "redirect file name: %s\n", input_file_name);

	if (target_domain == 0) {
		/*
		 * Default connection to the HUB
		 */
		strncpy(target_uuid, VXTDB_DOM0_ENDPOINT, MAX_VXT_UUID); 
	} else {
		vxt_db_query_arg_t query_arg;
		int                authdev;

		VXTPRINT(3, "Open VxT Authorization Database\n");
		authdev = open("/dev/vxtdb-auth", O_RDWR);
		if(authdev < 0) {
			VXTPRINT(0, "\n\nFailed to open the Vxt authorization "
			         "database device\n\n");
			return -1;
		}
		query_arg.hub = 1;
		ioctl(authdev, VXT_AUTH_DB_QUERY, (void *)(long)&query_arg);
		if (!query_arg.hub) {
			/*
			 * Get the routing and authorization through the
			 * auth db intermediary.
			 */
			VXTPRINT(3, "We are not a hub, use default routing."
			         " If in future we utilize a physical device"
			         " With internal routing, code may go here\n");
			strncpy(target_uuid,
				VXTDB_DOM0_ENDPOINT, MAX_VXT_UUID); 
		} else {
#ifdef XSTOOLS
			struct xs_handle *xs;
			xs_transaction_t th;
			int len;
			char ep_id_path[32];
			char *xenstore_uuid_path;
	
			xs = xs_domain_open();
			if (!xs) {
				perror("xs_domain_open failure");
				return -1;
			}

			sprintf(ep_id_path, "/local/domain/%d/vm",
			        target_domain);
			th = xs_transaction_start(xs);
			xenstore_uuid_path = 
			   (char *) xs_read(xs, th, ep_id_path, &len);
			if (!xenstore_uuid_path) {
				VXTPRINT(0, "Target domain %d not valid. "
				         "Exiting...\n", target_domain);
				return -1;
			}
			strncpy(target_uuid,
			        &(xenstore_uuid_path[4]), MAX_VXT_UUID-4);
			free(xenstore_uuid_path);
			target_uuid[MAX_VXT_UUID-1] = 0;
			if(!xs_transaction_end(xs, th, 0)) {
	       	        	VXTPRINT(0,
				         "Could not read xenstore database\n");
				return -1;
			}
#else
			strncpy(target_uuid,
				VXTDB_DOM0_ENDPOINT, MAX_VXT_UUID); 
#endif
		}
        }



	vrsh_set_sig_handler();

	ret = vrsh_create_device(&vsock);
	if (ret != VXT_SUCCESS) {
		return -1;
	}

	vxt_mb();

        ret = pthread_create(&rcv_thread, NULL, 
	                     (void *) &rsh_rcv_thread, (void *)&vsock);

	if (ret == -1) {
		endwin();
		return -1;
	}


	/*
	 * Starting local interpreter
	 */
	while(TRUE) {
		char buf[1024];
		int vxt_send_len;
		int read_len;
		size_t len = 0;
		ssize_t read_size;
		
/*
		char *line = NULL;
		read_size = getline(&line, &len, stdin);
		VXTPRINT(4, "Picked up command: %s of length %d\n",
		         line, read_size);
*/

		if (strnlen(input_file_name, MAX_FILE_STRING) != 0) {
			input_commands = open(input_file_name, O_RDWR);
			if(input_commands < 0) {
				VXTPRINT(0, "\n\n\tFailed to open the Vxt "
				         "input redirection command file\n\n");
				return -1;
			}
			while ((read_len =
			        read(input_commands, &buf, 1024)) > 0) {
				vxt_send_len = read_len;
				while (vxt_send_len != 0) {
					ret =
					   vxt_send(vsock, buf,
					            &vxt_send_len,
					            VXT_SOCK_SIGNAL
					               | VXT_SOCK_WAIT);
					read_len -= vxt_send_len;
					vxt_send_len = read_len;
					
				}
			}

			pthread_mutex_lock(&rcv_sync_lock);
			pthread_cond_wait(&rcv_sync_var, &rcv_sync_lock);
			pthread_mutex_unlock(&rcv_sync_lock);
			return 0;
		}
		while ((read_len = read(STDOUT_FILENO, &buf, 1024)) > 0) {
		 	/*
			 * Local debug trace, writes stream bound for
			 * remote to stdout
	  		 *  write(STDOUT_FILENO, &buf, sendlen);
			 */
			vxt_send_len = read_len;
			while (vxt_send_len != 0) {
				ret = vxt_send(vsock, buf, &vxt_send_len,
				               VXT_SOCK_SIGNAL | VXT_SOCK_WAIT);
				read_len -= vxt_send_len;
				vxt_send_len = read_len;
				
			}
	 	}
	}


}