Coverage report for src/proxy_internal.c.gcov
-: 0:Source:proxy_internal.c
-: 0:Graph:./libvirt_la-proxy_internal.gcno
-: 0:Data:./libvirt_la-proxy_internal.gcda
-: 0:Runs:1
-: 0:Programs:1
-: 1:/*
-: 2: * proxy_client.c: client side of the communication with the libvirt proxy.
-: 3: *
-: 4: * Copyright (C) 2006 Red Hat, Inc.
-: 5: *
-: 6: * See COPYING.LIB for the License of this software
-: 7: *
-: 8: * Daniel Veillard <veillard@redhat.com>
-: 9: */
-: 10:
-: 11:#include <stdio.h>
-: 12:#include <stdlib.h>
-: 13:#include <unistd.h>
-: 14:#include <errno.h>
-: 15:#include <fcntl.h>
-: 16:#include <sys/types.h>
-: 17:#include <sys/poll.h>
-: 18:#include <sys/socket.h>
-: 19:#include <sys/un.h>
-: 20:#include <sys/wait.h>
-: 21:#include "internal.h"
-: 22:#include "driver.h"
-: 23:#include "proxy_internal.h"
-: 24:
-: 25:#define STANDALONE
-: 26:
-: 27:static int debug = 0;
-: 28:
-: 29:static int xenProxyClose(virConnectPtr conn);
-: 30:static int xenProxyOpen(virConnectPtr conn, const char *name, int flags);
-: 31:static int xenProxyGetVersion(virConnectPtr conn, unsigned long *hvVer);
-: 32:static int xenProxyNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info);
-: 33:static int xenProxyListDomains(virConnectPtr conn, int *ids, int maxids);
-: 34:static int xenProxyNumOfDomains(virConnectPtr conn);
-: 35:static virDomainPtr xenProxyLookupByID(virConnectPtr conn, int id);
-: 36:static virDomainPtr xenProxyLookupByUUID(virConnectPtr conn,
-: 37: const unsigned char *uuid);
-: 38:static virDomainPtr xenProxyDomainLookupByName(virConnectPtr conn,
-: 39: const char *domname);
-: 40:static unsigned long xenProxyDomainGetMaxMemory(virDomainPtr domain);
-: 41:static int xenProxyDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info);
-: 42:static char *xenProxyDomainDumpXML(virDomainPtr domain, int flags);
-: 43:
-: 44:static virDriver xenProxyDriver = {
-: 45: VIR_DRV_XEN_PROXY,
-: 46: "XenProxy",
-: 47: 0,
-: 48: NULL, /* init */
-: 49: xenProxyOpen, /* open */
-: 50: xenProxyClose, /* close */
-: 51: NULL, /* type */
-: 52: xenProxyGetVersion, /* version */
-: 53: xenProxyNodeGetInfo, /* nodeGetInfo */
-: 54: xenProxyListDomains, /* listDomains */
-: 55: xenProxyNumOfDomains, /* numOfDomains */
-: 56: NULL, /* domainCreateLinux */
-: 57: xenProxyLookupByID, /* domainLookupByID */
-: 58: xenProxyLookupByUUID, /* domainLookupByUUID */
-: 59: xenProxyDomainLookupByName, /* domainLookupByName */
-: 60: NULL, /* domainSuspend */
-: 61: NULL, /* domainResume */
-: 62: NULL, /* domainShutdown */
-: 63: NULL, /* domainReboot */
-: 64: NULL, /* domainDestroy */
-: 65: NULL, /* domainFree */
-: 66: NULL, /* domainGetName */
-: 67: NULL, /* domainGetID */
-: 68: NULL, /* domainGetUUID */
-: 69: NULL, /* domainGetOSType */
-: 70: xenProxyDomainGetMaxMemory, /* domainGetMaxMemory */
-: 71: NULL, /* domainSetMaxMemory */
-: 72: NULL, /* domainSetMemory */
-: 73: xenProxyDomainGetInfo, /* domainGetInfo */
-: 74: NULL, /* domainSave */
-: 75: NULL, /* domainRestore */
-: 76: NULL, /* domainSetVcpus */
-: 77: NULL, /* domainPinVcpu */
-: 78: NULL, /* domainGetVcpus */
-: 79: xenProxyDomainDumpXML, /* domainDumpXML */
-: 80:};
-: 81:
-: 82:/**
-: 83: * xenProxyRegister:
-: 84: *
-: 85: * Registers the xenHypervisor driver
-: 86: */
-: 87:void xenProxyRegister(void)
function xenProxyRegister called 0 returned 0% blocks executed 0%
#####: 88:{
#####: 89: virRegisterDriver(&xenProxyDriver);
call 0 never executed
#####: 90:}
-: 91:/************************************************************************
-: 92: * *
-: 93: * Error handling *
-: 94: * *
-: 95: ************************************************************************/
-: 96:
-: 97:/**
-: 98: * virProxyError:
-: 99: * @conn: the connection if available
-: 100: * @error: the error noumber
-: 101: * @info: extra information string
-: 102: *
-: 103: * Handle an error at the xend daemon interface
-: 104: */
-: 105:static void
-: 106:virProxyError(virConnectPtr conn, virErrorNumber error, const char *info)
function virProxyError called 0 returned 0% blocks executed 0%
#####: 107:{
-: 108: const char *errmsg;
-: 109:
#####: 110: if (error == VIR_ERR_OK)
branch 0 never executed
branch 1 never executed
#####: 111: return;
-: 112:
#####: 113: errmsg = __virErrorMsg(error, info);
call 0 never executed
#####: 114: __virRaiseError(conn, NULL, VIR_FROM_PROXY, error, VIR_ERR_ERROR,
call 0 never executed
-: 115: errmsg, info, NULL, 0, 0, errmsg, info);
-: 116:}
-: 117:
-: 118:/************************************************************************
-: 119: * *
-: 120: * Automatic startup of the proxy server if it is not running *
-: 121: * *
-: 122: ************************************************************************/
-: 123:/**
-: 124: * virProxyFindServerPath:
-: 125: *
-: 126: * Tries to find the path to the gam_server binary.
-: 127: *
-: 128: * Returns path on success or NULL in case of error.
-: 129: */
-: 130:static const char *
-: 131:virProxyFindServerPath(void)
function virProxyFindServerPath called 0 returned 0% blocks executed 0%
#####: 132:{
-: 133: static const char *serverPaths[] = {
-: 134: BINDIR "/libvirt_proxy",
-: 135: "/usr/bin/libvirt_proxy_dbg",
-: 136: NULL
-: 137: };
-: 138: int i;
#####: 139: const char *debugProxy = getenv("LIBVIRT_DEBUG_PROXY");
call 0 never executed
-: 140:
#####: 141: if (debugProxy)
branch 0 never executed
branch 1 never executed
#####: 142: return(debugProxy);
-: 143:
#####: 144: for (i = 0; serverPaths[i]; i++) {
branch 0 never executed
branch 1 never executed
#####: 145: if (access(serverPaths[i], X_OK | R_OK) == 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 146: return serverPaths[i];
-: 147: }
-: 148: }
#####: 149: return NULL;
-: 150:}
-: 151:
-: 152:/**
-: 153: * virProxyForkServer:
-: 154: *
-: 155: * Forks and try to launch the proxy server processing the requests for
-: 156: * libvirt when communicating with Xen.
-: 157: *
-: 158: * Returns 0 in case of success or -1 in case of detected error.
-: 159: */
-: 160:static int
-: 161:virProxyForkServer(void)
function virProxyForkServer called 0 returned 0% blocks executed 0%
#####: 162:{
#####: 163: const char *proxyPath = virProxyFindServerPath();
call 0 never executed
-: 164: int ret, pid, status;
-: 165:
#####: 166: if (!proxyPath) {
branch 0 never executed
branch 1 never executed
#####: 167: fprintf(stderr, "failed to find libvirt_proxy\n");
call 0 never executed
#####: 168: return(-1);
-: 169: }
-: 170:
#####: 171: if (debug)
branch 0 never executed
branch 1 never executed
#####: 172: fprintf(stderr, "Asking to launch %s\n", proxyPath);
call 0 never executed
-: 173:
-: 174: /* Become a daemon */
#####: 175: pid = fork();
call 0 never executed
#####: 176: if (pid == 0) {
branch 0 never executed
branch 1 never executed
-: 177: long open_max;
-: 178: long i;
-: 179:
-: 180: /* don't hold open fd opened from the client of the library */
#####: 181: open_max = sysconf (_SC_OPEN_MAX);
call 0 never executed
#####: 182: for (i = 0; i < open_max; i++)
branch 0 never executed
branch 1 never executed
#####: 183: fcntl (i, F_SETFD, FD_CLOEXEC);
call 0 never executed
-: 184:
#####: 185: setsid();
call 0 never executed
#####: 186: if (fork() == 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 187: execl(proxyPath, proxyPath, NULL);
call 0 never executed
#####: 188: fprintf(stderr, "failed to exec %s\n", proxyPath);
call 0 never executed
-: 189: }
-: 190: /*
-: 191: * calling exit() generate troubles for termination handlers
-: 192: */
#####: 193: _exit(0);
call 0 never executed
-: 194: }
-: 195:
-: 196: /*
-: 197: * do a waitpid on the intermediate process to avoid zombies.
-: 198: */
#####: 199:retry_wait:
#####: 200: ret = waitpid(pid, &status, 0);
call 0 never executed
#####: 201: if (ret < 0) {
branch 0 never executed
branch 1 never executed
#####: 202: if (errno == EINTR)
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 203: goto retry_wait;
-: 204: }
-: 205:
#####: 206: return (0);
-: 207:}
-: 208:
-: 209:/************************************************************************
-: 210: * *
-: 211: * Processing of client sockets *
-: 212: * *
-: 213: ************************************************************************/
-: 214:
-: 215:/**
-: 216: * virProxyOpenClientSocket:
-: 217: * @path: the fileame for the socket
-: 218: *
-: 219: * try to connect to the socket open by libvirt_proxy
-: 220: *
-: 221: * Returns the associated file descriptor or -1 in case of failure
-: 222: */
-: 223:static int
function virProxyOpenClientSocket called 0 returned 0% blocks executed 0%
#####: 224:virProxyOpenClientSocket(const char *path) {
-: 225: int fd;
-: 226: struct sockaddr_un addr;
#####: 227: int trials = 0;
-: 228:
#####: 229:retry:
#####: 230: fd = socket(PF_UNIX, SOCK_STREAM, 0);
call 0 never executed
#####: 231: if (fd < 0) {
branch 0 never executed
branch 1 never executed
#####: 232: return(-1);
-: 233: }
-: 234:
-: 235: /*
-: 236: * Abstract socket do not hit the filesystem, way more secure and
-: 237: * garanteed to be atomic
-: 238: */
#####: 239: memset(&addr, 0, sizeof(addr));
call 0 never executed
#####: 240: addr.sun_family = AF_UNIX;
#####: 241: addr.sun_path[0] = '\0';
#####: 242: strncpy(&addr.sun_path[1], path, (sizeof(addr) - 4) - 2);
call 0 never executed
-: 243:
-: 244: /*
-: 245: * now bind the socket to that address and listen on it
-: 246: */
#####: 247: if (connect(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 248: close(fd);
call 0 never executed
#####: 249: if (trials < 3) {
branch 0 never executed
branch 1 never executed
#####: 250: if (virProxyForkServer() < 0)
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 251: return(-1);
#####: 252: trials++;
#####: 253: usleep(5000 * trials * trials);
call 0 never executed
#####: 254: goto retry;
-: 255: }
#####: 256: return (-1);
-: 257: }
-: 258:
#####: 259: if (debug > 0)
branch 0 never executed
branch 1 never executed
#####: 260: fprintf(stderr, "connected to unix socket %s via %d\n", path, fd);
call 0 never executed
-: 261:
#####: 262: return (fd);
-: 263:}
-: 264:
-: 265:/**
-: 266: * virProxyCloseClientSocket:
-: 267: * @fd: the file descriptor for the socket
-: 268: *
-: 269: * Close the socket from that client
-: 270: *
-: 271: * Returns 0 in case of success and -1 in case of error
-: 272: */
-: 273:static int
function virProxyCloseClientSocket called 0 returned 0% blocks executed 0%
#####: 274:virProxyCloseClientSocket(int fd) {
-: 275: int ret;
-: 276:
#####: 277: if (fd < 0)
branch 0 never executed
branch 1 never executed
#####: 278: return(-1);
-: 279:
#####: 280: ret = close(fd);
call 0 never executed
#####: 281: if (ret != 0)
branch 0 never executed
branch 1 never executed
#####: 282: fprintf(stderr, "Failed to close socket %d\n", fd);
call 0 never executed
#####: 283: else if (debug > 0)
branch 0 never executed
branch 1 never executed
#####: 284: fprintf(stderr, "Closed socket %d\n", fd);
call 0 never executed
#####: 285: return(ret);
-: 286:}
-: 287:
-: 288:/**
-: 289: * virProxyReadClientSocket:
-: 290: * @fd: the socket
-: 291: * @buffer: the target memory area
-: 292: * @len: the lenght in bytes
-: 293: * @quiet: quiet access
-: 294: *
-: 295: * Process a read from a client socket
-: 296: *
-: 297: * Returns the number of byte read or -1 in case of error.
-: 298: */
-: 299:static int
function virProxyReadClientSocket called 0 returned 0% blocks executed 0%
#####: 300:virProxyReadClientSocket(int fd, char *buffer, int len, int quiet) {
-: 301: int ret;
-: 302:
#####: 303: if ((fd < 0) || (buffer == NULL) || (len < 0))
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 304: return(-1);
-: 305:
#####: 306:retry:
#####: 307: ret = read(fd, buffer, len);
call 0 never executed
#####: 308: if (ret < 0) {
branch 0 never executed
branch 1 never executed
#####: 309: if (errno == EINTR) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 310: if (debug > 0)
branch 0 never executed
branch 1 never executed
#####: 311: fprintf(stderr, "read socket %d interrupted\n", fd);
call 0 never executed
-: 312: goto retry;
-: 313: }
#####: 314: if (!quiet)
branch 0 never executed
branch 1 never executed
#####: 315: fprintf(stderr, "Failed to read socket %d\n", fd);
call 0 never executed
#####: 316: return(-1);
-: 317: }
-: 318:
#####: 319: if (debug)
branch 0 never executed
branch 1 never executed
#####: 320: fprintf(stderr, "read %d bytes from socket %d\n",
call 0 never executed
-: 321: ret, fd);
#####: 322: return(ret);
-: 323:}
-: 324:
-: 325:/**
-: 326: * virProxyWriteClientSocket:
-: 327: * @fd: the socket
-: 328: * @data: the data
-: 329: * @len: the lenght of data in bytes
-: 330: *
-: 331: * Process a read from a client socket
-: 332: */
-: 333:static int
function virProxyWriteClientSocket called 0 returned 0% blocks executed 0%
#####: 334:virProxyWriteClientSocket(int fd, const char *data, int len) {
-: 335: int ret;
-: 336:
#####: 337: if ((fd < 0) || (data == NULL) || (len < 0))
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 338: return(-1);
-: 339:
#####: 340:retry:
#####: 341: ret = write(fd, data, len);
call 0 never executed
#####: 342: if (ret < 0) {
branch 0 never executed
branch 1 never executed
#####: 343: if (errno == EINTR) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 344: if (debug > 0)
branch 0 never executed
branch 1 never executed
#####: 345: fprintf(stderr, "write socket %d, %d bytes interrupted\n",
call 0 never executed
-: 346: fd, len);
-: 347: goto retry;
-: 348: }
#####: 349: fprintf(stderr, "Failed to write to socket %d\n", fd);
call 0 never executed
#####: 350: return(-1);
-: 351: }
#####: 352: if (debug)
branch 0 never executed
branch 1 never executed
#####: 353: fprintf(stderr, "wrote %d bytes to socket %d\n",
call 0 never executed
-: 354: len, fd);
-: 355:
#####: 356: return(0);
-: 357:}
-: 358:
-: 359:/************************************************************************
-: 360: * *
-: 361: * Proxy commands processing *
-: 362: * *
-: 363: ************************************************************************/
-: 364:
-: 365:/**
-: 366: * xenProxyClose:
-: 367: * @conn: pointer to the hypervisor connection
-: 368: *
-: 369: * Shutdown the Xen proxy communication layer
-: 370: */
-: 371:static int
function xenProxyClose called 0 returned 0% blocks executed 0%
#####: 372:xenProxyClose(virConnectPtr conn) {
#####: 373: if ((conn == NULL) || (conn->proxy < 0))
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 374: return(-1);
#####: 375: virProxyCloseClientSocket(conn->proxy);
call 0 never executed
#####: 376: conn->proxy = -1;
#####: 377: return (0);
-: 378:}
-: 379:
-: 380:static int
-: 381:xenProxyCommand(virConnectPtr conn, virProxyPacketPtr request,
function xenProxyCommand called 0 returned 0% blocks executed 0%
#####: 382: virProxyFullPacketPtr answer, int quiet) {
-: 383: static int serial = 0;
-: 384: int ret;
#####: 385: virProxyPacketPtr res = NULL;
-: 386:
#####: 387: if ((conn == NULL) || (conn->proxy < 0))
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 388: return(-1);
-: 389:
-: 390: /*
-: 391: * normal communication serial numbers are in 0..4095
-: 392: */
#####: 393: ++serial;
#####: 394: if (serial >= 4096)
branch 0 never executed
branch 1 never executed
#####: 395: serial = 0;
#####: 396: request->version = PROXY_PROTO_VERSION;
#####: 397: request->serial = serial;
#####: 398: ret = virProxyWriteClientSocket(conn->proxy, (const char *) request,
call 0 never executed
-: 399: request->len);
#####: 400: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 401: return(-1);
#####: 402:retry:
#####: 403: if (answer == NULL) {
branch 0 never executed
branch 1 never executed
-: 404: /* read in situ */
#####: 405: ret = virProxyReadClientSocket(conn->proxy, (char *) request,
call 0 never executed
-: 406: sizeof(virProxyPacket), quiet);
#####: 407: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 408: return(-1);
#####: 409: if (ret != sizeof(virProxyPacket)) {
branch 0 never executed
branch 1 never executed
#####: 410: fprintf(stderr,
call 0 never executed
-: 411: "Communication error with proxy: got %d bytes of %d\n",
-: 412: ret, (int) sizeof(virProxyPacket));
#####: 413: xenProxyClose(conn);
call 0 never executed
#####: 414: return(-1);
-: 415: }
#####: 416: res = request;
#####: 417: if (res->len != sizeof(virProxyPacket)) {
branch 0 never executed
branch 1 never executed
#####: 418: fprintf(stderr,
call 0 never executed
-: 419: "Communication error with proxy: expected %d bytes got %d\n",
-: 420: (int) sizeof(virProxyPacket), res->len);
#####: 421: xenProxyClose(conn);
call 0 never executed
#####: 422: return(-1);
-: 423: }
-: 424: } else {
-: 425: /* read in packet provided */
#####: 426: ret = virProxyReadClientSocket(conn->proxy, (char *) answer,
call 0 never executed
-: 427: sizeof(virProxyPacket), quiet);
#####: 428: if (ret < 0)
branch 0 never executed
branch 1 never executed
#####: 429: return(-1);
#####: 430: if (ret != sizeof(virProxyPacket)) {
branch 0 never executed
branch 1 never executed
#####: 431: fprintf(stderr,
call 0 never executed
-: 432: "Communication error with proxy: got %d bytes of %d\n",
-: 433: ret, (int) sizeof(virProxyPacket));
#####: 434: xenProxyClose(conn);
call 0 never executed
#####: 435: return(-1);
-: 436: }
#####: 437: res = (virProxyPacketPtr) answer;
#####: 438: if ((res->len < sizeof(virProxyPacket)) ||
branch 0 never executed
branch 1 never executed
-: 439: (res->len > sizeof(virProxyFullPacket))) {
#####: 440: fprintf(stderr,
call 0 never executed
-: 441: "Communication error with proxy: got %d bytes packet\n",
-: 442: res->len);
#####: 443: xenProxyClose(conn);
call 0 never executed
#####: 444: return(-1);
-: 445: }
#####: 446: if (res->len > sizeof(virProxyPacket)) {
branch 0 never executed
branch 1 never executed
#####: 447: ret = virProxyReadClientSocket(conn->proxy,
call 0 never executed
-: 448: (char *) &(answer->extra.arg[0]),
-: 449: res->len - ret, quiet);
#####: 450: if (ret != (int) (res->len - sizeof(virProxyPacket))) {
branch 0 never executed
branch 1 never executed
#####: 451: fprintf(stderr,
call 0 never executed
-: 452: "Communication error with proxy: got %d bytes of %d\n",
-: 453: ret, (int) sizeof(virProxyPacket));
#####: 454: xenProxyClose(conn);
call 0 never executed
#####: 455: return(-1);
-: 456: }
-: 457: }
-: 458: }
-: 459: /*
-: 460: * do more checks on the incoming packet.
-: 461: */
#####: 462: if ((res == NULL) || (res->version != PROXY_PROTO_VERSION) ||
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
branch 4 never executed
branch 5 never executed
-: 463: (res->len < sizeof(virProxyPacket))) {
#####: 464: fprintf(stderr,
call 0 never executed
-: 465: "Communication error with proxy: malformed packet\n");
#####: 466: xenProxyClose(conn);
call 0 never executed
#####: 467: return(-1);
-: 468: }
#####: 469: if (res->serial != serial) {
branch 0 never executed
branch 1 never executed
#####: 470: TODO /* Asynchronous communication */
call 0 never executed
#####: 471: fprintf(stderr, "gor asynchronous packet number %d\n", res->serial);
call 0 never executed
#####: 472: goto retry;
-: 473: }
#####: 474: return(0);
-: 475:}
-: 476:
-: 477:/**
-: 478: * xenProxyOpen:
-: 479: * @conn: pointer to the hypervisor connection
-: 480: * @name: URL for the target, NULL for local
-: 481: * @flags: combination of virDrvOpenFlag(s)
-: 482: *
-: 483: * Try to initialize the Xen proxy communication layer
-: 484: * This can be opened only for a read-only kind of access
-: 485: *
-: 486: * Returns 0 in case of success, and -1 in case of failure
-: 487: */
-: 488:int
-: 489:xenProxyOpen(virConnectPtr conn, const char *name, int flags)
function xenProxyOpen called 0 returned 0% blocks executed 0%
#####: 490:{
-: 491: virProxyPacket req;
-: 492: int ret;
-: 493: int fd;
-: 494:
#####: 495: if ((name != NULL) && (strcasecmp(name, "xen")))
branch 0 never executed
branch 1 never executed
call 2 never executed
branch 3 never executed
branch 4 never executed
#####: 496: return(-1);
#####: 497: if (!(flags & VIR_DRV_OPEN_RO))
branch 0 never executed
branch 1 never executed
#####: 498: return(-1);
-: 499:
#####: 500: conn->proxy = -1;
#####: 501: fd = virProxyOpenClientSocket(PROXY_SOCKET_PATH);
call 0 never executed
#####: 502: if (fd < 0) {
branch 0 never executed
branch 1 never executed
#####: 503: if (!(flags & VIR_DRV_OPEN_QUIET))
branch 0 never executed
branch 1 never executed
#####: 504: virProxyError(conn, VIR_ERR_NO_XEN, PROXY_SOCKET_PATH);
call 0 never executed
#####: 505: return(-1);
-: 506: }
#####: 507: conn->proxy = fd;
-: 508:
#####: 509: memset(&req, 0, sizeof(req));
call 0 never executed
#####: 510: req.command = VIR_PROXY_NONE;
#####: 511: req.len = sizeof(req);
#####: 512: ret = xenProxyCommand(conn, &req, NULL, 1);
call 0 never executed
#####: 513: if ((ret < 0) || (req.command != VIR_PROXY_NONE)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 514: if (!(flags & VIR_DRV_OPEN_QUIET))
branch 0 never executed
branch 1 never executed
#####: 515: virProxyError(conn, VIR_ERR_OPERATION_FAILED, __FUNCTION__);
call 0 never executed
#####: 516: xenProxyClose(conn);
call 0 never executed
#####: 517: return(-1);
-: 518: }
#####: 519: return(0);
-: 520:}
-: 521:
-: 522:/************************************************************************
-: 523: * *
-: 524: * Driver entry points *
-: 525: * *
-: 526: ************************************************************************/
-: 527:
-: 528:/**
-: 529: * xenProxyGetVersion:
-: 530: * @conn: pointer to the Xen Daemon block
-: 531: * @hvVer: return value for the version of the running hypervisor (OUT)
-: 532: *
-: 533: * Get the version level of the Hypervisor running.
-: 534: *
-: 535: * Returns -1 in case of error, 0 otherwise. if the version can't be
-: 536: * extracted by lack of capacities returns 0 and @hvVer is 0, otherwise
-: 537: * @hvVer value is major * 1,000,000 + minor * 1,000 + release
-: 538: */
-: 539:static int
-: 540:xenProxyGetVersion(virConnectPtr conn, unsigned long *hvVer)
function xenProxyGetVersion called 0 returned 0% blocks executed 0%
#####: 541:{
-: 542: virProxyPacket req;
-: 543: int ret;
-: 544:
#####: 545: if (!VIR_IS_CONNECT(conn)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 546: virProxyError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
call 0 never executed
#####: 547: return (-1);
-: 548: }
#####: 549: if (hvVer == NULL) {
branch 0 never executed
branch 1 never executed
#####: 550: virProxyError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
call 0 never executed
#####: 551: return (-1);
-: 552: }
#####: 553: memset(&req, 0, sizeof(req));
call 0 never executed
#####: 554: req.command = VIR_PROXY_VERSION;
#####: 555: req.len = sizeof(req);
#####: 556: ret = xenProxyCommand(conn, &req, NULL, 0);
call 0 never executed
#####: 557: if (ret < 0) {
branch 0 never executed
branch 1 never executed
#####: 558: xenProxyClose(conn);
call 0 never executed
#####: 559: return(-1);
-: 560: }
#####: 561: *hvVer = req.data.larg;
#####: 562: return(0);
-: 563:}
-: 564:
-: 565:/**
-: 566: * xenProxyListDomains:
-: 567: * @conn: pointer to the hypervisor connection
-: 568: * @ids: array to collect the list of IDs of active domains
-: 569: * @maxids: size of @ids
-: 570: *
-: 571: * Collect the list of active domains, and store their ID in @maxids
-: 572: *
-: 573: * Returns the number of domain found or -1 in case of error
-: 574: */
-: 575:static int
-: 576:xenProxyListDomains(virConnectPtr conn, int *ids, int maxids)
function xenProxyListDomains called 0 returned 0% blocks executed 0%
#####: 577:{
-: 578: virProxyPacket req;
-: 579: virProxyFullPacket ans;
-: 580: int ret;
-: 581: int nb;
-: 582:
#####: 583: if (!VIR_IS_CONNECT(conn)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 584: virProxyError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
call 0 never executed
#####: 585: return (-1);
-: 586: }
#####: 587: if ((ids == NULL) || (maxids <= 0)) {
branch 0 never executed
branch 1 never executed
#####: 588: virProxyError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
call 0 never executed
#####: 589: return (-1);
-: 590: }
#####: 591: memset(&req, 0, sizeof(req));
call 0 never executed
#####: 592: req.command = VIR_PROXY_LIST;
#####: 593: req.len = sizeof(req);
#####: 594: ret = xenProxyCommand(conn, &req, &ans, 0);
call 0 never executed
#####: 595: if (ret < 0) {
branch 0 never executed
branch 1 never executed
#####: 596: xenProxyClose(conn);
call 0 never executed
#####: 597: return(-1);
-: 598: }
#####: 599: nb = ans.data.arg;
#####: 600: if ((nb > 1020) || (nb <= 0) ||
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
branch 4 never executed
branch 5 never executed
-: 601: (ans.len <= sizeof(virProxyPacket)) ||
-: 602: (ans.len > sizeof(virProxyFullPacket))) {
#####: 603: virProxyError(conn, VIR_ERR_OPERATION_FAILED, __FUNCTION__);
call 0 never executed
#####: 604: return(-1);
-: 605: }
#####: 606: if (nb > maxids)
branch 0 never executed
branch 1 never executed
#####: 607: nb = maxids;
#####: 608: memmove(ids, &ans.extra.arg[0], nb * sizeof(int));
call 0 never executed
-: 609:
#####: 610: return(nb);
-: 611:}
-: 612:
-: 613:/**
-: 614: * xenProxyNumOfDomains:
-: 615: * @conn: pointer to the hypervisor connection
-: 616: *
-: 617: * Provides the number of active domains.
-: 618: *
-: 619: * Returns the number of domain found or -1 in case of error
-: 620: */
-: 621:static int
-: 622:xenProxyNumOfDomains(virConnectPtr conn)
function xenProxyNumOfDomains called 0 returned 0% blocks executed 0%
#####: 623:{
-: 624: virProxyPacket req;
-: 625: int ret;
-: 626:
#####: 627: if (!VIR_IS_CONNECT(conn)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 628: virProxyError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
call 0 never executed
#####: 629: return (-1);
-: 630: }
#####: 631: memset(&req, 0, sizeof(req));
call 0 never executed
#####: 632: req.command = VIR_PROXY_NUM_DOMAIN;
#####: 633: req.len = sizeof(req);
#####: 634: ret = xenProxyCommand(conn, &req, NULL, 0);
call 0 never executed
#####: 635: if (ret < 0) {
branch 0 never executed
branch 1 never executed
#####: 636: xenProxyClose(conn);
call 0 never executed
#####: 637: return(-1);
-: 638: }
#####: 639: return(req.data.arg);
-: 640:}
-: 641:
-: 642:
-: 643:/**
-: 644: * xenProxyDomainGetDomMaxMemory:
-: 645: * @conn: pointer to the hypervisor connection
-: 646: * @id: the domain ID number
-: 647: *
-: 648: * Ask the Xen Daemon for the maximum memory allowed for a domain
-: 649: *
-: 650: * Returns the memory size in kilobytes or 0 in case of error.
-: 651: */
-: 652:static unsigned long
-: 653:xenProxyDomainGetDomMaxMemory(virConnectPtr conn, int id)
function xenProxyDomainGetDomMaxMemory called 0 returned 0% blocks executed 0%
#####: 654:{
-: 655: virProxyPacket req;
-: 656: int ret;
-: 657:
#####: 658: if (!VIR_IS_CONNECT(conn)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 659: virProxyError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
call 0 never executed
#####: 660: return (-1);
-: 661: }
#####: 662: memset(&req, 0, sizeof(req));
call 0 never executed
#####: 663: req.command = VIR_PROXY_MAX_MEMORY;
#####: 664: req.data.arg = id;
#####: 665: req.len = sizeof(req);
#####: 666: ret = xenProxyCommand(conn, &req, NULL, 0);
call 0 never executed
#####: 667: if (ret < 0) {
branch 0 never executed
branch 1 never executed
#####: 668: xenProxyClose(conn);
call 0 never executed
#####: 669: return(-1);
-: 670: }
#####: 671: return(req.data.larg);
-: 672:}
-: 673:
-: 674:/**
-: 675: * xenProxyDomainGetMaxMemory:
-: 676: * @domain: pointer to the domain block
-: 677: *
-: 678: * Ask the Xen Daemon for the maximum memory allowed for a domain
-: 679: *
-: 680: * Returns the memory size in kilobytes or 0 in case of error.
-: 681: */
-: 682:static unsigned long
-: 683:xenProxyDomainGetMaxMemory(virDomainPtr domain)
function xenProxyDomainGetMaxMemory called 0 returned 0% blocks executed 0%
#####: 684:{
#####: 685: if (!VIR_IS_CONNECTED_DOMAIN(domain)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
branch 4 never executed
branch 5 never executed
branch 6 never executed
branch 7 never executed
#####: 686: if (domain == NULL)
branch 0 never executed
branch 1 never executed
#####: 687: virProxyError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
call 0 never executed
-: 688: else
#####: 689: virProxyError(domain->conn, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
call 0 never executed
#####: 690: return (0);
-: 691: }
#####: 692: return(xenProxyDomainGetDomMaxMemory(domain->conn, domain->handle));
call 0 never executed
-: 693:}
-: 694:
-: 695:/**
-: 696: * xenProxyDomainGetInfo:
-: 697: * @domain: a domain object
-: 698: * @info: pointer to a virDomainInfo structure allocated by the user
-: 699: *
-: 700: * This method looks up information about a domain and update the
-: 701: * information block provided.
-: 702: *
-: 703: * Returns 0 in case of success, -1 in case of error
-: 704: */
-: 705:static int
-: 706:xenProxyDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info)
function xenProxyDomainGetInfo called 0 returned 0% blocks executed 0%
#####: 707:{
-: 708: virProxyPacket req;
-: 709: virProxyFullPacket ans;
-: 710: int ret;
-: 711:
#####: 712: if (!VIR_IS_CONNECTED_DOMAIN(domain)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
branch 4 never executed
branch 5 never executed
branch 6 never executed
branch 7 never executed
#####: 713: if (domain == NULL)
branch 0 never executed
branch 1 never executed
#####: 714: virProxyError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
call 0 never executed
-: 715: else
#####: 716: virProxyError(domain->conn, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
call 0 never executed
#####: 717: return (0);
-: 718: }
#####: 719: if (info == NULL) {
branch 0 never executed
branch 1 never executed
#####: 720: virProxyError(domain->conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
call 0 never executed
#####: 721: return (-1);
-: 722: }
#####: 723: memset(&req, 0, sizeof(req));
call 0 never executed
#####: 724: req.command = VIR_PROXY_DOMAIN_INFO;
#####: 725: req.data.arg = domain->handle;
#####: 726: req.len = sizeof(req);
#####: 727: ret = xenProxyCommand(domain->conn, &req, &ans, 0);
call 0 never executed
#####: 728: if (ret < 0) {
branch 0 never executed
branch 1 never executed
#####: 729: xenProxyClose(domain->conn);
call 0 never executed
#####: 730: return(-1);
-: 731: }
#####: 732: if (ans.len != sizeof(virProxyPacket) + sizeof(virDomainInfo)) {
branch 0 never executed
branch 1 never executed
#####: 733: virProxyError(domain->conn, VIR_ERR_OPERATION_FAILED, __FUNCTION__);
call 0 never executed
#####: 734: return (-1);
-: 735: }
#####: 736: memmove(info, &ans.extra.dinfo, sizeof(virDomainInfo));
call 0 never executed
-: 737:
#####: 738: return(0);
-: 739:}
-: 740:
-: 741:/**
-: 742: * xenProxyLookupByID:
-: 743: * @conn: pointer to the hypervisor connection
-: 744: * @id: the domain ID number
-: 745: *
-: 746: * Try to find a domain based on the hypervisor ID number
-: 747: *
-: 748: * Returns a new domain object or NULL in case of failure
-: 749: */
-: 750:static virDomainPtr
-: 751:xenProxyLookupByID(virConnectPtr conn, int id)
function xenProxyLookupByID called 0 returned 0% blocks executed 0%
#####: 752:{
-: 753: virProxyPacket req;
-: 754: virProxyFullPacket ans;
-: 755: unsigned char uuid[16];
-: 756: const char *name;
-: 757: int ret;
-: 758: virDomainPtr res;
-: 759:
#####: 760: if (!VIR_IS_CONNECT(conn)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 761: virProxyError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
call 0 never executed
#####: 762: return (NULL);
-: 763: }
#####: 764: if (id < 0) {
branch 0 never executed
branch 1 never executed
#####: 765: virProxyError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
call 0 never executed
#####: 766: return (NULL);
-: 767: }
#####: 768: memset(&req, 0, sizeof(req));
call 0 never executed
#####: 769: req.command = VIR_PROXY_LOOKUP_ID;
#####: 770: req.data.arg = id;
#####: 771: req.len = sizeof(req);
#####: 772: ret = xenProxyCommand(conn, &req, &ans, 0);
call 0 never executed
#####: 773: if (ret < 0) {
branch 0 never executed
branch 1 never executed
#####: 774: xenProxyClose(conn);
call 0 never executed
#####: 775: return(NULL);
-: 776: }
#####: 777: if (ans.data.arg == -1) {
branch 0 never executed
branch 1 never executed
#####: 778: return(NULL);
-: 779: }
#####: 780: memcpy(uuid, &ans.extra.str[0], 16);
call 0 never executed
#####: 781: name = &ans.extra.str[16];
#####: 782: res = virGetDomain(conn, name, uuid);
call 0 never executed
-: 783:
#####: 784: if (res == NULL)
branch 0 never executed
branch 1 never executed
#####: 785: virProxyError(conn, VIR_ERR_NO_MEMORY, "Allocating domain");
call 0 never executed
-: 786: else
#####: 787: res->handle = id;
-: 788:
#####: 789: return(res);
-: 790:}
-: 791:
-: 792:/**
-: 793: * xenProxyLookupByUUID:
-: 794: * @conn: pointer to the hypervisor connection
-: 795: * @uuid: the raw UUID for the domain
-: 796: *
-: 797: * Try to lookup a domain on xend based on its UUID.
-: 798: *
-: 799: * Returns a new domain object or NULL in case of failure
-: 800: */
-: 801:static virDomainPtr
-: 802:xenProxyLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
function xenProxyLookupByUUID called 0 returned 0% blocks executed 0%
#####: 803:{
-: 804: virProxyFullPacket req;
-: 805: const char *name;
-: 806: int ret;
-: 807: virDomainPtr res;
-: 808:
#####: 809: if (!VIR_IS_CONNECT(conn)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 810: virProxyError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
call 0 never executed
#####: 811: return (NULL);
-: 812: }
#####: 813: if (uuid == NULL) {
branch 0 never executed
branch 1 never executed
#####: 814: virProxyError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
call 0 never executed
#####: 815: return (NULL);
-: 816: }
#####: 817: memset(&req, 0, sizeof(virProxyPacket));
call 0 never executed
#####: 818: req.command = VIR_PROXY_LOOKUP_UUID;
#####: 819: req.len = sizeof(virProxyPacket) + 16;
#####: 820: ret = xenProxyCommand(conn, (virProxyPacketPtr) &req, &req, 0);
call 0 never executed
#####: 821: if (ret < 0) {
branch 0 never executed
branch 1 never executed
#####: 822: xenProxyClose(conn);
call 0 never executed
#####: 823: return(NULL);
-: 824: }
#####: 825: if (req.data.arg == -1) {
branch 0 never executed
branch 1 never executed
#####: 826: return(NULL);
-: 827: }
#####: 828: name = &req.extra.str[0];
#####: 829: res = virGetDomain(conn, name, uuid);
call 0 never executed
-: 830:
#####: 831: if (res == NULL)
branch 0 never executed
branch 1 never executed
#####: 832: virProxyError(conn, VIR_ERR_NO_MEMORY, "Allocating domain");
call 0 never executed
-: 833: else
#####: 834: res->handle = req.data.arg;
-: 835:
#####: 836: return(res);
-: 837:}
-: 838:
-: 839:/**
-: 840: * xenProxyDomainLookupByName:
-: 841: * @conn: A xend instance
-: 842: * @name: The name of the domain
-: 843: *
-: 844: * This method looks up information about a domain based on its name
-: 845: *
-: 846: * Returns a new domain object or NULL in case of failure
-: 847: */
-: 848:static virDomainPtr
-: 849:xenProxyDomainLookupByName(virConnectPtr conn, const char *name)
function xenProxyDomainLookupByName called 0 returned 0% blocks executed 0%
#####: 850:{
-: 851: virProxyFullPacket req;
-: 852: int ret, len;
-: 853: virDomainPtr res;
-: 854:
#####: 855: if (!VIR_IS_CONNECT(conn)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 856: virProxyError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
call 0 never executed
#####: 857: return (NULL);
-: 858: }
#####: 859: if (name == NULL) {
branch 0 never executed
branch 1 never executed
#####: 860: virProxyError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
call 0 never executed
#####: 861: return (NULL);
-: 862: }
#####: 863: len = strlen(name);
call 0 never executed
#####: 864: if (len > 1000) {
branch 0 never executed
branch 1 never executed
#####: 865: virProxyError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
call 0 never executed
#####: 866: return (NULL);
-: 867: }
#####: 868: memset(&req, 0, sizeof(virProxyPacket));
call 0 never executed
#####: 869: req.command = VIR_PROXY_LOOKUP_NAME;
#####: 870: req.len = sizeof(virProxyPacket) + len + 1;
#####: 871: strcpy(&req.extra.str[0], name);
call 0 never executed
#####: 872: ret = xenProxyCommand(conn, (virProxyPacketPtr) &req, &req, 0);
call 0 never executed
#####: 873: if (ret < 0) {
branch 0 never executed
branch 1 never executed
#####: 874: xenProxyClose(conn);
call 0 never executed
#####: 875: return(NULL);
-: 876: }
#####: 877: if (req.data.arg == -1) {
branch 0 never executed
branch 1 never executed
#####: 878: return(NULL);
-: 879: }
#####: 880: res = virGetDomain(conn, name, (const unsigned char *)&req.extra.str[0]);
call 0 never executed
-: 881:
#####: 882: if (res == NULL)
branch 0 never executed
branch 1 never executed
#####: 883: virProxyError(conn, VIR_ERR_NO_MEMORY, "Allocating domain");
call 0 never executed
-: 884: else
#####: 885: res->handle = req.data.arg;
-: 886:
#####: 887: return(res);
-: 888:}
-: 889:
-: 890:/**
-: 891: * xenProxyNodeGetInfo:
-: 892: * @conn: pointer to the Xen Daemon block
-: 893: * @info: pointer to a virNodeInfo structure allocated by the user
-: 894: *
-: 895: * Extract hardware information about the node.
-: 896: *
-: 897: * Returns 0 in case of success and -1 in case of failure.
-: 898: */
-: 899:static int
function xenProxyNodeGetInfo called 0 returned 0% blocks executed 0%
#####: 900:xenProxyNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info) {
-: 901: virProxyPacket req;
-: 902: virProxyFullPacket ans;
-: 903: int ret;
-: 904:
#####: 905: if (!VIR_IS_CONNECT(conn)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
#####: 906: virProxyError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
call 0 never executed
#####: 907: return (-1);
-: 908: }
#####: 909: if (info == NULL) {
branch 0 never executed
branch 1 never executed
#####: 910: virProxyError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
call 0 never executed
#####: 911: return (-1);
-: 912: }
#####: 913: memset(&req, 0, sizeof(req));
call 0 never executed
#####: 914: req.command = VIR_PROXY_NODE_INFO;
#####: 915: req.data.arg = 0;
#####: 916: req.len = sizeof(req);
#####: 917: ret = xenProxyCommand(conn, &req, &ans, 0);
call 0 never executed
#####: 918: if (ret < 0) {
branch 0 never executed
branch 1 never executed
#####: 919: xenProxyClose(conn);
call 0 never executed
#####: 920: return(-1);
-: 921: }
#####: 922: if (ans.data.arg == -1) {
branch 0 never executed
branch 1 never executed
#####: 923: return(-1);
-: 924: }
#####: 925: if (ans.len != sizeof(virProxyPacket) + sizeof(virNodeInfo)) {
branch 0 never executed
branch 1 never executed
#####: 926: return(-1);
-: 927: }
#####: 928: memcpy(info, &ans.extra.ninfo, sizeof(virNodeInfo));
call 0 never executed
#####: 929: return(0);
-: 930:}
-: 931:
-: 932:/**
-: 933: * xenProxyDomainDumpXML:
-: 934: * @domain: a domain object
-: 935: * @flags: xml generation flags
-: 936: *
-: 937: * This method generates an XML description of a domain.
-: 938: *
-: 939: * Returns the XML document on success, NULL otherwise.
-: 940: */
-: 941:static char *
-: 942:xenProxyDomainDumpXML(virDomainPtr domain, int flags ATTRIBUTE_UNUSED)
function xenProxyDomainDumpXML called 0 returned 0% blocks executed 0%
#####: 943:{
-: 944: virProxyPacket req;
-: 945: virProxyFullPacket ans;
-: 946: int ret;
-: 947: int xmllen;
-: 948: char *xml;
-: 949:
#####: 950: if (!VIR_IS_CONNECTED_DOMAIN(domain)) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
branch 3 never executed
branch 4 never executed
branch 5 never executed
branch 6 never executed
branch 7 never executed
#####: 951: if (domain == NULL)
branch 0 never executed
branch 1 never executed
#####: 952: virProxyError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
call 0 never executed
-: 953: else
#####: 954: virProxyError(domain->conn, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
call 0 never executed
#####: 955: return (NULL);
-: 956: }
#####: 957: memset(&req, 0, sizeof(req));
call 0 never executed
#####: 958: req.command = VIR_PROXY_DOMAIN_XML;
#####: 959: req.data.arg = domain->handle;
#####: 960: req.len = sizeof(req);
#####: 961: ret = xenProxyCommand(domain->conn, &req, &ans, 0);
call 0 never executed
#####: 962: if (ret < 0) {
branch 0 never executed
branch 1 never executed
#####: 963: xenProxyClose(domain->conn);
call 0 never executed
#####: 964: return(NULL);
-: 965: }
#####: 966: if (ans.len <= sizeof(virProxyPacket)) {
branch 0 never executed
branch 1 never executed
#####: 967: virProxyError(domain->conn, VIR_ERR_OPERATION_FAILED, __FUNCTION__);
call 0 never executed
#####: 968: return (NULL);
-: 969: }
#####: 970: xmllen = ans.len - sizeof(virProxyPacket);
#####: 971: if (!(xml = malloc(xmllen+1))) {
call 0 never executed
branch 1 never executed
branch 2 never executed
#####: 972: return NULL;
-: 973: }
#####: 974: memmove(xml, &ans.extra.dinfo, xmllen);
call 0 never executed
#####: 975: xml[xmllen] = '\0';
-: 976:
#####: 977: return(xml);
-: 978:}