On 01/03/2013 08:46 AM, Michal Privoznik wrote: I think you mean VIR_INTERFACE_PTP, not _PPP. I dislike creating yet another struct to represent IP address info when we already can do that internally with virSocketAddr, but virSocketAddr is too complicated (and has platform-specific bits to boot) to put it in the public API, and every other IP address in the public API is represented with XML, so I guess this is okay. You should remove the "etc" line. The repeated plurality sounds a bit clumsy, but it *is* the most correct I guess (since virDomainInterfaceAddresses would imply that it's only returning the addresses of a single interface). However, most (unfortunately not all) libvirt APIs that retrieve information about an entity include a verb in the name, usually "Get". So how about naming it "virDomainGetInterfacesAddresses" (following all the other virDomainGet* function names). (BTW, it seems a bit bothersome to me that we will now have virDomainGetInterfaceParameters() (which merely returns duplicates of bandwidth information already present in the domain XML for a single interface), virDomainInterfaceStats() (which returns traffic stats for a single interface), and this new function, which returns addresses for all interfaces. It's true that the source of each piece of information is different (the first is from the domain's configuration, the 2nd is from ioctls run on the host, and the third is from either querying the guest agent, or from asking nwfilter for the value it's learned via snooping the traffic), but that's an implementation detail that shouldn't matter to the user of the libvirt API. It would be nice if this was somehow consolidated, although I'm not expecting you to do it :-)) s/presented in given/present in the given/ s/among/along/ s/Single/A single/ s/none/no/ s/struct/object/ s/much interfaces domain/many interfaces the domain/ Depending on the selected @method, the address information will be retrieved from a different source: the guest agent method requests the information from an agent running in the guest. This obviously requires a guest agent to be configured and running, and will otherwise fail. However, the guest agent method provides the information from the guest's point of view - the interface names and hardware addresses are those seen by the guest OS. When the NWFilter method is used, the information is requested from libvirt's NWFilter driver, which "snoops" traffic on the guest's network connections and deduces IP and MAC address information from examining that traffic; in this case, the interface name will be the name of the tap device created by libvirt to connect the device to the host's network, *not* the name of the device as seen by the guest OS.

This command returns an array of all guest interfaces among with their IP and HW addresses. --- src/qemu/qemu_agent.c | 171 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/qemu/qemu_agent.h | 2 + 2 files changed, 173 insertions(+) diff --git a/src/qemu/qemu_agent.c b/src/qemu/qemu_agent.c index bb421bd..409ba04 100644 --- a/src/qemu/qemu_agent.c +++ b/src/qemu/qemu_agent.c @@ -1474,3 +1474,174 @@ qemuAgentFSTrim(qemuAgentPtr mon, virJSONValueFree(reply); return ret; } + +static int +getInterfaces(virJSONValuePtr reply, + virDomainInterfacePtr **ifaces) +{ + int ret = -1; + int i, size = 0; + virJSONValuePtr replyArray = NULL; + + if (!(replyArray = virJSONValueObjectGet(reply, "return"))) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("qemu agent did not provide 'return' object")); + goto cleanup; + } + + if ((size = virJSONValueArraySize(replyArray)) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("qemu agent did not provide any interface")); + goto cleanup; + } + + if (size && VIR_ALLOC_N(*ifaces, size * sizeof(virDomainInterfacePtr)) < 0) { + virReportOOMError(); + goto cleanup; + } + + for (i = 0; i < size; i++) { + virJSONValuePtr jsonIface = virJSONValueArrayGet(replyArray, i); + virDomainInterfacePtr tmpIface = NULL; + virJSONValuePtr jsonIpAddrArr = NULL; + int j, jsonIpAddrArrSize = 0; + const char *name, *hwaddr; + + if (VIR_ALLOC(tmpIface) < 0) { + virReportOOMError(); + goto cleanup; + } + + (*ifaces)[i] = tmpIface; + /* should not happen, but doesn't hurt to check */ + if (!jsonIface) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("Something went really wrong while processing " + "guest agent reply")); + goto cleanup; + } + + name = virJSONValueObjectGetString(jsonIface, "name"); + if (!name) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("qemu agent did not provide 'name' object")); + goto cleanup; + } + + if (!(tmpIface->name = strdup(name))) { + virReportOOMError(); + goto cleanup; + } + + /* hwaddr might be omitted */ + hwaddr = virJSONValueObjectGetString(jsonIface, "hardware-address"); + if (hwaddr && !(tmpIface->hwaddr = strdup(hwaddr))) { + virReportOOMError(); + goto cleanup; + } + + /* as well as ip-addresses */ + jsonIpAddrArr = virJSONValueObjectGet(jsonIface, "ip-addresses"); + if (!jsonIpAddrArr) + continue; + + if ((jsonIpAddrArrSize = virJSONValueArraySize(jsonIpAddrArr)) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("qemu agent provided malformed " + "ip-addresses field")); + goto cleanup; + } + + if (VIR_ALLOC_N(tmpIface->ip_addrs, jsonIpAddrArrSize) < 0) { + virReportOOMError(); + goto cleanup; + } + tmpIface->ip_addrs_count = jsonIpAddrArrSize; + + for (j = 0; j < jsonIpAddrArrSize; j++) { + virJSONValuePtr jsonIpAddr = virJSONValueArrayGet(jsonIpAddrArr, j); + virDomainIPAddressPtr tmpIpAddr = &(tmpIface->ip_addrs[j]); + const char *ipAddr, *ipAddrType; + + if (!(ipAddr = virJSONValueObjectGetString(jsonIpAddr, + "ip-address"))) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("qemu-agent didn't provided " + "an ip-address field")); + goto cleanup; + } + + if (!(tmpIpAddr->addr = strdup(ipAddr))) { + virReportOOMError(); + goto cleanup; + } + + if (!(ipAddrType = virJSONValueObjectGetString(jsonIpAddr, + "ip-address-type"))) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("qemu-agent didn't provided " + "an ip-address-type field")); + goto cleanup; + } + + if (STREQ(ipAddrType, "ipv4")) + tmpIpAddr->type = VIR_IP_ADDR_TYPE_IPV4; + else if (STREQ(ipAddrType, "ipv6")) + tmpIpAddr->type = VIR_IP_ADDR_TYPE_IPV6; + else { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("qemu agent provided unknown " + "ip-address-type '%s'"), + ipAddrType); + goto cleanup; + } + + if (virJSONValueObjectGetNumberInt(jsonIpAddr, "prefix", + &(tmpIpAddr->prefix)) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("qemu agent provided " + "malformed prefix field")); + goto cleanup; + } + + /* Nor broadcast address is reported */ + } + } + + ret = size; + +cleanup: + if (ret < 0) { + for (i = 0; i < size; i++) + virDomainInterfaceFree((*ifaces)[i]); + VIR_FREE(*ifaces); + } + return ret; +} + +int +qemuAgentGetInterfaces(qemuAgentPtr mon, + virDomainInterfacePtr **ifaces) +{ + int ret = -1; + virJSONValuePtr cmd; + virJSONValuePtr reply = NULL; + + cmd = qemuAgentMakeCommand("guest-network-get-interfaces", NULL); + + if (!cmd) + return ret; + + ret = qemuAgentCommand(mon, cmd, &reply, + VIR_DOMAIN_QEMU_AGENT_COMMAND_BLOCK); + + if (reply && ret == 0) + ret = qemuAgentCheckError(cmd, reply); + + if (ret == 0) + ret = getInterfaces(reply, ifaces); + + virJSONValueFree(cmd); + virJSONValueFree(reply); + return ret; +} diff --git a/src/qemu/qemu_agent.h b/src/qemu/qemu_agent.h index dad068b..0c22920 100644 --- a/src/qemu/qemu_agent.h +++ b/src/qemu/qemu_agent.h @@ -85,4 +85,6 @@ int qemuAgentArbitraryCommand(qemuAgentPtr mon, int timeout); int qemuAgentFSTrim(qemuAgentPtr mon, unsigned long long minimum); +int qemuAgentGetInterfaces(qemuAgentPtr mon, + virDomainInterfacePtr **ifaces); #endif /* __QEMU_AGENT_H__ */ -- 1.8.0.2

--- src/qemu/qemu_driver.c | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index b8bb36b..662d956 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -14520,6 +14520,73 @@ cleanup: return ret; } +static int +qemuDomainInterfacesAddresses(virDomainPtr dom, + virDomainInterfacePtr **ifaces, + unsigned int method, + unsigned int flags) +{ + virQEMUDriverPtr driver = dom->conn->privateData; + virDomainObjPtr vm; + int ret = -1; + qemuDomainObjPrivatePtr priv; + + virCheckFlags(0, -1); + + if (method != VIR_DOMAIN_INTERFACE_ADDRS_DEFAULT && + method != VIR_DOMAIN_INTERFACE_ADDRS_GUEST_AGENT) { + virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", + _("Only guest agent method is supported for now")); + return -1; + } + + if (!(vm = qemuDomObjFromDomain(dom))) + goto cleanup; + + priv = vm->privateData; + + if (!virDomainObjIsActive(vm)) { + virReportError(VIR_ERR_OPERATION_INVALID, "%s", + _("domain is not running")); + goto cleanup; + } + + if (!priv->agent) { + virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", + _("QEMU guest agent is not configured")); + goto cleanup; + } + + if (priv->agentError) { + virReportError(VIR_ERR_AGENT_UNRESPONSIVE, "%s", + _("QEMU guest agent is not " + "available due to an error")); + goto cleanup; + } + + if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_QUERY) < 0) + goto cleanup; + + if (!virDomainObjIsActive(vm)) { + virReportError(VIR_ERR_OPERATION_INVALID, "%s", + _("domain is not running")); + goto endjob; + } + + qemuDomainObjEnterAgent(driver, vm); + ret = qemuAgentGetInterfaces(priv->agent, ifaces); + qemuDomainObjExitAgent(driver, vm); + +endjob: + if (qemuDomainObjEndJob(driver, vm) == 0) + vm = NULL; + +cleanup: + if (vm) + virDomainObjUnlock(vm); + return ret; +} + static virDriver qemuDriver = { .no = VIR_DRV_QEMU, .name = QEMU_DRIVER_NAME, @@ -14694,6 +14761,7 @@ static virDriver qemuDriver = { .nodeSetMemoryParameters = nodeSetMemoryParameters, /* 0.10.2 */ .nodeGetCPUMap = nodeGetCPUMap, /* 1.0.0 */ .domainFSTrim = qemuDomainFSTrim, /* 1.0.1 */ + .domainInterfacesAddresses = qemuDomainInterfacesAddresses, /* 1.0.2 */ }; -- 1.8.0.2

--- daemon/remote.c | 140 +++++++++++++++++++++++++++++++++++++++++++ src/remote/remote_driver.c | 94 +++++++++++++++++++++++++++++ src/remote/remote_protocol.x | 27 ++++++++- src/remote_protocol-structs | 27 +++++++++ 4 files changed, 287 insertions(+), 1 deletion(-) diff --git a/daemon/remote.c b/daemon/remote.c index 8767c18..7363e2a 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -4783,3 +4783,143 @@ no_memory: virReportOOMError(); return -1; } + +static int +remoteSerializeDomainInterfacesPtr(virDomainInterfacePtr *ifaces, + int ifacesCount, + remote_domain_interfaces_addresses_ret *ret) +{ + int i, j; + + if (!ifacesCount) + return 0; + + if (VIR_ALLOC_N(ret->ifaces.ifaces_val, ifacesCount) < 0) { + virReportOOMError(); + return -1; + } + + ret->ifaces.ifaces_len = ifacesCount; + + for (i = 0; i < ifacesCount; i++) { + virDomainInterfacePtr tmp = ifaces[i]; + remote_domain_interface *tmp_ret = &(ret->ifaces.ifaces_val[i]); + + if (!(tmp_ret->name = strdup(tmp->name))) + goto no_memory; + + if (tmp->hwaddr) { + char **hwaddr_p = NULL; + if (VIR_ALLOC(hwaddr_p) < 0) + goto no_memory; + *hwaddr_p = strdup(tmp->hwaddr); + if (!*hwaddr_p) { + VIR_FREE(hwaddr_p); + goto no_memory; + } + + tmp_ret->hwaddr = hwaddr_p; + } + + tmp_ret->flags = tmp->flags; + + if (!tmp->ip_addrs_count) + continue; + + if (VIR_ALLOC_N(tmp_ret->ip_addrs.ip_addrs_val, + tmp->ip_addrs_count) < 0) + goto no_memory; + + tmp_ret->ip_addrs.ip_addrs_len = tmp->ip_addrs_count; + + for (j = 0; j < tmp->ip_addrs_count; j++) { + virDomainIPAddress addr = tmp->ip_addrs[j]; + remote_domain_ip_addrs *addr_ret = &(tmp_ret->ip_addrs.ip_addrs_val[j]); + + addr_ret->prefix = addr.prefix; + addr_ret->type = addr.type; + + if (addr.addr) { + char **addr_p = NULL; + if (VIR_ALLOC(addr_p) < 0) + goto no_memory; + *addr_p = strdup(addr.addr); + if (!*addr_p) { + VIR_FREE(addr_p); + goto no_memory; + } + addr_ret->addr = addr_p; + } + + if (addr.dstaddr) { + char **addr_p = NULL; + if (VIR_ALLOC(addr_p) < 0) + goto no_memory; + *addr_p = strdup(addr.dstaddr); + if (!*addr_p) { + VIR_FREE(addr_p); + goto no_memory; + } + addr_ret->dstaddr = addr_p; + } + } + } + + return 0; + +no_memory: + virReportOOMError(); + for (i = 0; i < ret->ifaces.ifaces_len; i++) { + remote_domain_interface tmp_ret = ret->ifaces.ifaces_val[i]; + + VIR_FREE(tmp_ret.name); + VIR_FREE(tmp_ret.hwaddr); + for (j = 0; j < tmp_ret.ip_addrs.ip_addrs_len; j++) { + VIR_FREE(tmp_ret.ip_addrs.ip_addrs_val[j].addr); + VIR_FREE(tmp_ret.ip_addrs.ip_addrs_val[j].dstaddr); + } + } + VIR_FREE(ret->ifaces.ifaces_val); + + return -1; +} + +static int +remoteDispatchDomainInterfacesAddresses(virNetServerPtr server ATTRIBUTE_UNUSED, + virNetServerClientPtr client, + virNetMessagePtr msg ATTRIBUTE_UNUSED, + virNetMessageErrorPtr rerr, + remote_domain_interfaces_addresses_args *args, + remote_domain_interfaces_addresses_ret *ret) +{ + int rv = -1; + virDomainPtr dom = NULL; + virDomainInterfacePtr *ifaces = NULL; + int ifacesCount = 0; + struct daemonClientPrivate *priv = virNetServerClientGetPrivateData(client); + + if (!(dom = get_nonnull_domain(priv->conn, args->domain))) + goto cleanup; + + ifacesCount = virDomainInterfacesAddresses(dom, &ifaces, + args->method, + args->flags); + if (ifacesCount < 0) + goto cleanup; + + if (remoteSerializeDomainInterfacesPtr(ifaces, ifacesCount, ret) < 0) + goto cleanup; + + rv = 0; + +cleanup: + if (rv < 0) + virNetMessageSaveError(rerr); + if (dom) + virDomainFree(dom); + + while (ifacesCount > 0) + virDomainInterfaceFree(ifaces[--ifacesCount]); + VIR_FREE(ifaces); + return rv; +} diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index ae861cc..7290f30 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -5834,6 +5834,99 @@ done: return rv; } +static int +remoteDomainInterfacesAddresses(virDomainPtr dom, + virDomainInterfacePtr **ifaces, + unsigned int method, + unsigned int flags) +{ + int rv = -1; + remote_domain_interfaces_addresses_args args; + remote_domain_interfaces_addresses_ret ret; + struct private_data *priv = dom->conn->privateData; + int i, j; + + *ifaces = NULL; + + memset(&ret, 0, sizeof(ret)); + make_nonnull_domain(&args.domain, dom); + args.method = method; + args.flags = flags; + + remoteDriverLock(priv); + + if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_INTERFACES_ADDRESSES, + (xdrproc_t)xdr_remote_domain_interfaces_addresses_args, + (char *)&args, + (xdrproc_t)xdr_remote_domain_interfaces_addresses_ret, + (char *)&ret) == -1) + goto cleanup; + + if (!ret.ifaces.ifaces_len) { + rv = 0; + goto cleanup; + } + + if (VIR_ALLOC_N(*ifaces, ret.ifaces.ifaces_len * sizeof(virDomainInterfacePtr)) < 0) + goto no_memory; + + for (i = 0; i < ret.ifaces.ifaces_len; i++) { + virDomainInterfacePtr tmp = NULL; + remote_domain_interface tmp_ret = ret.ifaces.ifaces_val[i]; + + if (VIR_ALLOC(tmp) < 0) + goto no_memory; + + (*ifaces)[i] = tmp; + + if (!(tmp->name = strdup(tmp_ret.name))) + goto no_memory; + + if (tmp_ret.hwaddr && + !(tmp->hwaddr = strdup(*tmp_ret.hwaddr))) + goto no_memory; + + tmp->flags = tmp_ret.flags; + + if (!tmp_ret.ip_addrs.ip_addrs_len) + continue; + + if (VIR_ALLOC_N(tmp->ip_addrs, tmp_ret.ip_addrs.ip_addrs_len) < 0) + goto no_memory; + + tmp->ip_addrs_count = tmp_ret.ip_addrs.ip_addrs_len; + for (j = 0; j < tmp->ip_addrs_count; j++) { + virDomainIPAddressPtr addr = &(tmp->ip_addrs[j]); + remote_domain_ip_addrs addr_ret = tmp_ret.ip_addrs.ip_addrs_val[j]; + + addr->prefix = addr_ret.prefix; + addr->type = addr_ret.type; + if (addr_ret.addr && + !(addr->addr = strdup(*addr_ret.addr))) + goto no_memory; + + if (addr_ret.dstaddr && + !(addr->dstaddr = strdup(*addr_ret.dstaddr))) + goto no_memory; + } + } + + rv = ret.ifaces.ifaces_len; + +cleanup: + remoteDriverUnlock(priv); + xdr_free((xdrproc_t)xdr_remote_domain_interfaces_addresses_ret, + (char *) &ret); + return rv; + +no_memory: + virReportOOMError(); + for (i = 0; i < ret.ifaces.ifaces_len; i++) + virDomainInterfaceFree((*ifaces)[i]); + VIR_FREE(*ifaces); + goto cleanup; +} + static void remoteDomainEventQueue(struct private_data *priv, virDomainEventPtr event) { @@ -6153,6 +6246,7 @@ static virDriver remote_driver = { .nodeGetMemoryParameters = remoteNodeGetMemoryParameters, /* 0.10.2 */ .nodeGetCPUMap = remoteNodeGetCPUMap, /* 1.0.0 */ .domainFSTrim = remoteDomainFSTrim, /* 1.0.1 */ + .domainInterfacesAddresses = remoteDomainInterfacesAddresses, /* 1.0.2 */ }; static virNetworkDriver network_driver = { diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index bdad9f0..bd15107 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -2696,6 +2696,30 @@ struct remote_domain_fstrim_args { unsigned int flags; }; +struct remote_domain_ip_addrs { + int type; + remote_string addr; + int prefix; + remote_string dstaddr; +}; + +struct remote_domain_interface { + remote_nonnull_string name; + unsigned int flags; + remote_string hwaddr; + remote_domain_ip_addrs ip_addrs<>; +}; + +struct remote_domain_interfaces_addresses_args { + remote_nonnull_domain domain; + unsigned int method; + unsigned int flags; +}; + +struct remote_domain_interfaces_addresses_ret { + remote_domain_interface ifaces<>; +}; + /*----- Protocol. -----*/ /* Define the program number, protocol version and procedure numbers here. */ @@ -3042,7 +3066,8 @@ enum remote_procedure { REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND_DISK = 292, /* autogen autogen */ REMOTE_PROC_NODE_GET_CPU_MAP = 293, /* skipgen skipgen */ REMOTE_PROC_DOMAIN_FSTRIM = 294, /* autogen autogen */ - REMOTE_PROC_DOMAIN_SEND_PROCESS_SIGNAL = 295 /* autogen autogen */ + REMOTE_PROC_DOMAIN_SEND_PROCESS_SIGNAL = 295, /* autogen autogen */ + REMOTE_PROC_DOMAIN_INTERFACES_ADDRESSES = 296 /* skipgen skipgen */ /* * Notice how the entries are grouped in sets of 10 ? diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs index e7d05b8..b481f4f 100644 --- a/src/remote_protocol-structs +++ b/src/remote_protocol-structs @@ -2151,6 +2151,32 @@ struct remote_domain_fstrim_args { uint64_t minimum; u_int flags; }; +struct remote_domain_ip_addrs { + int type; + remote_string addr; + int prefix; + remote_string dstaddr; +}; +struct remote_domain_interface { + remote_nonnull_string name; + u_int flags; + remote_string hwaddr; + struct { + u_int ip_addrs_len; + remote_domain_ip_addrs * ip_addrs_val; + } ip_addrs; +}; +struct remote_domain_interfaces_addresses_args { + remote_nonnull_domain domain; + u_int method; + u_int flags; +}; +struct remote_domain_interfaces_addresses_ret { + struct { + u_int ifaces_len; + remote_domain_interface * ifaces_val; + } ifaces; +}; enum remote_procedure { REMOTE_PROC_OPEN = 1, REMOTE_PROC_CLOSE = 2, @@ -2447,4 +2473,5 @@ enum remote_procedure { REMOTE_PROC_NODE_GET_CPU_MAP = 293, REMOTE_PROC_DOMAIN_FSTRIM = 294, REMOTE_PROC_DOMAIN_SEND_PROCESS_SIGNAL = 295, + REMOTE_PROC_DOMAIN_INTERFACES_ADDRESSES = 296, }; -- 1.8.0.2

--- examples/python/Makefile.am | 2 +- examples/python/README | 1 + examples/python/domipaddrs.py | 50 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 52 insertions(+), 1 deletion(-) create mode 100755 examples/python/domipaddrs.py diff --git a/examples/python/Makefile.am b/examples/python/Makefile.am index b04d126..b51f729 100644 --- a/examples/python/Makefile.am +++ b/examples/python/Makefile.am @@ -4,4 +4,4 @@ EXTRA_DIST= \ README \ consolecallback.py \ - dominfo.py domrestore.py domsave.py domstart.py esxlist.py + dominfo.py domrestore.py domsave.py domstart.py esxlist.py domipaddrs.py diff --git a/examples/python/README b/examples/python/README index f4db76c..d895740 100644 --- a/examples/python/README +++ b/examples/python/README @@ -10,6 +10,7 @@ domsave.py - save all running domU's into a directory domrestore.py - restore domU's from their saved files in a directory esxlist.py - list active domains of an VMware ESX host and print some info. also demonstrates how to use the libvirt.openAuth() method +domipaddrs.py - print domain interfaces among with their HW and IP addresses The XML files in this directory are examples of the XML format that libvirt expects, and will have to be adapted for your setup. They are only needed diff --git a/examples/python/domipaddrs.py b/examples/python/domipaddrs.py new file mode 100755 index 0000000..82c5774 --- /dev/null +++ b/examples/python/domipaddrs.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python +# domipaddrds - print IP addresses for running domain + +import libvirt +import sys + +def usage(): + print "Usage: %s [URI] DOMAIN" % sys.argv[0] + print " Print IP addresses assigned to domain interfaces" + +uri = None +name = None +args = len(sys.argv) + +if args == 2: + name = sys.argv[1] +elif args == 3: + uri = sys.argv[1] + name = sys.argv[2] +else: + usage() + sys.exit(2) + +conn = libvirt.openReadOnly(uri) +if conn == None: + print "Unable to open connection to libvirt" + sys.exit(1) + +try: + dom = conn.lookupByName(name) +except libvirt.libvirtError: + print "Domain %s not found" % name + sys.exit(0) + +ifaces = dom.interfacesAddresses(libvirt.VIR_DOMAIN_INTERFACE_ADDRS_DEFAULT, 0) +if (ifaces == None): + print "Failed to get domain interfaces" + sys.exit(0) + +print " {0:10} {1:17} {2}".format("Interface", "HW address", "IP Address") + +for (name, val) in ifaces.iteritems(): + print " {0:10} {1:17}".format(name, val['hwaddr']), + + if (val['ip_addrs'] <> None): + print " ", + for addr in val['ip_addrs']: + print "{0}/{1} ".format(addr['addr'], addr['prefix']), + + print -- 1.8.0.2