+ free (xml);
+ if (xpathObj) xmlXPathFreeObject (xpathObj);
+ if (xpathCtx) xmlXPathFreeContext (xpathCtx);
+ if (doc) xmlFreeDoc (doc);
+
+ return r;
+}
+
+/* This was proposed as an external API, but it's not quite baked yet. */
+
+static int add_disk (guestfs_h *g, const char *filename, const char *format, int readonly, void *data);
+static int connect_live (guestfs_h *g, virDomainPtr dom);
+
+enum readonlydisk {
+ readonlydisk_error,
+ readonlydisk_read,
+ readonlydisk_write,
+ readonlydisk_ignore,
+};
+
+struct add_disk_data {
+ int readonly;
+ enum readonlydisk readonlydisk;
+ /* Other args to pass through to add_drive_opts. */
+ struct guestfs_add_drive_opts_argv optargs;
+};
+
+static int
+guestfs___add_libvirt_dom (guestfs_h *g, virDomainPtr dom,
+ const struct guestfs___add_libvirt_dom_argv *optargs)
+{
+ size_t cmdline_pos;
+ int r;
+ int readonly;
+ const char *iface;
+ int live;
+ /* Default for back-compat reasons: */
+ enum readonlydisk readonlydisk = readonlydisk_write;
+
+ readonly =
+ optargs->bitmask & GUESTFS___ADD_LIBVIRT_DOM_READONLY_BITMASK
+ ? optargs->readonly : 0;
+ iface =
+ optargs->bitmask & GUESTFS___ADD_LIBVIRT_DOM_IFACE_BITMASK
+ ? optargs->iface : NULL;
+ live =
+ optargs->bitmask & GUESTFS___ADD_LIBVIRT_DOM_LIVE_BITMASK
+ ? optargs->live : 0;
+
+ if ((optargs->bitmask & GUESTFS___ADD_LIBVIRT_DOM_READONLYDISK_BITMASK)) {
+ if (STREQ (optargs->readonlydisk, "error"))
+ readonlydisk = readonlydisk_error;
+ else if (STREQ (optargs->readonlydisk, "read"))
+ readonlydisk = readonlydisk_read;
+ else if (STREQ (optargs->readonlydisk, "write"))
+ readonlydisk = readonlydisk_write;
+ else if (STREQ (optargs->readonlydisk, "ignore"))
+ readonlydisk = readonlydisk_ignore;
+ else {
+ error (g, _("unknown readonlydisk parameter"));
+ return -1;
+ }
+ }
+
+ if (live && readonly) {
+ error (g, _("you cannot set both live and readonly flags"));
+ return -1;
+ }
+
+ if (!readonly) {
+ virDomainInfo info;
+ virErrorPtr err;
+ int vm_running;
+
+ if (virDomainGetInfo (dom, &info) == -1) {
+ err = virGetLastError ();
+ error (g, _("error getting domain info: %s"), err->message);
+ return -1;
+ }
+ vm_running = info.state != VIR_DOMAIN_SHUTOFF;
+
+ if (vm_running) {
+ /* If the caller specified the 'live' flag, then they want us to
+ * try to connect to guestfsd if the domain is running. Note
+ * that live readonly connections are not possible.
+ */
+ if (live)
+ return connect_live (g, dom);
+
+ /* Dangerous to modify the disks of a running VM. */
+ error (g, _("error: domain is a live virtual machine.\n"
+ "Writing to the disks of a running virtual machine can cause disk corruption.\n"
+ "Either use read-only access, or if the guest is running the guestfsd daemon\n"
+ "specify live access. In most libguestfs tools these options are --ro or\n"
+ "--live respectively. Consult the documentation for further information."));
+ return -1;
+ }
+ }
+
+ /* Add the disks. */
+ struct add_disk_data data;
+ data.optargs.bitmask = 0;
+ data.readonly = readonly;
+ data.readonlydisk = readonlydisk;
+ if (iface) {
+ data.optargs.bitmask |= GUESTFS_ADD_DRIVE_OPTS_IFACE_BITMASK;
+ data.optargs.iface = iface;
+ }
+
+ /* Checkpoint the command line around the operation so that either
+ * all disks are added or none are added.
+ */
+ struct drive **cp = guestfs___checkpoint_drives (g);
+ r = guestfs___for_each_disk (g, dom, add_disk, &data);
+ if (r == -1)
+ guestfs___rollback_drives (g, cp);
+
+ return r;
+}
+
+static int
+add_disk (guestfs_h *g,
+ const char *filename, const char *format, int readonly_in_xml,
+ void *datavp)
+{
+ struct add_disk_data *data = datavp;
+ /* Copy whole struct so we can make local changes: */
+ struct guestfs_add_drive_opts_argv optargs = data->optargs;
+ int readonly, error = 0, skip = 0;
+
+ if (readonly_in_xml) { /* <readonly/> appears in the XML */
+ if (data->readonly) { /* asked to add disk read-only */
+ switch (data->readonlydisk) {
+ case readonlydisk_error: readonly = 1; break;
+ case readonlydisk_read: readonly = 1; break;
+ case readonlydisk_write: readonly = 1; break;
+ case readonlydisk_ignore: skip = 1; break;
+ default: abort ();
+ }
+ } else { /* asked to add disk for read/write */
+ switch (data->readonlydisk) {
+ case readonlydisk_error: error = 1; break;
+ case readonlydisk_read: readonly = 1; break;
+ case readonlydisk_write: readonly = 0; break;
+ case readonlydisk_ignore: skip = 1; break;
+ default: abort ();
+ }
+ }
+ } else /* no <readonly/> in XML */
+ readonly = data->readonly;
+
+ if (skip)
+ return 0;
+
+ if (error) {
+ error (g, _("%s: disk is marked <readonly/> in libvirt XML, and readonlydisk was set to \"error\""),
+ filename);
+ return -1;
+ }
+
+ optargs.bitmask |= GUESTFS_ADD_DRIVE_OPTS_READONLY_BITMASK;
+ optargs.readonly = readonly;
+
+ if (format) {
+ optargs.bitmask |= GUESTFS_ADD_DRIVE_OPTS_FORMAT_BITMASK;
+ optargs.format = format;
+ }
+
+ return guestfs__add_drive_opts (g, filename, &optargs);
+}
+
+static int
+connect_live (guestfs_h *g, virDomainPtr dom)
+{
+ int i, r = -1;
+ virErrorPtr err;
+ xmlDocPtr doc = NULL;
+ xmlXPathContextPtr xpathCtx = NULL;
+ xmlXPathObjectPtr xpathObj = NULL;
+ char *xml = NULL;
+ char *path = NULL;
+ char *attach_method = NULL;
+
+ /* Domain XML. */
+ xml = virDomainGetXMLDesc (dom, 0);
+
+ if (!xml) {
+ err = virGetLastError ();
+ error (g, _("error reading libvirt XML information: %s"),
+ err->message);
+ goto cleanup;
+ }
+
+ /* Parse XML to document. */
+ doc = xmlParseMemory (xml, strlen (xml));
+ if (doc == NULL) {
+ error (g, _("unable to parse XML information returned by libvirt"));
+ goto cleanup;
+ }
+
+ xpathCtx = xmlXPathNewContext (doc);
+ if (xpathCtx == NULL) {
+ error (g, _("unable to create new XPath context"));
+ goto cleanup;
+ }
+
+ /* This gives us a set of all the <channel> nodes related to the
+ * guestfsd virtio-serial channel.
+ */
+ xpathObj = xmlXPathEvalExpression (BAD_CAST
+ "//devices/channel[@type=\"unix\" and "
+ "./source/@mode=\"bind\" and "
+ "./source/@path and "
+ "./target/@type=\"virtio\" and "
+ "./target/@name=\"org.libguestfs.channel.0\"]",
+ xpathCtx);
+ if (xpathObj == NULL) {
+ error (g, _("unable to evaluate XPath expression"));
+ goto cleanup;
+ }
+
+ xmlNodeSetPtr nodes = xpathObj->nodesetval;
+ for (i = 0; i < nodes->nodeNr; ++i) {
+ xmlXPathObjectPtr xppath;
+
+ /* See note in function above. */
+ xpathCtx->node = nodes->nodeTab[i];
+
+ /* The path is in <source path=..> attribute. */
+ xppath = xmlXPathEvalExpression (BAD_CAST "./source/@path", xpathCtx);
+ if (xppath == NULL ||
+ xppath->nodesetval == NULL ||
+ xppath->nodesetval->nodeNr == 0) {
+ xmlXPathFreeObject (xppath);
+ continue; /* no type attribute, skip it */
+ }
+ assert (xppath->nodesetval->nodeTab[0]);
+ assert (xppath->nodesetval->nodeTab[0]->type == XML_ATTRIBUTE_NODE);
+ xmlAttrPtr attr = (xmlAttrPtr) xppath->nodesetval->nodeTab[0];
+ path = (char *) xmlNodeListGetString (doc, attr->children, 1);
+ xmlXPathFreeObject (xppath);
+ break;
+ }
+
+ if (path == NULL) {
+ error (g, _("this guest has no libvirt <channel> definition for guestfsd\n"
+ "See ATTACHING TO RUNNING DAEMONS in guestfs(3) for further information."));
+ goto cleanup;
+ }
+
+ /* Got a path. */
+ attach_method = safe_malloc (g, strlen (path) + 5 + 1);
+ strcpy (attach_method, "unix:");
+ strcat (attach_method, path);
+ r = guestfs_set_attach_method (g, attach_method);
+
+ cleanup:
+ free (path);
+ free (attach_method);