vbox_tmpl.c 340.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10
/** @file vbox_tmpl.c
 * Template File to support multiple versions of VirtualBox
 * at runtime :).
 *
 * IMPORTANT:
 * Please dont include this file in the src/Makefile.am, it
 * is automatically include by other files.
 */

/*
11
 * Copyright (C) 2010-2012 Red Hat, Inc.
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
 * Copyright (C) 2008-2009 Sun Microsystems, Inc.
 *
 * This file is part of a free software library; you can redistribute
 * it and/or modify it under the terms of the GNU Lesser General
 * Public License version 2.1 as published by the Free Software
 * Foundation and shipped in the "COPYING" file with this library.
 * The library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY of any kind.
 *
 * Sun LGPL Disclaimer: For the avoidance of doubt, except that if
 * any license choice other than GPL or LGPL is available it will
 * apply instead, Sun elects to use only the Lesser General Public
 * License version 2.1 (LGPLv2) at this time for any software where
 * a choice of LGPL license versions is made available with the
 * language indicating that LGPLv2 or any later version may be used,
 * or where a choice of which version of the LGPL is applied is
 * otherwise unspecified.
 *
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
 * Clara, CA 95054 USA or visit http://www.sun.com if you need
 * additional information or have any questions.
 */

#include <config.h>

37
#include <unistd.h>
38 39 40
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
41 42 43 44

#include "internal.h"
#include "datatypes.h"
#include "domain_conf.h"
45
#include "snapshot_conf.h"
46
#include "network_conf.h"
47
#include "virterror_internal.h"
48
#include "domain_event.h"
49
#include "storage_conf.h"
50
#include "storage_file.h"
51
#include "uuid.h"
52
#include "viralloc.h"
53
#include "nodeinfo.h"
54
#include "virlog.h"
55
#include "vbox_driver.h"
56
#include "configmake.h"
E
Eric Blake 已提交
57
#include "virfile.h"
58
#include "fdstream.h"
M
Martin Kletzander 已提交
59
#include "viruri.h"
60 61 62 63

/* This one changes from version to version. */
#if VBOX_API_VERSION == 2002
# include "vbox_CAPI_v2_2.h"
64 65
#elif VBOX_API_VERSION == 3000
# include "vbox_CAPI_v3_0.h"
66 67
#elif VBOX_API_VERSION == 3001
# include "vbox_CAPI_v3_1.h"
68 69
#elif VBOX_API_VERSION == 3002
# include "vbox_CAPI_v3_2.h"
70 71
#elif VBOX_API_VERSION == 4000
# include "vbox_CAPI_v4_0.h"
72 73
#elif VBOX_API_VERSION == 4001
# include "vbox_CAPI_v4_1.h"
74 75
#else
# error "Unsupport VBOX_API_VERSION"
76 77
#endif

78
/* Include this *last* or we'll get the wrong vbox_CAPI_*.h. */
79
#include "vbox_glue.h"
80 81


82 83 84 85 86 87 88
#define VIR_FROM_THIS                   VIR_FROM_VBOX
#define VBOX_UTF16_FREE(arg)            data->pFuncs->pfnUtf16Free(arg)
#define VBOX_UTF8_FREE(arg)             data->pFuncs->pfnUtf8Free(arg)
#define VBOX_COM_UNALLOC_MEM(arg)       data->pFuncs->pfnComUnallocMem(arg)
#define VBOX_UTF16_TO_UTF8(arg1, arg2)  data->pFuncs->pfnUtf16ToUtf8(arg1, arg2)
#define VBOX_UTF8_TO_UTF16(arg1, arg2)  data->pFuncs->pfnUtf8ToUtf16(arg1, arg2)

89 90
#define VBOX_ADDREF(arg) (arg)->vtbl->nsisupports.AddRef((nsISupports *)(arg))

91 92 93 94 95 96 97
#define VBOX_RELEASE(arg)                                                     \
    do {                                                                      \
        if (arg) {                                                            \
            (arg)->vtbl->nsisupports.Release((nsISupports *)(arg));           \
            (arg) = NULL;                                                     \
        }                                                                     \
    } while (0)
98 99 100 101

#define VBOX_OBJECT_CHECK(conn, type, value) \
vboxGlobalData *data = conn->privateData;\
type ret = value;\
102
if (!data->vboxObj) {\
103 104 105 106 107 108 109
    return ret;\
}

#define VBOX_OBJECT_HOST_CHECK(conn, type, value) \
vboxGlobalData *data = conn->privateData;\
type ret = value;\
IHost *host = NULL;\
110
if (!data->vboxObj) {\
111 112 113 114 115 116 117 118 119
    return ret;\
}\
data->vboxObj->vtbl->GetHost(data->vboxObj, &host);\
if (!host) {\
    return ret;\
}

#if VBOX_API_VERSION < 3001

120
# define VBOX_MEDIUM_RELEASE(arg) \
121
if (arg)\
122
    (arg)->vtbl->imedium.nsisupports.Release((nsISupports *)(arg))
123
# define VBOX_MEDIUM_FUNC_ARG1(object, func, arg1) \
124
    (object)->vtbl->imedium.func((IMedium *)(object), arg1)
125
# define VBOX_MEDIUM_FUNC_ARG2(object, func, arg1, arg2) \
126 127 128 129 130 131
    (object)->vtbl->imedium.func((IMedium *)(object), arg1, arg2)

#else  /* VBOX_API_VERSION >= 3001 */

typedef IMedium IHardDisk;
typedef IMediumAttachment IHardDiskAttachment;
132 133 134 135 136
# define MediaState_Inaccessible     MediumState_Inaccessible
# define HardDiskVariant_Standard    MediumVariant_Standard
# define HardDiskVariant_Fixed       MediumVariant_Fixed
# define VBOX_MEDIUM_RELEASE(arg) VBOX_RELEASE(arg)
# define VBOX_MEDIUM_FUNC_ARG1(object, func, arg1) \
137
    (object)->vtbl->func(object, arg1)
138
# define VBOX_MEDIUM_FUNC_ARG2(object, func, arg1, arg2) \
139 140 141
    (object)->vtbl->func(object, arg1, arg2)

#endif /* VBOX_API_VERSION >= 3001 */
142

143 144 145 146 147 148
#define DEBUGPRUnichar(msg, strUtf16) \
if (strUtf16) {\
    char *strUtf8 = NULL;\
\
    g_pVBoxGlobalData->pFuncs->pfnUtf16ToUtf8(strUtf16, &strUtf8);\
    if (strUtf8) {\
149
        VIR_DEBUG("%s: %s", msg, strUtf8);\
150 151 152 153 154 155
        g_pVBoxGlobalData->pFuncs->pfnUtf8Free(strUtf8);\
    }\
}

#define DEBUGUUID(msg, iid) \
{\
156
    VIR_DEBUG(msg ": {%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",\
157 158 159 160 161 162 163 164 165 166 167 168 169
          (unsigned)(iid)->m0,\
          (unsigned)(iid)->m1,\
          (unsigned)(iid)->m2,\
          (unsigned)(iid)->m3[0],\
          (unsigned)(iid)->m3[1],\
          (unsigned)(iid)->m3[2],\
          (unsigned)(iid)->m3[3],\
          (unsigned)(iid)->m3[4],\
          (unsigned)(iid)->m3[5],\
          (unsigned)(iid)->m3[6],\
          (unsigned)(iid)->m3[7]);\
}\

170 171
typedef struct {
    virMutex lock;
172
    unsigned long version;
173 174 175 176 177

    virCapsPtr caps;

    IVirtualBox *vboxObj;
    ISession *vboxSession;
178 179 180

    /** Our version specific API table pointer. */
    PCVBOXXPCOM pFuncs;
181 182 183 184 185 186 187

#if VBOX_API_VERSION == 2002

} vboxGlobalData;

#else /* !(VBOX_API_VERSION == 2002) */

188 189
    /* Async event handling */
    virDomainEventStatePtr domainEvents;
190 191
    int fdWatch;

192 193
# if VBOX_API_VERSION <= 3002
    /* IVirtualBoxCallback is used in VirtualBox 3.x only */
194
    IVirtualBoxCallback *vboxCallback;
195
# endif /* VBOX_API_VERSION <= 3002 */
196 197 198 199 200 201 202

    nsIEventQueue  *vboxQueue;
    int volatile vboxCallBackRefCount;

    /* pointer back to the connection */
    virConnectPtr conn;

203 204
} vboxGlobalData;

205 206 207 208 209 210 211 212 213 214
/* g_pVBoxGlobalData has to be global variable,
 * there is no other way to make the callbacks
 * work other then having g_pVBoxGlobalData as
 * global, because the functions namely AddRef,
 * Release, etc consider it as global and you
 * can't change the function definition as it
 * is XPCOM nsISupport::* function and it expects
 * them that way
 */

215
static vboxGlobalData *g_pVBoxGlobalData = NULL;
216 217

#endif /* !(VBOX_API_VERSION == 2002) */
218

219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
#if VBOX_API_VERSION < 4000

# define VBOX_OBJECT_GET_MACHINE(/* in */ iid_value, /* out */ machine) \
    data->vboxObj->vtbl->GetMachine(data->vboxObj, iid_value, machine)

# define VBOX_SESSION_OPEN(/* in */ iid_value, /* unused */ machine) \
    data->vboxObj->vtbl->OpenSession(data->vboxObj, data->vboxSession, iid_value)

# define VBOX_SESSION_OPEN_EXISTING(/* in */ iid_value, /* unused */ machine) \
    data->vboxObj->vtbl->OpenExistingSession(data->vboxObj, data->vboxSession, iid_value)

# define VBOX_SESSION_CLOSE() \
    data->vboxSession->vtbl->Close(data->vboxSession)

#else /* VBOX_API_VERSION >= 4000 */

# define VBOX_OBJECT_GET_MACHINE(/* in */ iid_value, /* out */ machine) \
    data->vboxObj->vtbl->FindMachine(data->vboxObj, iid_value, machine)

# define VBOX_SESSION_OPEN(/* unused */ iid_value, /* in */ machine) \
    machine->vtbl->LockMachine(machine, data->vboxSession, LockType_Write)

# define VBOX_SESSION_OPEN_EXISTING(/* unused */ iid_value, /* in */ machine) \
    machine->vtbl->LockMachine(machine, data->vboxSession, LockType_Shared)

# define VBOX_SESSION_CLOSE() \
    data->vboxSession->vtbl->UnlockMachine(data->vboxSession)

#endif /* VBOX_API_VERSION >= 4000 */

249 250
static virDomainPtr vboxDomainDefineXML(virConnectPtr conn, const char *xml);
static int vboxDomainCreate(virDomainPtr dom);
251
static int vboxDomainUndefineFlags(virDomainPtr dom, unsigned int flags);
252

253 254 255 256 257 258 259 260 261
static void vboxDriverLock(vboxGlobalData *data) {
    virMutexLock(&data->lock);
}

static void vboxDriverUnlock(vboxGlobalData *data) {
    virMutexUnlock(&data->lock);
}

#if VBOX_API_VERSION == 2002
262

263
static void nsIDtoChar(unsigned char *uuid, const nsID *iid) {
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294
    char uuidstrsrc[VIR_UUID_STRING_BUFLEN];
    char uuidstrdst[VIR_UUID_STRING_BUFLEN];
    unsigned char uuidinterim[VIR_UUID_BUFLEN];
    int i;

    memcpy(uuidinterim, iid, VIR_UUID_BUFLEN);
    virUUIDFormat(uuidinterim, uuidstrsrc);

    uuidstrdst[0]  = uuidstrsrc[6];
    uuidstrdst[1]  = uuidstrsrc[7];
    uuidstrdst[2]  = uuidstrsrc[4];
    uuidstrdst[3]  = uuidstrsrc[5];
    uuidstrdst[4]  = uuidstrsrc[2];
    uuidstrdst[5]  = uuidstrsrc[3];
    uuidstrdst[6]  = uuidstrsrc[0];
    uuidstrdst[7]  = uuidstrsrc[1];

    uuidstrdst[8]  = uuidstrsrc[8];

    uuidstrdst[9]  = uuidstrsrc[11];
    uuidstrdst[10] = uuidstrsrc[12];
    uuidstrdst[11] = uuidstrsrc[9];
    uuidstrdst[12] = uuidstrsrc[10];

    uuidstrdst[13] = uuidstrsrc[13];

    uuidstrdst[14] = uuidstrsrc[16];
    uuidstrdst[15] = uuidstrsrc[17];
    uuidstrdst[16] = uuidstrsrc[14];
    uuidstrdst[17] = uuidstrsrc[15];

295
    for (i = 18; i < VIR_UUID_STRING_BUFLEN; i++) {
296 297 298 299
        uuidstrdst[i] = uuidstrsrc[i];
    }

    uuidstrdst[VIR_UUID_STRING_BUFLEN-1] = '\0';
300
    ignore_value(virUUIDParse(uuidstrdst, uuid));
301 302
}

303
static void nsIDFromChar(nsID *iid, const unsigned char *uuid) {
304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333
    char uuidstrsrc[VIR_UUID_STRING_BUFLEN];
    char uuidstrdst[VIR_UUID_STRING_BUFLEN];
    unsigned char uuidinterim[VIR_UUID_BUFLEN];
    int i;

    virUUIDFormat(uuid, uuidstrsrc);

    uuidstrdst[0]  = uuidstrsrc[6];
    uuidstrdst[1]  = uuidstrsrc[7];
    uuidstrdst[2]  = uuidstrsrc[4];
    uuidstrdst[3]  = uuidstrsrc[5];
    uuidstrdst[4]  = uuidstrsrc[2];
    uuidstrdst[5]  = uuidstrsrc[3];
    uuidstrdst[6]  = uuidstrsrc[0];
    uuidstrdst[7]  = uuidstrsrc[1];

    uuidstrdst[8]  = uuidstrsrc[8];

    uuidstrdst[9]  = uuidstrsrc[11];
    uuidstrdst[10] = uuidstrsrc[12];
    uuidstrdst[11] = uuidstrsrc[9];
    uuidstrdst[12] = uuidstrsrc[10];

    uuidstrdst[13] = uuidstrsrc[13];

    uuidstrdst[14] = uuidstrsrc[16];
    uuidstrdst[15] = uuidstrsrc[17];
    uuidstrdst[16] = uuidstrsrc[14];
    uuidstrdst[17] = uuidstrsrc[15];

334
    for (i = 18; i < VIR_UUID_STRING_BUFLEN; i++) {
335 336 337 338
        uuidstrdst[i] = uuidstrsrc[i];
    }

    uuidstrdst[VIR_UUID_STRING_BUFLEN-1] = '\0';
339
    ignore_value(virUUIDParse(uuidstrdst, uuidinterim));
340 341 342
    memcpy(iid, uuidinterim, VIR_UUID_BUFLEN);
}

343
# ifdef WIN32
344

345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
typedef struct _vboxIID_v2_x_WIN32 vboxIID;
typedef struct _vboxIID_v2_x_WIN32 vboxIID_v2_x_WIN32;

struct _vboxIID_v2_x_WIN32 {
    /* IID is represented by a GUID value. */
    GUID value;
};

#  define VBOX_IID_INITIALIZER { { 0, 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0 } } }

static void
vboxIIDUnalloc_v2_x_WIN32(vboxGlobalData *data ATTRIBUTE_UNUSED,
                          vboxIID_v2_x_WIN32 *iid ATTRIBUTE_UNUSED)
{
    /* Nothing to free */
360
}
361

362 363 364 365 366
static void
vboxIIDToUUID_v2_x_WIN32(vboxIID_v2_x_WIN32 *iid, unsigned char *uuid)
{
    nsIDtoChar(uuid, (nsID *)&iid->value);
}
367

368 369 370 371 372
static void
vboxIIDFromUUID_v2_x_WIN32(vboxGlobalData *data, vboxIID_v2_x_WIN32 *iid,
                           const unsigned char *uuid)
{
    vboxIIDUnalloc_v2_x_WIN32(data, iid);
373

374
    nsIDFromChar((nsID *)&iid->value, uuid);
375 376
}

377 378 379
static bool
vboxIIDIsEqual_v2_x_WIN32(vboxIID_v2_x_WIN32 *iid1, vboxIID_v2_x_WIN32 *iid2)
{
380
    return memcmp(&iid1->value, &iid2->value, sizeof(GUID)) == 0;
381
}
382

383 384 385 386 387 388 389 390
static void
vboxIIDFromArrayItem_v2_x_WIN32(vboxGlobalData *data, vboxIID_v2_x_WIN32 *iid,
                                vboxArray *array, int idx)
{
    GUID *items = (GUID *)array->items;

    vboxIIDUnalloc_v2_x_WIN32(data, iid);

391
    memcpy(&iid->value, &items[idx], sizeof(GUID));
392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
}

#  define vboxIIDUnalloc(iid) vboxIIDUnalloc_v2_x_WIN32(data, iid)
#  define vboxIIDToUUID(iid, uuid) vboxIIDToUUID_v2_x_WIN32(iid, uuid)
#  define vboxIIDFromUUID(iid, uuid) vboxIIDFromUUID_v2_x_WIN32(data, iid, uuid)
#  define vboxIIDIsEqual(iid1, iid2) vboxIIDIsEqual_v2_x_WIN32(iid1, iid2)
#  define vboxIIDFromArrayItem(iid, array, idx) \
    vboxIIDFromArrayItem_v2_x_WIN32(data, iid, array, idx)
#  define DEBUGIID(msg, iid) DEBUGUUID(msg, (nsID *)&(iid))

# else /* !WIN32 */

typedef struct _vboxIID_v2_x vboxIID;
typedef struct _vboxIID_v2_x vboxIID_v2_x;

struct _vboxIID_v2_x {
    /* IID is represented by a pointer to a nsID. */
    nsID *value;

    /* backing is used in cases where we need to create or copy an IID.
     * We cannot allocate memory that can be freed by ComUnallocMem.
     * Therefore, we use this stack allocated nsID instead. */
    nsID backing;
};

#  define VBOX_IID_INITIALIZER { NULL, { 0, 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0 } } }

static void
vboxIIDUnalloc_v2_x(vboxGlobalData *data, vboxIID_v2_x *iid)
{
    if (iid->value == NULL) {
423 424 425
        return;
    }

426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447
    if (iid->value != &iid->backing) {
        data->pFuncs->pfnComUnallocMem(iid->value);
    }

    iid->value = NULL;
}

static void
vboxIIDToUUID_v2_x(vboxIID_v2_x *iid, unsigned char *uuid)
{
    nsIDtoChar(uuid, iid->value);
}

static void
vboxIIDFromUUID_v2_x(vboxGlobalData *data, vboxIID_v2_x *iid,
                     const unsigned char *uuid)
{
    vboxIIDUnalloc_v2_x(data, iid);

    iid->value = &iid->backing;

    nsIDFromChar(iid->value, uuid);
448 449
}

450 451 452
static bool
vboxIIDIsEqual_v2_x(vboxIID_v2_x *iid1, vboxIID_v2_x *iid2)
{
453
    return memcmp(iid1->value, iid2->value, sizeof(nsID)) == 0;
454 455 456 457 458 459 460 461 462 463
}

static void
vboxIIDFromArrayItem_v2_x(vboxGlobalData *data, vboxIID_v2_x *iid,
                          vboxArray *array, int idx)
{
    vboxIIDUnalloc_v2_x(data, iid);

    iid->value = &iid->backing;

464
    memcpy(iid->value, array->items[idx], sizeof(nsID));
465 466 467 468 469 470 471 472 473 474 475 476
}

#  define vboxIIDUnalloc(iid) vboxIIDUnalloc_v2_x(data, iid)
#  define vboxIIDToUUID(iid, uuid) vboxIIDToUUID_v2_x(iid, uuid)
#  define vboxIIDFromUUID(iid, uuid) vboxIIDFromUUID_v2_x(data, iid, uuid)
#  define vboxIIDIsEqual(iid1, iid2) vboxIIDIsEqual_v2_x(iid1, iid2)
#  define vboxIIDFromArrayItem(iid, array, idx) \
    vboxIIDFromArrayItem_v2_x(data, iid, array, idx)
#  define DEBUGIID(msg, iid) DEBUGUUID(msg, iid)

# endif /* !WIN32 */

477
#else /* VBOX_API_VERSION != 2002 */
478

479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500
typedef struct _vboxIID_v3_x vboxIID;
typedef struct _vboxIID_v3_x vboxIID_v3_x;

struct _vboxIID_v3_x {
    /* IID is represented by a UTF-16 encoded UUID in string form. */
    PRUnichar *value;

    /* owner indicates if we own the value and need to free it. */
    bool owner;
};

# define VBOX_IID_INITIALIZER { NULL, true }

static void
vboxIIDUnalloc_v3_x(vboxGlobalData *data, vboxIID_v3_x *iid)
{
    if (iid->value != NULL && iid->owner) {
        data->pFuncs->pfnUtf16Free(iid->value);
    }

    iid->value = NULL;
    iid->owner = true;
501 502
}

503 504 505 506 507 508 509 510
static void
vboxIIDToUUID_v3_x(vboxGlobalData *data, vboxIID_v3_x *iid,
                   unsigned char *uuid)
{
    char *utf8 = NULL;

    data->pFuncs->pfnUtf16ToUtf8(iid->value, &utf8);

511
    ignore_value(virUUIDParse(utf8, uuid));
512 513

    data->pFuncs->pfnUtf8Free(utf8);
514 515
}

516 517 518 519 520
static void
vboxIIDFromUUID_v3_x(vboxGlobalData *data, vboxIID_v3_x *iid,
                     const unsigned char *uuid)
{
    char utf8[VIR_UUID_STRING_BUFLEN];
521

522
    vboxIIDUnalloc_v3_x(data, iid);
523

524
    virUUIDFormat(uuid, utf8);
525

526 527
    data->pFuncs->pfnUtf8ToUtf16(utf8, &iid->value);
}
528

529 530 531 532 533 534
static bool
vboxIIDIsEqual_v3_x(vboxGlobalData *data, vboxIID_v3_x *iid1,
                    vboxIID_v3_x *iid2)
{
    unsigned char uuid1[VIR_UUID_BUFLEN];
    unsigned char uuid2[VIR_UUID_BUFLEN];
535 536

    /* Note: we can't directly compare the utf8 strings here
E
Eric Blake 已提交
537
     * cause the two UUID's may have separators as space or '-'
538 539
     * or mixture of both and we don't want to fail here by
     * using direct string comparison. Here virUUIDParse() takes
540 541 542
     * care of these cases. */
    vboxIIDToUUID_v3_x(data, iid1, uuid1);
    vboxIIDToUUID_v3_x(data, iid2, uuid2);
543

544 545
    return memcmp(uuid1, uuid2, VIR_UUID_BUFLEN) == 0;
}
546 547


548 549 550 551 552
static void
vboxIIDFromArrayItem_v3_x(vboxGlobalData *data, vboxIID_v3_x *iid,
                          vboxArray *array, int idx)
{
    vboxIIDUnalloc_v3_x(data, iid);
553

554 555
    iid->value = array->items[idx];
    iid->owner = false;
556 557
}

558 559 560 561 562 563 564 565

# define vboxIIDUnalloc(iid) vboxIIDUnalloc_v3_x(data, iid)
# define vboxIIDToUUID(iid, uuid) vboxIIDToUUID_v3_x(data, iid, uuid)
# define vboxIIDFromUUID(iid, uuid) vboxIIDFromUUID_v3_x(data, iid, uuid)
# define vboxIIDIsEqual(iid1, iid2) vboxIIDIsEqual_v3_x(data, iid1, iid2)
# define vboxIIDFromArrayItem(iid, array, idx) \
    vboxIIDFromArrayItem_v3_x(data, iid, array, idx)
# define DEBUGIID(msg, strUtf16) DEBUGPRUnichar(msg, strUtf16)
566

567
# if VBOX_API_VERSION >= 3001
568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583

/**
 * function to generate the name for medium,
 * for e.g: hda, sda, etc
 *
 * @returns     null terminated string with device name or NULL
 *              for failures
 * @param       conn            Input Connection Pointer
 * @param       storageBus      Input storage bus type
 * @param       deviceInst      Input device instance number
 * @param       devicePort      Input port number
 * @param       deviceSlot      Input slot number
 * @param       aMaxPortPerInst Input array of max port per device instance
 * @param       aMaxSlotPerPort Input array of max slot per device port
 *
 */
584
static char *vboxGenerateMediumName(PRUint32  storageBus,
585 586 587 588 589
                                    PRInt32   deviceInst,
                                    PRInt32   devicePort,
                                    PRInt32   deviceSlot,
                                    PRUint32 *aMaxPortPerInst,
                                    PRUint32 *aMaxSlotPerPort) {
590
    const char *prefix = NULL;
591 592 593 594 595
    char *name  = NULL;
    int   total = 0;
    PRUint32 maxPortPerInst = 0;
    PRUint32 maxSlotPerPort = 0;

596 597
    if (!aMaxPortPerInst ||
        !aMaxSlotPerPort)
598 599
        return NULL;

600 601
    if ((storageBus < StorageBus_IDE) ||
        (storageBus > StorageBus_Floppy))
602 603 604 605 606 607 608 609 610
        return NULL;

    maxPortPerInst = aMaxPortPerInst[storageBus];
    maxSlotPerPort = aMaxSlotPerPort[storageBus];
    total =   (deviceInst * maxPortPerInst * maxSlotPerPort)
            + (devicePort * maxSlotPerPort)
            + deviceSlot;

    if (storageBus == StorageBus_IDE) {
611
        prefix = "hd";
612 613
    } else if ((storageBus == StorageBus_SATA) ||
               (storageBus == StorageBus_SCSI)) {
614
        prefix = "sd";
615
    } else if (storageBus == StorageBus_Floppy) {
616
        prefix = "fd";
617 618
    }

619
    name = virIndexToDiskName(total, prefix);
620

621
    VIR_DEBUG("name=%s, total=%d, storageBus=%u, deviceInst=%d, "
622
          "devicePort=%d deviceSlot=%d, maxPortPerInst=%u maxSlotPerPort=%u",
623
          NULLSTR(name), total, storageBus, deviceInst, devicePort,
624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
          deviceSlot, maxPortPerInst, maxSlotPerPort);
    return name;
}

/**
 * function to get the StorageBus, Port number
 * and Device number for the given devicename
 * e.g: hda has StorageBus = IDE, port = 0,
 *      device = 0
 *
 * @returns     true on Success, false on failure.
 * @param       deviceName      Input device name
 * @param       aMaxPortPerInst Input array of max port per device instance
 * @param       aMaxSlotPerPort Input array of max slot per device port
 * @param       storageBus      Input storage bus type
 * @param       deviceInst      Output device instance number
 * @param       devicePort      Output port number
 * @param       deviceSlot      Output slot number
 *
 */
static bool vboxGetDeviceDetails(const char *deviceName,
                                 PRUint32   *aMaxPortPerInst,
                                 PRUint32   *aMaxSlotPerPort,
                                 PRUint32    storageBus,
                                 PRInt32    *deviceInst,
                                 PRInt32    *devicePort,
                                 PRInt32    *deviceSlot) {
    int total = 0;
    PRUint32 maxPortPerInst = 0;
    PRUint32 maxSlotPerPort = 0;

655 656 657 658 659 660
    if (!deviceName ||
        !deviceInst ||
        !devicePort ||
        !deviceSlot ||
        !aMaxPortPerInst ||
        !aMaxSlotPerPort)
661 662
        return false;

663 664
    if ((storageBus < StorageBus_IDE) ||
        (storageBus > StorageBus_Floppy))
665 666 667 668 669 670 671
        return false;

    total = virDiskNameToIndex(deviceName);

    maxPortPerInst = aMaxPortPerInst[storageBus];
    maxSlotPerPort = aMaxSlotPerPort[storageBus];

672 673 674
    if (!maxPortPerInst ||
        !maxSlotPerPort ||
        (total < 0))
675 676 677 678 679 680
        return false;

    *deviceInst = total / (maxPortPerInst * maxSlotPerPort);
    *devicePort = (total % (maxPortPerInst * maxSlotPerPort)) / maxSlotPerPort;
    *deviceSlot = (total % (maxPortPerInst * maxSlotPerPort)) % maxSlotPerPort;

681
    VIR_DEBUG("name=%s, total=%d, storageBus=%u, deviceInst=%d, "
682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757
          "devicePort=%d deviceSlot=%d, maxPortPerInst=%u maxSlotPerPort=%u",
          deviceName, total, storageBus, *deviceInst, *devicePort,
          *deviceSlot, maxPortPerInst, maxSlotPerPort);

    return true;
}

/**
 * function to get the values for max port per
 * instance and max slots per port for the devices
 *
 * @returns     true on Success, false on failure.
 * @param       vbox            Input IVirtualBox pointer
 * @param       maxPortPerInst  Output array of max port per instance
 * @param       maxSlotPerPort  Output array of max slot per port
 *
 */

static bool vboxGetMaxPortSlotValues(IVirtualBox *vbox,
                                     PRUint32 *maxPortPerInst,
                                     PRUint32 *maxSlotPerPort) {
    ISystemProperties *sysProps = NULL;

    if (!vbox)
        return false;

    vbox->vtbl->GetSystemProperties(vbox, &sysProps);

    if (!sysProps)
        return false;

    sysProps->vtbl->GetMaxPortCountForStorageBus(sysProps,
                                                 StorageBus_IDE,
                                                 &maxPortPerInst[StorageBus_IDE]);
    sysProps->vtbl->GetMaxPortCountForStorageBus(sysProps,
                                                 StorageBus_SATA,
                                                 &maxPortPerInst[StorageBus_SATA]);
    sysProps->vtbl->GetMaxPortCountForStorageBus(sysProps,
                                                 StorageBus_SCSI,
                                                 &maxPortPerInst[StorageBus_SCSI]);
    sysProps->vtbl->GetMaxPortCountForStorageBus(sysProps,
                                                 StorageBus_Floppy,
                                                 &maxPortPerInst[StorageBus_Floppy]);

    sysProps->vtbl->GetMaxDevicesPerPortForStorageBus(sysProps,
                                                      StorageBus_IDE,
                                                      &maxSlotPerPort[StorageBus_IDE]);
    sysProps->vtbl->GetMaxDevicesPerPortForStorageBus(sysProps,
                                                      StorageBus_SATA,
                                                      &maxSlotPerPort[StorageBus_SATA]);
    sysProps->vtbl->GetMaxDevicesPerPortForStorageBus(sysProps,
                                                      StorageBus_SCSI,
                                                      &maxSlotPerPort[StorageBus_SCSI]);
    sysProps->vtbl->GetMaxDevicesPerPortForStorageBus(sysProps,
                                                      StorageBus_Floppy,
                                                      &maxSlotPerPort[StorageBus_Floppy]);

    VBOX_RELEASE(sysProps);

    return true;
}

/**
 * Converts Utf-16 string to int
 */
static int PRUnicharToInt(PRUnichar *strUtf16) {
    char *strUtf8 = NULL;
    int ret = 0;

    if (!strUtf16)
        return -1;

    g_pVBoxGlobalData->pFuncs->pfnUtf16ToUtf8(strUtf16, &strUtf8);
    if (!strUtf8)
        return -1;

758 759 760
    if (virStrToLong_i(strUtf8, NULL, 10, &ret) < 0)
        ret = -1;

761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779
    g_pVBoxGlobalData->pFuncs->pfnUtf8Free(strUtf8);

    return ret;
}

/**
 * Converts int to Utf-16 string
 */
static PRUnichar *PRUnicharFromInt(int n) {
    PRUnichar *strUtf16 = NULL;
    char s[24];

    snprintf(s, sizeof(s), "%d", n);

    g_pVBoxGlobalData->pFuncs->pfnUtf8ToUtf16(s, &strUtf16);

    return strUtf16;
}

780
# endif /* VBOX_API_VERSION >= 3001 */
781

782 783
#endif /* !(VBOX_API_VERSION == 2002) */

784 785 786 787 788 789
static PRUnichar *
vboxSocketFormatAddrUtf16(vboxGlobalData *data, virSocketAddrPtr addr)
{
    char *utf8 = NULL;
    PRUnichar *utf16 = NULL;

790
    utf8 = virSocketAddrFormat(addr);
791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810

    if (utf8 == NULL) {
        return NULL;
    }

    VBOX_UTF8_TO_UTF16(utf8, &utf16);
    VIR_FREE(utf8);

    return utf16;
}

static int
vboxSocketParseAddrUtf16(vboxGlobalData *data, const PRUnichar *utf16,
                         virSocketAddrPtr addr)
{
    int result = -1;
    char *utf8 = NULL;

    VBOX_UTF16_TO_UTF8(utf16, &utf8);

811
    if (virSocketAddrParse(addr, utf8, AF_UNSPEC) < 0) {
812 813 814 815 816 817 818 819 820 821 822
        goto cleanup;
    }

    result = 0;

cleanup:
    VBOX_UTF8_FREE(utf8);

    return result;
}

823

824
static int vboxDefaultConsoleType(const char *ostype ATTRIBUTE_UNUSED,
825
                                  virArch arch ATTRIBUTE_UNUSED)
826 827 828 829 830
{
    return VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SERIAL;
}


831 832
static virCapsPtr vboxCapsInit(void)
{
833 834 835
    virCapsPtr caps;
    virCapsGuestPtr guest;

836
    if ((caps = virCapabilitiesNew(virArchFromHost(),
837 838 839
                                   0, 0)) == NULL)
        goto no_memory;

840
    if (nodeCapsInitNUMA(caps) < 0)
841 842 843 844 845 846
        goto no_memory;

    virCapabilitiesSetMacPrefix(caps, (unsigned char[]){ 0x08, 0x00, 0x27 });

    if ((guest = virCapabilitiesAddGuest(caps,
                                         "hvm",
847
                                         caps->host.arch,
848 849 850 851 852 853 854 855 856 857 858 859 860
                                         NULL,
                                         NULL,
                                         0,
                                         NULL)) == NULL)
        goto no_memory;

    if (virCapabilitiesAddGuestDomain(guest,
                                      "vbox",
                                      NULL,
                                      NULL,
                                      0,
                                      NULL) == NULL)
        goto no_memory;
861 862 863

    caps->defaultConsoleTargetType = vboxDefaultConsoleType;

864 865 866 867 868 869 870
    return caps;

no_memory:
    virCapabilitiesFree(caps);
    return NULL;
}

871 872 873
static int
vboxInitialize(vboxGlobalData *data)
{
874 875 876
    data->pFuncs = g_pfnGetFunctions(VBOX_XPCOMC_VERSION);

    if (data->pFuncs == NULL)
877
        goto cleanup;
878 879 880

#if VBOX_XPCOMC_VERSION == 0x00010000U
    data->pFuncs->pfnComInitialize(&data->vboxObj, &data->vboxSession);
881
#else  /* !(VBOX_XPCOMC_VERSION == 0x00010000U) */
882 883
    data->pFuncs->pfnComInitialize(IVIRTUALBOX_IID_STR, &data->vboxObj,
                               ISESSION_IID_STR, &data->vboxSession);
884

885
# if VBOX_API_VERSION == 2002
886 887 888

    /* No event queue functionality in 2.2.* as of now */

889
# else  /* !(VBOX_API_VERSION == 2002) */
890 891 892 893 894 895 896

    /* Initial the fWatch needed for Event Callbacks */
    data->fdWatch = -1;

    data->pFuncs->pfnGetEventQueue(&data->vboxQueue);

    if (data->vboxQueue == NULL) {
897 898
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("nsIEventQueue object is null"));
899 900 901
        goto cleanup;
    }

902
# endif /* !(VBOX_API_VERSION == 2002) */
903
#endif /* !(VBOX_XPCOMC_VERSION == 0x00010000U) */
904 905

    if (data->vboxObj == NULL) {
906 907
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("IVirtualBox object is null"));
908
        goto cleanup;
909 910 911
    }

    if (data->vboxSession == NULL) {
912 913
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("ISession object is null"));
914 915
        goto cleanup;
    }
916 917 918 919 920 921 922

    return 0;

cleanup:
    return -1;
}

923
static int vboxExtractVersion(vboxGlobalData *data) {
924
    int ret = -1;
925 926 927 928 929 930 931 932 933 934
    PRUnichar *versionUtf16 = NULL;
    nsresult rc;

    if (data->version > 0)
        return 0;

    rc = data->vboxObj->vtbl->GetVersion(data->vboxObj, &versionUtf16);
    if (NS_SUCCEEDED(rc)) {
        char *vboxVersion = NULL;

935
        VBOX_UTF16_TO_UTF8(versionUtf16, &vboxVersion);
936

937
        if (virParseVersionString(vboxVersion, &data->version, false) >= 0)
938 939
            ret = 0;

940 941
        VBOX_UTF8_FREE(vboxVersion);
        VBOX_COM_UNALLOC_MEM(versionUtf16);
942 943 944
    }

    if (ret != 0)
945 946
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("Could not extract VirtualBox version"));
947

948 949 950 951
    return ret;
}

static void vboxUninitialize(vboxGlobalData *data) {
952 953 954
    if (!data)
        return;

955 956
    if (data->pFuncs)
        data->pFuncs->pfnComUninitialize();
957 958

    virCapabilitiesFree(data->caps);
959 960 961
#if VBOX_API_VERSION == 2002
    /* No domainEventCallbacks in 2.2.* version */
#else  /* !(VBOX_API_VERSION == 2002) */
962
    virDomainEventStateFree(data->domainEvents);
963
#endif /* !(VBOX_API_VERSION == 2002) */
964 965 966
    VIR_FREE(data);
}

967

968 969
static virDrvOpenStatus vboxOpen(virConnectPtr conn,
                                 virConnectAuthPtr auth ATTRIBUTE_UNUSED,
E
Eric Blake 已提交
970 971
                                 unsigned int flags)
{
972
    vboxGlobalData *data = NULL;
973 974
    uid_t uid = getuid();

E
Eric Blake 已提交
975 976
    virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);

977 978 979
    if (conn->uri == NULL &&
        !(conn->uri = virURIParse(uid ? "vbox:///session" : "vbox:///system")))
        return VIR_DRV_OPEN_ERROR;
980

981
    if (conn->uri->scheme == NULL ||
982
        STRNEQ(conn->uri->scheme, "vbox"))
983 984 985 986
        return VIR_DRV_OPEN_DECLINED;

    /* Leave for remote driver */
    if (conn->uri->server != NULL)
987 988
        return VIR_DRV_OPEN_DECLINED;

989
    if (conn->uri->path == NULL || STREQ(conn->uri->path, "")) {
990 991
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("no VirtualBox driver path specified (try vbox:///session)"));
992 993 994
        return VIR_DRV_OPEN_ERROR;
    }

995
    if (uid != 0) {
996
        if (STRNEQ(conn->uri->path, "/session")) {
997 998
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("unknown driver path '%s' specified (try vbox:///session)"), conn->uri->path);
999 1000
            return VIR_DRV_OPEN_ERROR;
        }
1001
    } else { /* root */
1002 1003
        if (STRNEQ(conn->uri->path, "/system") &&
            STRNEQ(conn->uri->path, "/session")) {
1004 1005
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("unknown driver path '%s' specified (try vbox:///system)"), conn->uri->path);
1006 1007
            return VIR_DRV_OPEN_ERROR;
        }
1008 1009 1010
    }

    if (VIR_ALLOC(data) < 0) {
1011
        virReportOOMError();
1012
        return VIR_DRV_OPEN_ERROR;
1013 1014
    }

1015
    if (!(data->caps = vboxCapsInit()) ||
1016 1017
        vboxInitialize(data) < 0 ||
        vboxExtractVersion(data) < 0) {
1018 1019 1020
        vboxUninitialize(data);
        return VIR_DRV_OPEN_ERROR;
    }
1021

1022 1023 1024 1025 1026 1027
#if VBOX_API_VERSION == 2002

    /* No domainEventCallbacks in 2.2.* version */

#else  /* !(VBOX_API_VERSION == 2002) */

1028
    if (!(data->domainEvents = virDomainEventStateNew())) {
1029
        vboxUninitialize(data);
1030 1031 1032 1033 1034 1035 1036 1037
        return VIR_DRV_OPEN_ERROR;
    }

    data->conn = conn;
    g_pVBoxGlobalData = data;

#endif /* !(VBOX_API_VERSION == 2002) */

1038
    conn->privateData = data;
1039
    VIR_DEBUG("in vboxOpen");
1040 1041 1042 1043 1044 1045

    return VIR_DRV_OPEN_SUCCESS;
}

static int vboxClose(virConnectPtr conn) {
    vboxGlobalData *data = conn->privateData;
1046
    VIR_DEBUG("%s: in vboxClose",conn->driver->name);
1047 1048 1049 1050 1051 1052 1053 1054 1055

    vboxUninitialize(data);
    conn->privateData = NULL;

    return 0;
}

static int vboxGetVersion(virConnectPtr conn, unsigned long *version) {
    vboxGlobalData *data = conn->privateData;
1056
    VIR_DEBUG("%s: in vboxGetVersion",conn->driver->name);
1057 1058 1059 1060 1061 1062 1063 1064

    vboxDriverLock(data);
    *version = data->version;
    vboxDriverUnlock(data);

    return 0;
}

1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
static int vboxIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED) {
    /* Driver is using local, non-network based transport */
    return 1;
}

static int vboxIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED) {
    /* No encryption is needed, or used on the local transport*/
    return 0;
}

1075 1076 1077 1078 1079
static int vboxIsAlive(virConnectPtr conn ATTRIBUTE_UNUSED)
{
    return 1;
}

1080
static int vboxGetMaxVcpus(virConnectPtr conn, const char *type ATTRIBUTE_UNUSED) {
1081
    VBOX_OBJECT_CHECK(conn, int, -1);
1082 1083 1084 1085 1086
    PRUint32 maxCPUCount = 0;

    /* VirtualBox Supports only hvm and thus the type passed to it
     * has no meaning, setting it to ATTRIBUTE_UNUSED
     */
1087
    ISystemProperties *systemProperties = NULL;
1088

1089 1090 1091 1092
    data->vboxObj->vtbl->GetSystemProperties(data->vboxObj, &systemProperties);
    if (systemProperties) {
        systemProperties->vtbl->GetMaxGuestCPUCount(systemProperties, &maxCPUCount);
        VBOX_RELEASE(systemProperties);
1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
    }

    if (maxCPUCount > 0)
        ret = maxCPUCount;

    return ret;
}


static char *vboxGetCapabilities(virConnectPtr conn) {
1103
    VBOX_OBJECT_CHECK(conn, char *, NULL);
1104 1105 1106 1107 1108 1109 1110 1111 1112

    vboxDriverLock(data);
    ret = virCapabilitiesFormatXML(data->caps);
    vboxDriverUnlock(data);

    return ret;
}

static int vboxListDomains(virConnectPtr conn, int *ids, int nids) {
1113
    VBOX_OBJECT_CHECK(conn, int, -1);
1114
    vboxArray machines = VBOX_ARRAY_INITIALIZER;
1115
    PRUint32 state;
1116
    nsresult rc;
1117 1118
    int i, j;

1119
    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
1120
    if (NS_FAILED(rc)) {
1121 1122
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Could not get list of Domains, rc=%08x"),(unsigned)rc);
1123 1124
        goto cleanup;
    }
1125

1126 1127 1128
    ret = 0;
    for (i = 0, j = 0; (i < machines.count) && (j < nids); ++i) {
        IMachine *machine = machines.items[i];
1129 1130 1131 1132 1133 1134

        if (machine) {
            PRBool isAccessible = PR_FALSE;
            machine->vtbl->GetAccessible(machine, &isAccessible);
            if (isAccessible) {
                machine->vtbl->GetState(machine, &state);
1135 1136
                if ((state >= MachineState_FirstOnline) &&
                    (state <= MachineState_LastOnline)) {
1137 1138
                    ret++;
                    ids[j++] = i + 1;
1139 1140 1141 1142 1143 1144
                }
            }
        }
    }

cleanup:
1145
    vboxArrayRelease(&machines);
1146 1147 1148 1149
    return ret;
}

static int vboxNumOfDomains(virConnectPtr conn) {
1150
    VBOX_OBJECT_CHECK(conn, int, -1);
1151
    vboxArray machines = VBOX_ARRAY_INITIALIZER;
1152
    PRUint32 state;
1153
    nsresult rc;
1154 1155
    int i;

1156
    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
1157
    if (NS_FAILED(rc)) {
1158 1159
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Could not get number of Domains, rc=%08x"), (unsigned)rc);
1160 1161
        goto cleanup;
    }
1162

1163 1164 1165
    ret = 0;
    for (i = 0; i < machines.count; ++i) {
        IMachine *machine = machines.items[i];
1166 1167 1168 1169 1170 1171

        if (machine) {
            PRBool isAccessible = PR_FALSE;
            machine->vtbl->GetAccessible(machine, &isAccessible);
            if (isAccessible) {
                machine->vtbl->GetState(machine, &state);
1172 1173
                if ((state >= MachineState_FirstOnline) &&
                    (state <= MachineState_LastOnline))
1174
                    ret++;
1175 1176 1177 1178 1179
            }
        }
    }

cleanup:
1180
    vboxArrayRelease(&machines);
1181 1182 1183 1184
    return ret;
}

static virDomainPtr vboxDomainCreateXML(virConnectPtr conn, const char *xml,
1185
                                        unsigned int flags) {
1186 1187 1188 1189 1190 1191 1192 1193
    /* VirtualBox currently doesn't have support for running
     * virtual machines without actually defining them and thus
     * for time being just define new machine and start it.
     *
     * TODO: After the appropriate API's are added in VirtualBox
     * change this behaviour to the expected one.
     */

1194 1195 1196 1197 1198
    virDomainPtr dom;

    virCheckFlags(0, NULL);

    dom = vboxDomainDefineXML(conn, xml);
1199 1200 1201 1202
    if (dom == NULL)
        return NULL;

    if (vboxDomainCreate(dom) < 0) {
1203
        vboxDomainUndefineFlags(dom, 0);
1204
        virObjectUnref(dom);
1205
        return NULL;
1206 1207 1208 1209 1210 1211
    }

    return dom;
}

static virDomainPtr vboxDomainLookupByID(virConnectPtr conn, int id) {
1212
    VBOX_OBJECT_CHECK(conn, virDomainPtr, NULL);
1213
    vboxArray machines = VBOX_ARRAY_INITIALIZER;
1214 1215
    vboxIID iid = VBOX_IID_INITIALIZER;
    unsigned char uuid[VIR_UUID_BUFLEN];
1216
    PRUint32 state;
1217
    nsresult rc;
1218

1219 1220 1221
    /* Internal vbox IDs start from 0, the public libvirt ID
     * starts from 1, so refuse id==0, and adjust the rest*/
    if (id == 0) {
1222 1223
        virReportError(VIR_ERR_NO_DOMAIN,
                       _("no domain with matching id %d"), id);
1224 1225 1226 1227
        return NULL;
    }
    id = id - 1;

1228
    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
1229
    if (NS_FAILED(rc)) {
1230 1231
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Could not get list of machines, rc=%08x"), (unsigned)rc);
1232 1233
        return NULL;
    }
1234

1235 1236 1237 1238
    if (id < machines.count) {
        IMachine *machine = machines.items[id];

        if (machine) {
1239
            PRBool isAccessible = PR_FALSE;
1240
            machine->vtbl->GetAccessible(machine, &isAccessible);
1241
            if (isAccessible) {
1242
                machine->vtbl->GetState(machine, &state);
1243 1244
                if ((state >= MachineState_FirstOnline) &&
                    (state <= MachineState_LastOnline)) {
1245 1246
                    PRUnichar *machineNameUtf16 = NULL;
                    char      *machineNameUtf8  = NULL;
1247

1248
                    machine->vtbl->GetName(machine, &machineNameUtf16);
1249
                    VBOX_UTF16_TO_UTF8(machineNameUtf16, &machineNameUtf8);
1250

1251 1252 1253
                    machine->vtbl->GetId(machine, &iid.value);
                    vboxIIDToUUID(&iid, uuid);
                    vboxIIDUnalloc(&iid);
1254 1255 1256 1257 1258 1259 1260

                    /* get a new domain pointer from virGetDomain, if it fails
                     * then no need to assign the id, else assign the id, cause
                     * it is -1 by default. rest is taken care by virGetDomain
                     * itself, so need not worry.
                     */

1261
                    ret = virGetDomain(conn, machineNameUtf8, uuid);
1262 1263 1264 1265 1266 1267
                    if (ret)
                        ret->id = id + 1;

                    /* Cleanup all the XPCOM allocated stuff here */
                    VBOX_UTF8_FREE(machineNameUtf8);
                    VBOX_UTF16_FREE(machineNameUtf16);
1268 1269 1270 1271 1272
                }
            }
        }
    }

1273
    vboxArrayRelease(&machines);
1274 1275

    return ret;
1276 1277 1278
}

static virDomainPtr vboxDomainLookupByUUID(virConnectPtr conn, const unsigned char *uuid) {
1279
    VBOX_OBJECT_CHECK(conn, virDomainPtr, NULL);
1280
    vboxArray machines = VBOX_ARRAY_INITIALIZER;
1281
    vboxIID iid = VBOX_IID_INITIALIZER;
1282
    char      *machineNameUtf8  = NULL;
1283
    PRUnichar *machineNameUtf16 = NULL;
1284
    unsigned char iid_as_uuid[VIR_UUID_BUFLEN];
1285
    int i, matched = 0;
1286
    nsresult rc;
1287

1288
    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
1289
    if (NS_FAILED(rc)) {
1290 1291
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Could not get list of machines, rc=%08x"), (unsigned)rc);
1292 1293
        return NULL;
    }
1294

1295 1296
    for (i = 0; i < machines.count; ++i) {
        IMachine *machine = machines.items[i];
1297
        PRBool isAccessible = PR_FALSE;
1298

1299 1300
        if (!machine)
            continue;
1301

1302 1303
        machine->vtbl->GetAccessible(machine, &isAccessible);
        if (isAccessible) {
1304

1305 1306
            rc = machine->vtbl->GetId(machine, &iid.value);
            if (NS_FAILED(rc))
1307
                continue;
1308 1309
            vboxIIDToUUID(&iid, iid_as_uuid);
            vboxIIDUnalloc(&iid);
1310

1311
            if (memcmp(uuid, iid_as_uuid, VIR_UUID_BUFLEN) == 0) {
1312

1313
                PRUint32 state;
1314

1315
                matched = 1;
1316

1317 1318
                machine->vtbl->GetName(machine, &machineNameUtf16);
                VBOX_UTF16_TO_UTF8(machineNameUtf16, &machineNameUtf8);
1319

1320
                machine->vtbl->GetState(machine, &state);
1321

1322 1323 1324 1325 1326
                /* get a new domain pointer from virGetDomain, if it fails
                 * then no need to assign the id, else assign the id, cause
                 * it is -1 by default. rest is taken care by virGetDomain
                 * itself, so need not worry.
                 */
1327

1328
                ret = virGetDomain(conn, machineNameUtf8, iid_as_uuid);
1329 1330 1331
                if (ret &&
                    (state >= MachineState_FirstOnline) &&
                    (state <= MachineState_LastOnline))
1332
                    ret->id = i + 1;
1333 1334
            }

1335 1336
            if (matched == 1)
                break;
1337 1338 1339
        }
    }

1340 1341 1342
    /* Do the cleanup and take care you dont leak any memory */
    VBOX_UTF8_FREE(machineNameUtf8);
    VBOX_COM_UNALLOC_MEM(machineNameUtf16);
1343
    vboxArrayRelease(&machines);
1344 1345

    return ret;
1346 1347 1348
}

static virDomainPtr vboxDomainLookupByName(virConnectPtr conn, const char *name) {
1349
    VBOX_OBJECT_CHECK(conn, virDomainPtr, NULL);
1350
    vboxArray machines = VBOX_ARRAY_INITIALIZER;
1351
    vboxIID iid = VBOX_IID_INITIALIZER;
1352
    char      *machineNameUtf8  = NULL;
1353
    PRUnichar *machineNameUtf16 = NULL;
1354
    unsigned char uuid[VIR_UUID_BUFLEN];
1355
    int i, matched = 0;
1356
    nsresult rc;
1357

1358
    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
1359
    if (NS_FAILED(rc)) {
1360 1361
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Could not get list of machines, rc=%08x"), (unsigned)rc);
1362 1363
        return NULL;
    }
1364

1365 1366
    for (i = 0; i < machines.count; ++i) {
        IMachine *machine = machines.items[i];
1367
        PRBool isAccessible = PR_FALSE;
1368

1369 1370
        if (!machine)
            continue;
1371

1372 1373
        machine->vtbl->GetAccessible(machine, &isAccessible);
        if (isAccessible) {
1374

1375 1376
            machine->vtbl->GetName(machine, &machineNameUtf16);
            VBOX_UTF16_TO_UTF8(machineNameUtf16, &machineNameUtf8);
1377

1378
            if (STREQ(name, machineNameUtf8)) {
1379

1380
                PRUint32 state;
1381

1382
                matched = 1;
1383

1384 1385 1386
                machine->vtbl->GetId(machine, &iid.value);
                vboxIIDToUUID(&iid, uuid);
                vboxIIDUnalloc(&iid);
1387

1388
                machine->vtbl->GetState(machine, &state);
1389

1390 1391 1392 1393 1394
                /* get a new domain pointer from virGetDomain, if it fails
                 * then no need to assign the id, else assign the id, cause
                 * it is -1 by default. rest is taken care by virGetDomain
                 * itself, so need not worry.
                 */
1395

1396
                ret = virGetDomain(conn, machineNameUtf8, uuid);
1397 1398 1399
                if (ret &&
                    (state >= MachineState_FirstOnline) &&
                    (state <= MachineState_LastOnline))
1400
                    ret->id = i + 1;
1401 1402
            }

1403 1404 1405 1406 1407 1408 1409 1410 1411 1412
            if (machineNameUtf8) {
                VBOX_UTF8_FREE(machineNameUtf8);
                machineNameUtf8 = NULL;
            }
            if (machineNameUtf16) {
                VBOX_COM_UNALLOC_MEM(machineNameUtf16);
                machineNameUtf16 = NULL;
            }
            if (matched == 1)
                break;
1413 1414 1415
        }
    }

1416
    vboxArrayRelease(&machines);
1417 1418

    return ret;
1419 1420
}

1421 1422

static int vboxDomainIsActive(virDomainPtr dom) {
1423
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
1424
    vboxArray machines = VBOX_ARRAY_INITIALIZER;
1425
    vboxIID iid = VBOX_IID_INITIALIZER;
1426 1427
    char      *machineNameUtf8  = NULL;
    PRUnichar *machineNameUtf16 = NULL;
1428
    unsigned char uuid[VIR_UUID_BUFLEN];
1429
    int i, matched = 0;
1430
    nsresult rc;
1431

1432
    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
1433
    if (NS_FAILED(rc)) {
1434 1435
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Could not get list of machines, rc=%08x"), (unsigned)rc);
1436 1437
        return ret;
    }
1438

1439 1440
    for (i = 0; i < machines.count; ++i) {
        IMachine *machine = machines.items[i];
1441 1442 1443 1444 1445 1446 1447
        PRBool isAccessible = PR_FALSE;

        if (!machine)
            continue;

        machine->vtbl->GetAccessible(machine, &isAccessible);
        if (isAccessible) {
1448

1449 1450
            rc = machine->vtbl->GetId(machine, &iid.value);
            if (NS_FAILED(rc))
1451
                continue;
1452 1453
            vboxIIDToUUID(&iid, uuid);
            vboxIIDUnalloc(&iid);
1454

1455
            if (memcmp(dom->uuid, uuid, VIR_UUID_BUFLEN) == 0) {
1456

1457
                PRUint32 state;
1458

1459
                matched = 1;
1460

1461 1462
                machine->vtbl->GetName(machine, &machineNameUtf16);
                VBOX_UTF16_TO_UTF8(machineNameUtf16, &machineNameUtf8);
1463

1464
                machine->vtbl->GetState(machine, &state);
1465

1466 1467
                if ((state >= MachineState_FirstOnline) &&
                    (state <= MachineState_LastOnline))
1468 1469 1470
                    ret = 1;
                else
                    ret = 0;
1471 1472
            }

1473 1474
            if (matched == 1)
                break;
1475 1476 1477
        }
    }

1478 1479 1480
    /* Do the cleanup and take care you dont leak any memory */
    VBOX_UTF8_FREE(machineNameUtf8);
    VBOX_COM_UNALLOC_MEM(machineNameUtf16);
1481
    vboxArrayRelease(&machines);
1482

1483 1484 1485 1486
    return ret;
}


1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498
static int vboxDomainIsPersistent(virDomainPtr dom ATTRIBUTE_UNUSED)
{
    /* All domains are persistent.  However, we do want to check for
     * existence. */
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
    vboxIID iid = VBOX_IID_INITIALIZER;
    IMachine *machine = NULL;
    nsresult rc;

    vboxIIDFromUUID(&iid, dom->uuid);
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
    if (NS_FAILED(rc)) {
1499 1500
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching UUID"));
1501 1502 1503 1504 1505 1506 1507 1508 1509
        goto cleanup;
    }

    ret = 1;

cleanup:
    VBOX_RELEASE(machine);
    vboxIIDUnalloc(&iid);
    return ret;
1510 1511 1512
}


1513
static int vboxDomainIsUpdated(virDomainPtr dom ATTRIBUTE_UNUSED) {
1514 1515 1516 1517 1518 1519 1520 1521 1522 1523
    /* VBox domains never have a persistent state that differs from
     * current state.  However, we do want to check for existence.  */
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
    vboxIID iid = VBOX_IID_INITIALIZER;
    IMachine *machine = NULL;
    nsresult rc;

    vboxIIDFromUUID(&iid, dom->uuid);
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
    if (NS_FAILED(rc)) {
1524 1525
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching UUID"));
1526 1527 1528 1529 1530 1531 1532 1533 1534
        goto cleanup;
    }

    ret = 0;

cleanup:
    VBOX_RELEASE(machine);
    vboxIIDUnalloc(&iid);
    return ret;
1535 1536
}

1537
static int vboxDomainSuspend(virDomainPtr dom) {
1538
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
1539
    IMachine *machine    = NULL;
1540
    vboxIID iid = VBOX_IID_INITIALIZER;
1541
    IConsole *console    = NULL;
1542
    PRBool isAccessible  = PR_FALSE;
1543
    PRUint32 state;
1544
    nsresult rc;
1545

1546
    vboxIIDFromUUID(&iid, dom->uuid);
1547
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
1548
    if (NS_FAILED(rc)) {
1549 1550
        virReportError(VIR_ERR_NO_DOMAIN,
                       _("no domain with matching id %d"), dom->id);
1551 1552
        goto cleanup;
    }
1553

1554 1555
    if (!machine)
        goto cleanup;
1556

1557 1558 1559
    machine->vtbl->GetAccessible(machine, &isAccessible);
    if (isAccessible) {
        machine->vtbl->GetState(machine, &state);
1560

1561
        if (state == MachineState_Running) {
1562 1563
            /* set state pause */
            VBOX_SESSION_OPEN_EXISTING(iid.value, machine);
1564 1565 1566 1567 1568
            data->vboxSession->vtbl->GetConsole(data->vboxSession, &console);
            if (console) {
                console->vtbl->Pause(console);
                VBOX_RELEASE(console);
                ret = 0;
1569
            } else {
1570 1571
                virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                               _("error while suspending the domain"));
1572 1573
                goto cleanup;
            }
1574
            VBOX_SESSION_CLOSE();
1575
        } else {
1576 1577
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("machine not in running state to suspend it"));
1578
            goto cleanup;
1579 1580 1581 1582
        }
    }

cleanup:
1583
    VBOX_RELEASE(machine);
1584
    vboxIIDUnalloc(&iid);
1585 1586 1587 1588
    return ret;
}

static int vboxDomainResume(virDomainPtr dom) {
1589
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
1590
    IMachine *machine    = NULL;
1591
    vboxIID iid = VBOX_IID_INITIALIZER;
1592 1593
    IConsole *console    = NULL;
    PRUint32 state       = MachineState_Null;
1594
    nsresult rc;
1595

1596
    PRBool isAccessible = PR_FALSE;
1597

1598
    vboxIIDFromUUID(&iid, dom->uuid);
1599
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
1600
    if (NS_FAILED(rc)) {
1601 1602
        virReportError(VIR_ERR_NO_DOMAIN,
                       _("no domain with matching id %d"), dom->id);
1603 1604
        goto cleanup;
    }
1605

1606 1607
    if (!machine)
        goto cleanup;
1608

1609 1610 1611 1612 1613
    machine->vtbl->GetAccessible(machine, &isAccessible);
    if (isAccessible) {
        machine->vtbl->GetState(machine, &state);

        if (state == MachineState_Paused) {
1614 1615
            /* resume the machine here */
            VBOX_SESSION_OPEN_EXISTING(iid.value, machine);
1616 1617 1618 1619 1620
            data->vboxSession->vtbl->GetConsole(data->vboxSession, &console);
            if (console) {
                console->vtbl->Resume(console);
                VBOX_RELEASE(console);
                ret = 0;
1621
            } else {
1622 1623
                virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                               _("error while resuming the domain"));
1624 1625
                goto cleanup;
            }
1626
            VBOX_SESSION_CLOSE();
1627
        } else {
1628 1629
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("machine not paused, so can't resume it"));
1630
            goto cleanup;
1631 1632 1633 1634
        }
    }

cleanup:
1635
    VBOX_RELEASE(machine);
1636
    vboxIIDUnalloc(&iid);
1637 1638 1639
    return ret;
}

1640 1641
static int vboxDomainShutdownFlags(virDomainPtr dom,
                                   unsigned int flags) {
1642
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
1643
    IMachine *machine    = NULL;
1644
    vboxIID iid = VBOX_IID_INITIALIZER;
1645 1646
    IConsole *console    = NULL;
    PRUint32 state       = MachineState_Null;
1647 1648
    PRBool isAccessible  = PR_FALSE;
    nsresult rc;
1649

1650 1651
    virCheckFlags(0, -1);

1652
    vboxIIDFromUUID(&iid, dom->uuid);
1653
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
1654
    if (NS_FAILED(rc)) {
1655 1656
        virReportError(VIR_ERR_NO_DOMAIN,
                       _("no domain with matching id %d"), dom->id);
1657 1658
        goto cleanup;
    }
1659

1660 1661
    if (!machine)
        goto cleanup;
1662

1663 1664 1665
    machine->vtbl->GetAccessible(machine, &isAccessible);
    if (isAccessible) {
        machine->vtbl->GetState(machine, &state);
1666

1667
        if (state == MachineState_Paused) {
1668 1669
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("machine paused, so can't power it down"));
1670 1671
            goto cleanup;
        } else if (state == MachineState_PoweredOff) {
1672 1673
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("machine already powered down"));
1674 1675
            goto cleanup;
        }
1676

1677
        VBOX_SESSION_OPEN_EXISTING(iid.value, machine);
1678 1679 1680 1681 1682
        data->vboxSession->vtbl->GetConsole(data->vboxSession, &console);
        if (console) {
            console->vtbl->PowerButton(console);
            VBOX_RELEASE(console);
            ret = 0;
1683
        }
1684
        VBOX_SESSION_CLOSE();
1685 1686 1687
    }

cleanup:
1688
    VBOX_RELEASE(machine);
1689
    vboxIIDUnalloc(&iid);
1690 1691 1692
    return ret;
}

1693 1694 1695 1696 1697
static int vboxDomainShutdown(virDomainPtr dom) {
    return vboxDomainShutdownFlags(dom, 0);
}


E
Eric Blake 已提交
1698 1699
static int vboxDomainReboot(virDomainPtr dom, unsigned int flags)
{
1700
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
1701
    IMachine *machine    = NULL;
1702
    vboxIID iid = VBOX_IID_INITIALIZER;
1703 1704
    IConsole *console    = NULL;
    PRUint32 state       = MachineState_Null;
1705 1706
    PRBool isAccessible  = PR_FALSE;
    nsresult rc;
1707

E
Eric Blake 已提交
1708 1709
    virCheckFlags(0, -1);

1710
    vboxIIDFromUUID(&iid, dom->uuid);
1711
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
1712
    if (NS_FAILED(rc)) {
1713 1714
        virReportError(VIR_ERR_NO_DOMAIN,
                       _("no domain with matching id %d"), dom->id);
1715 1716
        goto cleanup;
    }
1717

1718 1719
    if (!machine)
        goto cleanup;
1720

1721 1722 1723
    machine->vtbl->GetAccessible(machine, &isAccessible);
    if (isAccessible) {
        machine->vtbl->GetState(machine, &state);
1724

1725
        if (state == MachineState_Running) {
1726
            VBOX_SESSION_OPEN_EXISTING(iid.value, machine);
1727 1728 1729 1730 1731
            data->vboxSession->vtbl->GetConsole(data->vboxSession, &console);
            if (console) {
                console->vtbl->Reset(console);
                VBOX_RELEASE(console);
                ret = 0;
1732
            }
1733
            VBOX_SESSION_CLOSE();
1734
        } else {
1735 1736
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("machine not running, so can't reboot it"));
1737
            goto cleanup;
1738 1739 1740 1741
        }
    }

cleanup:
1742
    VBOX_RELEASE(machine);
1743
    vboxIIDUnalloc(&iid);
1744 1745 1746
    return ret;
}

1747 1748 1749 1750
static int
vboxDomainDestroyFlags(virDomainPtr dom,
                       unsigned int flags)
{
1751
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
1752
    IMachine *machine    = NULL;
1753
    vboxIID iid = VBOX_IID_INITIALIZER;
1754 1755
    IConsole *console    = NULL;
    PRUint32 state       = MachineState_Null;
1756 1757
    PRBool isAccessible  = PR_FALSE;
    nsresult rc;
1758

1759 1760
    virCheckFlags(0, -1);

1761
    vboxIIDFromUUID(&iid, dom->uuid);
1762
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
1763
    if (NS_FAILED(rc)) {
1764 1765
        virReportError(VIR_ERR_NO_DOMAIN,
                       _("no domain with matching id %d"), dom->id);
1766 1767
        goto cleanup;
    }
1768

1769 1770
    if (!machine)
        goto cleanup;
1771

1772 1773 1774
    machine->vtbl->GetAccessible(machine, &isAccessible);
    if (isAccessible) {
        machine->vtbl->GetState(machine, &state);
1775

1776
        if (state == MachineState_PoweredOff) {
1777 1778
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("machine already powered down"));
1779 1780
            goto cleanup;
        }
1781

1782
        VBOX_SESSION_OPEN_EXISTING(iid.value, machine);
1783 1784
        data->vboxSession->vtbl->GetConsole(data->vboxSession, &console);
        if (console) {
1785 1786

#if VBOX_API_VERSION == 2002
1787
            console->vtbl->PowerDown(console);
1788
#else
1789
            IProgress *progress = NULL;
1790 1791 1792 1793
            console->vtbl->PowerDown(console, &progress);
            if (progress) {
                progress->vtbl->WaitForCompletion(progress, -1);
                VBOX_RELEASE(progress);
1794
            }
1795 1796
#endif
            VBOX_RELEASE(console);
1797
            dom->id = -1;
1798
            ret = 0;
1799
        }
1800
        VBOX_SESSION_CLOSE();
1801 1802 1803
    }

cleanup:
1804
    VBOX_RELEASE(machine);
1805
    vboxIIDUnalloc(&iid);
1806 1807 1808
    return ret;
}

1809 1810 1811 1812 1813 1814
static int
vboxDomainDestroy(virDomainPtr dom)
{
    return vboxDomainDestroyFlags(dom, 0);
}

1815
static char *vboxDomainGetOSType(virDomainPtr dom ATTRIBUTE_UNUSED) {
1816 1817 1818 1819 1820
    /* Returning "hvm" always as suggested on list, cause
     * this functions seems to be badly named and it
     * is supposed to pass the ABI name and not the domain
     * operating system driver as I had imagined ;)
     */
1821 1822 1823
    char *osType = strdup("hvm");

    if (osType == NULL)
1824
        virReportOOMError();
1825 1826

    return osType;
1827 1828 1829
}

static int vboxDomainSetMemory(virDomainPtr dom, unsigned long memory) {
1830
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
1831
    IMachine *machine    = NULL;
1832
    vboxIID iid = VBOX_IID_INITIALIZER;
1833
    PRUint32 state       = MachineState_Null;
1834 1835
    PRBool isAccessible  = PR_FALSE;
    nsresult rc;
1836

1837
    vboxIIDFromUUID(&iid, dom->uuid);
1838
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
1839
    if (NS_FAILED(rc)) {
1840 1841
        virReportError(VIR_ERR_NO_DOMAIN,
                       _("no domain with matching id %d"), dom->id);
1842 1843
        goto cleanup;
    }
1844

1845 1846
    if (!machine)
        goto cleanup;
1847

1848 1849 1850
    machine->vtbl->GetAccessible(machine, &isAccessible);
    if (isAccessible) {
        machine->vtbl->GetState(machine, &state);
1851

1852
        if (state != MachineState_PoweredOff) {
1853 1854
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("memory size can't be changed unless domain is powered down"));
1855 1856
            goto cleanup;
        }
1857

1858
        rc = VBOX_SESSION_OPEN(iid.value, machine);
1859 1860 1861
        if (NS_SUCCEEDED(rc)) {
            rc = data->vboxSession->vtbl->GetMachine(data->vboxSession, &machine);
            if (NS_SUCCEEDED(rc) && machine) {
1862

1863 1864
                rc = machine->vtbl->SetMemorySize(machine,
                                                  VIR_DIV_UP(memory, 1024));
1865 1866 1867 1868
                if (NS_SUCCEEDED(rc)) {
                    machine->vtbl->SaveSettings(machine);
                    ret = 0;
                } else {
1869 1870 1871 1872
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("could not set the memory size of the "
                                     "domain to: %lu Kb, rc=%08x"),
                                   memory, (unsigned)rc);
1873 1874
                }
            }
1875
            VBOX_SESSION_CLOSE();
1876 1877 1878 1879
        }
    }

cleanup:
1880
    VBOX_RELEASE(machine);
1881
    vboxIIDUnalloc(&iid);
1882 1883 1884 1885
    return ret;
}

static int vboxDomainGetInfo(virDomainPtr dom, virDomainInfoPtr info) {
1886
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
1887
    vboxArray machines = VBOX_ARRAY_INITIALIZER;
1888 1889
    char *machineName    = NULL;
    PRUnichar *machineNameUtf16 = NULL;
1890 1891
    nsresult rc;
    int i = 0;
1892

1893
    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
1894
    if (NS_FAILED(rc)) {
1895 1896
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Could not get list of machines, rc=%08x"), (unsigned)rc);
1897 1898
        goto cleanup;
    }
1899

1900
    info->nrVirtCpu = 0;
1901 1902
    for (i = 0; i < machines.count; ++i) {
        IMachine *machine = machines.items[i];
1903
        PRBool isAccessible = PR_FALSE;
1904

1905 1906
        if (!machine)
            continue;
1907

1908 1909
        machine->vtbl->GetAccessible(machine, &isAccessible);
        if (isAccessible) {
1910

1911 1912 1913 1914 1915 1916
            machine->vtbl->GetName(machine, &machineNameUtf16);
            VBOX_UTF16_TO_UTF8(machineNameUtf16, &machineName);

            if (STREQ(dom->name, machineName)) {
                /* Get the Machine State (also match it with
                * virDomainState). Get the Machine memory and
1917
                * for time being set max_balloon and cur_balloon to same
1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934
                * Also since there is no direct way of checking
                * the cputime required (one condition being the
                * VM is remote), return zero for cputime. Get the
                * number of CPU.
                */
                PRUint32 CPUCount   = 0;
                PRUint32 memorySize = 0;
                PRUint32 state      = MachineState_Null;
                PRUint32 maxMemorySize = 4 * 1024;
                ISystemProperties *systemProperties = NULL;

                data->vboxObj->vtbl->GetSystemProperties(data->vboxObj, &systemProperties);
                if (systemProperties) {
                    systemProperties->vtbl->GetMaxGuestRAM(systemProperties, &maxMemorySize);
                    VBOX_RELEASE(systemProperties);
                    systemProperties = NULL;
                }
1935 1936


1937 1938 1939 1940 1941 1942
                machine->vtbl->GetCPUCount(machine, &CPUCount);
                machine->vtbl->GetMemorySize(machine, &memorySize);
                machine->vtbl->GetState(machine, &state);

                info->cpuTime = 0;
                info->nrVirtCpu = CPUCount;
1943 1944
                info->memory = memorySize * 1024;
                info->maxMem = maxMemorySize * 1024;
1945
                switch (state) {
1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967
                    case MachineState_Running:
                        info->state = VIR_DOMAIN_RUNNING;
                        break;
                    case MachineState_Stuck:
                        info->state = VIR_DOMAIN_BLOCKED;
                        break;
                    case MachineState_Paused:
                        info->state = VIR_DOMAIN_PAUSED;
                        break;
                    case MachineState_Stopping:
                        info->state = VIR_DOMAIN_SHUTDOWN;
                        break;
                    case MachineState_PoweredOff:
                        info->state = VIR_DOMAIN_SHUTOFF;
                        break;
                    case MachineState_Aborted:
                        info->state = VIR_DOMAIN_CRASHED;
                        break;
                    case MachineState_Null:
                    default:
                        info->state = VIR_DOMAIN_NOSTATE;
                        break;
1968 1969
                }

1970
                ret = 0;
1971 1972
            }

1973 1974 1975 1976 1977 1978
            if (machineName)
                VBOX_UTF8_FREE(machineName);
            if (machineNameUtf16)
                VBOX_COM_UNALLOC_MEM(machineNameUtf16);
            if (info->nrVirtCpu)
                break;
1979 1980 1981 1982
        }

    }

1983
    vboxArrayRelease(&machines);
1984 1985 1986 1987 1988

cleanup:
    return ret;
}

1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005
static int
vboxDomainGetState(virDomainPtr dom,
                   int *state,
                   int *reason,
                   unsigned int flags)
{
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
    vboxIID domiid = VBOX_IID_INITIALIZER;
    IMachine *machine = NULL;
    PRUint32 mstate = MachineState_Null;
    nsresult rc;

    virCheckFlags(0, -1);

    vboxIIDFromUUID(&domiid, dom->uuid);
    rc = VBOX_OBJECT_GET_MACHINE(domiid.value, &machine);
    if (NS_FAILED(rc)) {
2006 2007
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching UUID"));
2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047
        goto cleanup;
    }

    machine->vtbl->GetState(machine, &mstate);

    switch (mstate) {
    case MachineState_Running:
        *state = VIR_DOMAIN_RUNNING;
        break;
    case MachineState_Stuck:
        *state = VIR_DOMAIN_BLOCKED;
        break;
    case MachineState_Paused:
        *state = VIR_DOMAIN_PAUSED;
        break;
    case MachineState_Stopping:
        *state = VIR_DOMAIN_SHUTDOWN;
        break;
    case MachineState_PoweredOff:
        *state = VIR_DOMAIN_SHUTOFF;
        break;
    case MachineState_Aborted:
        *state = VIR_DOMAIN_CRASHED;
        break;
    case MachineState_Null:
    default:
        *state = VIR_DOMAIN_NOSTATE;
        break;
    }

    if (reason)
        *reason = 0;

    ret = 0;

cleanup:
    vboxIIDUnalloc(&domiid);
    return ret;
}

2048
static int vboxDomainSave(virDomainPtr dom, const char *path ATTRIBUTE_UNUSED) {
2049
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
2050
    IConsole *console    = NULL;
2051
    vboxIID iid = VBOX_IID_INITIALIZER;
2052
    IMachine *machine = NULL;
2053
    nsresult rc;
2054 2055 2056 2057 2058 2059 2060 2061

    /* VirtualBox currently doesn't support saving to a file
     * at a location other then the machine folder and thus
     * setting path to ATTRIBUTE_UNUSED for now, will change
     * this behaviour once get the VirtualBox API in right
     * shape to do this
     */

2062
    /* Open a Session for the machine */
2063
    vboxIIDFromUUID(&iid, dom->uuid);
2064 2065 2066 2067
#if VBOX_API_VERSION >= 4000
    /* Get machine for the call to VBOX_SESSION_OPEN_EXISTING */
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
    if (NS_FAILED(rc)) {
2068 2069
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching uuid"));
2070 2071 2072 2073 2074
        return -1;
    }
#endif

    rc = VBOX_SESSION_OPEN_EXISTING(iid.value, machine);
2075 2076 2077 2078
    if (NS_SUCCEEDED(rc)) {
        rc = data->vboxSession->vtbl->GetConsole(data->vboxSession, &console);
        if (NS_SUCCEEDED(rc) && console) {
            IProgress *progress = NULL;
2079

2080
            console->vtbl->SaveState(console, &progress);
2081

2082
            if (progress) {
2083
#if VBOX_API_VERSION == 2002
2084
                nsresult resultCode;
2085
#else
2086
                PRInt32 resultCode;
2087
#endif
2088

2089 2090 2091 2092
                progress->vtbl->WaitForCompletion(progress, -1);
                progress->vtbl->GetResultCode(progress, &resultCode);
                if (NS_SUCCEEDED(resultCode)) {
                    ret = 0;
2093
                }
2094
                VBOX_RELEASE(progress);
2095
            }
2096
            VBOX_RELEASE(console);
2097
        }
2098
        VBOX_SESSION_CLOSE();
2099 2100
    }

2101
    DEBUGIID("UUID of machine being saved:", iid.value);
2102

2103
    VBOX_RELEASE(machine);
2104
    vboxIIDUnalloc(&iid);
2105 2106 2107
    return ret;
}

2108 2109 2110 2111
static int
vboxDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
                        unsigned int flags)
{
2112
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
2113
    IMachine *machine    = NULL;
2114
    vboxIID iid = VBOX_IID_INITIALIZER;
2115
    PRUint32  CPUCount   = nvcpus;
2116
    nsresult rc;
2117

2118
    if (flags != VIR_DOMAIN_AFFECT_LIVE) {
2119
        virReportError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), flags);
2120 2121 2122
        return -1;
    }

2123
    vboxIIDFromUUID(&iid, dom->uuid);
2124 2125 2126 2127
#if VBOX_API_VERSION >= 4000
    /* Get machine for the call to VBOX_SESSION_OPEN */
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
    if (NS_FAILED(rc)) {
2128 2129
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching uuid"));
2130 2131 2132 2133 2134
        return -1;
    }
#endif

    rc = VBOX_SESSION_OPEN(iid.value, machine);
2135 2136 2137 2138 2139 2140 2141
    if (NS_SUCCEEDED(rc)) {
        data->vboxSession->vtbl->GetMachine(data->vboxSession, &machine);
        if (machine) {
            rc = machine->vtbl->SetCPUCount(machine, CPUCount);
            if (NS_SUCCEEDED(rc)) {
                machine->vtbl->SaveSettings(machine);
                ret = 0;
2142
            } else {
2143 2144 2145 2146
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("could not set the number of cpus of the domain "
                                 "to: %u, rc=%08x"),
                               CPUCount, (unsigned)rc);
2147
            }
2148
            VBOX_RELEASE(machine);
2149
        } else {
2150 2151
            virReportError(VIR_ERR_NO_DOMAIN,
                           _("no domain with matching id %d"), dom->id);
2152
        }
2153
    } else {
2154 2155
        virReportError(VIR_ERR_NO_DOMAIN,
                       _("can't open session to the domain with id %d"), dom->id);
2156
    }
2157
    VBOX_SESSION_CLOSE();
2158

2159
    vboxIIDUnalloc(&iid);
2160 2161 2162
    return ret;
}

2163 2164 2165
static int
vboxDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus)
{
2166
    return vboxDomainSetVcpusFlags(dom, nvcpus, VIR_DOMAIN_AFFECT_LIVE);
2167 2168 2169 2170 2171
}

static int
vboxDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
{
2172 2173
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
    ISystemProperties *systemProperties = NULL;
2174 2175
    PRUint32 maxCPUCount = 0;

2176
    if (flags != (VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_VCPU_MAXIMUM)) {
2177
        virReportError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), flags);
2178 2179 2180
        return -1;
    }

2181 2182 2183 2184 2185
    /* Currently every domain supports the same number of max cpus
     * as that supported by vbox and thus take it directly from
     * the systemproperties.
     */

2186 2187 2188 2189
    data->vboxObj->vtbl->GetSystemProperties(data->vboxObj, &systemProperties);
    if (systemProperties) {
        systemProperties->vtbl->GetMaxGuestCPUCount(systemProperties, &maxCPUCount);
        VBOX_RELEASE(systemProperties);
2190 2191 2192 2193 2194 2195 2196 2197
    }

    if (maxCPUCount > 0)
        ret = maxCPUCount;

    return ret;
}

2198 2199 2200
static int
vboxDomainGetMaxVcpus(virDomainPtr dom)
{
2201
    return vboxDomainGetVcpusFlags(dom, (VIR_DOMAIN_AFFECT_LIVE |
2202 2203 2204
                                         VIR_DOMAIN_VCPU_MAXIMUM));
}

2205
static char *vboxDomainGetXMLDesc(virDomainPtr dom, unsigned int flags) {
2206
    VBOX_OBJECT_CHECK(dom->conn, char *, NULL);
2207 2208
    virDomainDefPtr def  = NULL;
    IMachine *machine    = NULL;
2209
    vboxIID iid = VBOX_IID_INITIALIZER;
2210
    int gotAllABoutDef   = -1;
2211
    nsresult rc;
2212
    char *tmp;
2213

2214 2215
    /* Flags checked by virDomainDefFormat */

2216
    if (VIR_ALLOC(def) < 0) {
2217
        virReportOOMError();
2218 2219 2220
        goto cleanup;
    }

2221
    vboxIIDFromUUID(&iid, dom->uuid);
2222
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
2223
    if (NS_SUCCEEDED(rc)) {
2224
        PRBool accessible = PR_FALSE;
2225

2226 2227 2228 2229 2230 2231
        machine->vtbl->GetAccessible(machine, &accessible);
        if (accessible) {
            int i = 0;
            PRBool PAEEnabled                   = PR_FALSE;
            PRBool ACPIEnabled                  = PR_FALSE;
            PRBool IOAPICEnabled                = PR_FALSE;
2232
            PRBool VRDxEnabled                  = PR_FALSE;
2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254
            PRUint32 CPUCount                   = 0;
            PRUint32 memorySize                 = 0;
            PRUint32 netAdpCnt                  = 0;
            PRUint32 netAdpIncCnt               = 0;
            PRUint32 maxMemorySize              = 4 * 1024;
            PRUint32 USBFilterCount             = 0;
            PRUint32 maxBootPosition            = 0;
            PRUint32 serialPortCount            = 0;
            PRUint32 serialPortIncCount         = 0;
            PRUint32 parallelPortCount          = 0;
            PRUint32 parallelPortIncCount       = 0;
            IBIOSSettings *bios                 = NULL;
#if VBOX_API_VERSION < 3001
            PRInt32       hddNum                = 0;
            IDVDDrive    *dvdDrive              = NULL;
            IHardDisk    *hardDiskPM            = NULL;
            IHardDisk    *hardDiskPS            = NULL;
            IHardDisk    *hardDiskSS            = NULL;
            const char   *hddBus                = "IDE";
            PRUnichar    *hddBusUtf16           = NULL;
            IFloppyDrive *floppyDrive           = NULL;
#else  /* VBOX_API_VERSION >= 3001 */
2255
            vboxArray mediumAttachments         = VBOX_ARRAY_INITIALIZER;
2256
#endif /* VBOX_API_VERSION >= 3001 */
2257 2258 2259 2260 2261
#if VBOX_API_VERSION < 4000
            IVRDPServer *VRDxServer             = NULL;
#else  /* VBOX_API_VERSION >= 4000 */
            IVRDEServer *VRDxServer             = NULL;
#endif /* VBOX_API_VERSION >= 4000 */
2262 2263
            IAudioAdapter *audioAdapter         = NULL;
            IUSBController *USBController       = NULL;
2264 2265 2266
#if VBOX_API_VERSION >= 4001
            PRUint32 chipsetType                = ChipsetType_Null;
#endif /* VBOX_API_VERSION >= 4001 */
2267
            ISystemProperties *systemProperties = NULL;
2268 2269


2270 2271 2272 2273
            def->virtType = VIR_DOMAIN_VIRT_VBOX;
            def->id = dom->id;
            memcpy(def->uuid, dom->uuid, VIR_UUID_BUFLEN);
            def->name = strdup(dom->name);
2274

2275
            machine->vtbl->GetMemorySize(machine, &memorySize);
2276
            def->mem.cur_balloon = memorySize * 1024;
2277

2278 2279 2280 2281
#if VBOX_API_VERSION >= 4001
            machine->vtbl->GetChipsetType(machine, &chipsetType);
#endif /* VBOX_API_VERSION >= 4001 */

2282 2283 2284 2285
            data->vboxObj->vtbl->GetSystemProperties(data->vboxObj, &systemProperties);
            if (systemProperties) {
                systemProperties->vtbl->GetMaxGuestRAM(systemProperties, &maxMemorySize);
                systemProperties->vtbl->GetMaxBootPosition(systemProperties, &maxBootPosition);
2286
#if VBOX_API_VERSION < 4001
2287
                systemProperties->vtbl->GetNetworkAdapterCount(systemProperties, &netAdpCnt);
2288 2289 2290
#else  /* VBOX_API_VERSION >= 4000 */
                systemProperties->vtbl->GetMaxNetworkAdapters(systemProperties, chipsetType, &netAdpCnt);
#endif /* VBOX_API_VERSION >= 4000 */
2291 2292 2293 2294 2295 2296 2297 2298 2299
                systemProperties->vtbl->GetSerialPortCount(systemProperties, &serialPortCount);
                systemProperties->vtbl->GetParallelPortCount(systemProperties, &parallelPortCount);
                VBOX_RELEASE(systemProperties);
                systemProperties = NULL;
            }
            /* Currently setting memory and maxMemory as same, cause
             * the notation here seems to be inconsistent while
             * reading and while dumping xml
             */
2300 2301
            /* def->mem.max_balloon = maxMemorySize * 1024; */
            def->mem.max_balloon = memorySize * 1024;
2302 2303

            machine->vtbl->GetCPUCount(machine, &CPUCount);
E
Eric Blake 已提交
2304
            def->maxvcpus = def->vcpus = CPUCount;
2305 2306 2307 2308

            /* Skip cpumasklen, cpumask, onReboot, onPoweroff, onCrash */

            def->os.type = strdup("hvm");
2309

2310
            def->os.arch = virArchFromHost();
2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333

            def->os.nBootDevs = 0;
            for (i = 0; (i < VIR_DOMAIN_BOOT_LAST) && (i < maxBootPosition); i++) {
                PRUint32 device = DeviceType_Null;

                machine->vtbl->GetBootOrder(machine, i+1, &device);

                if (device == DeviceType_Floppy) {
                    def->os.bootDevs[i] = VIR_DOMAIN_BOOT_FLOPPY;
                    def->os.nBootDevs++;
                } else if (device == DeviceType_DVD) {
                    def->os.bootDevs[i] = VIR_DOMAIN_BOOT_CDROM;
                    def->os.nBootDevs++;
                } else if (device == DeviceType_HardDisk) {
                    def->os.bootDevs[i] = VIR_DOMAIN_BOOT_DISK;
                    def->os.nBootDevs++;
                } else if (device == DeviceType_Network) {
                    def->os.bootDevs[i] = VIR_DOMAIN_BOOT_NET;
                    def->os.nBootDevs++;
                } else if (device == DeviceType_USB) {
                    /* Not supported by libvirt yet */
                } else if (device == DeviceType_SharedFolder) {
                    /* Not supported by libvirt yet */
M
Matthias Bolte 已提交
2334
                    /* Can VirtualBox really boot from a shared folder? */
2335
                }
2336
            }
2337

2338 2339 2340
            def->features = 0;
#if VBOX_API_VERSION < 3001
            machine->vtbl->GetPAEEnabled(machine, &PAEEnabled);
2341
#elif VBOX_API_VERSION == 3001
2342
            machine->vtbl->GetCpuProperty(machine, CpuPropertyType_PAE, &PAEEnabled);
2343 2344 2345
#elif VBOX_API_VERSION >= 3002
            machine->vtbl->GetCPUProperty(machine, CPUPropertyType_PAE, &PAEEnabled);
#endif
2346 2347 2348
            if (PAEEnabled) {
                def->features = def->features | (1 << VIR_DOMAIN_FEATURE_PAE);
            }
2349

2350 2351 2352 2353 2354 2355
            machine->vtbl->GetBIOSSettings(machine, &bios);
            if (bios) {
                bios->vtbl->GetACPIEnabled(bios, &ACPIEnabled);
                if (ACPIEnabled) {
                    def->features = def->features | (1 << VIR_DOMAIN_FEATURE_ACPI);
                }
2356

2357 2358 2359
                bios->vtbl->GetIOAPICEnabled(bios, &IOAPICEnabled);
                if (IOAPICEnabled) {
                    def->features = def->features | (1 << VIR_DOMAIN_FEATURE_APIC);
2360 2361
                }

2362 2363 2364 2365 2366
                VBOX_RELEASE(bios);
            }

            /* Currently VirtualBox always uses locatime
             * so locatime is always true here */
2367
            def->clock.offset = VIR_DOMAIN_CLOCK_OFFSET_LOCALTIME;
2368 2369 2370 2371 2372 2373 2374 2375

            /* dump video options vram/2d/3d/directx/etc. */
            {
                /* Currently supports only one graphics card */
                def->nvideos = 1;
                if (VIR_ALLOC_N(def->videos, def->nvideos) >= 0) {
                    if (VIR_ALLOC(def->videos[0]) >= 0) {
                        /* the default is: vram is 8MB, One monitor, 3dAccel Off */
2376
                        PRUint32 VRAMSize          = 8;
2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388
                        PRUint32 monitorCount      = 1;
                        PRBool accelerate3DEnabled = PR_FALSE;
                        PRBool accelerate2DEnabled = PR_FALSE;

                        machine->vtbl->GetVRAMSize(machine, &VRAMSize);
                        machine->vtbl->GetMonitorCount(machine, &monitorCount);
                        machine->vtbl->GetAccelerate3DEnabled(machine, &accelerate3DEnabled);
#if VBOX_API_VERSION >= 3001
                        machine->vtbl->GetAccelerate2DVideoEnabled(machine, &accelerate2DEnabled);
#endif /* VBOX_API_VERSION >= 3001 */

                        def->videos[0]->type            = VIR_DOMAIN_VIDEO_TYPE_VBOX;
2389
                        def->videos[0]->vram            = VRAMSize * 1024;
2390 2391 2392 2393
                        def->videos[0]->heads           = monitorCount;
                        if (VIR_ALLOC(def->videos[0]->accel) >= 0) {
                            def->videos[0]->accel->support3d = accelerate3DEnabled;
                            def->videos[0]->accel->support2d = accelerate2DEnabled;
2394
                        } else
2395
                            virReportOOMError();
2396
                    } else
2397
                        virReportOOMError();
2398
                } else
2399
                    virReportOOMError();
2400
            }
2401

2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412
            /* dump display options vrdp/gui/sdl */
            {
                int vrdpPresent           = 0;
                int sdlPresent            = 0;
                int guiPresent            = 0;
                int totalPresent          = 0;
                char *guiDisplay          = NULL;
                char *sdlDisplay          = NULL;
                PRUnichar *keyTypeUtf16   = NULL;
                PRUnichar *valueTypeUtf16 = NULL;
                char      *valueTypeUtf8  = NULL;
2413

2414
                def->ngraphics = 0;
2415

2416 2417 2418
                VBOX_UTF8_TO_UTF16("FRONTEND/Type", &keyTypeUtf16);
                machine->vtbl->GetExtraData(machine, keyTypeUtf16, &valueTypeUtf16);
                VBOX_UTF16_FREE(keyTypeUtf16);
2419

2420 2421 2422
                if (valueTypeUtf16) {
                    VBOX_UTF16_TO_UTF8(valueTypeUtf16, &valueTypeUtf8);
                    VBOX_UTF16_FREE(valueTypeUtf16);
2423

2424
                    if (STREQ(valueTypeUtf8, "sdl") || STREQ(valueTypeUtf8, "gui")) {
2425 2426 2427
                        PRUnichar *keyDislpayUtf16   = NULL;
                        PRUnichar *valueDisplayUtf16 = NULL;
                        char      *valueDisplayUtf8  = NULL;
2428

2429 2430 2431
                        VBOX_UTF8_TO_UTF16("FRONTEND/Display", &keyDislpayUtf16);
                        machine->vtbl->GetExtraData(machine, keyDislpayUtf16, &valueDisplayUtf16);
                        VBOX_UTF16_FREE(keyDislpayUtf16);
2432

2433 2434 2435
                        if (valueDisplayUtf16) {
                            VBOX_UTF16_TO_UTF8(valueDisplayUtf16, &valueDisplayUtf8);
                            VBOX_UTF16_FREE(valueDisplayUtf16);
2436

2437 2438 2439
                            if (strlen(valueDisplayUtf8) <= 0) {
                                VBOX_UTF8_FREE(valueDisplayUtf8);
                                valueDisplayUtf8 = NULL;
2440 2441
                            }
                        }
2442

2443 2444 2445 2446 2447
                        if (STREQ(valueTypeUtf8, "sdl")) {
                            sdlPresent = 1;
                            if (valueDisplayUtf8)
                                sdlDisplay = strdup(valueDisplayUtf8);
                            if (sdlDisplay == NULL) {
2448
                                virReportOOMError();
2449 2450 2451 2452 2453 2454
                                /* just don't go to cleanup yet as it is ok to have
                                 * sdlDisplay as NULL and we check it below if it
                                 * exist and then only use it there
                                 */
                            }
                            totalPresent++;
2455
                        }
2456

2457 2458 2459 2460 2461
                        if (STREQ(valueTypeUtf8, "gui")) {
                            guiPresent = 1;
                            if (valueDisplayUtf8)
                                guiDisplay = strdup(valueDisplayUtf8);
                            if (guiDisplay == NULL) {
2462
                                virReportOOMError();
2463
                                /* just don't go to cleanup yet as it is ok to have
2464 2465
                                 * guiDisplay as NULL and we check it below if it
                                 * exist and then only use it there
2466
                                 */
2467
                            }
2468 2469
                            totalPresent++;
                        }
2470 2471
                        if (valueDisplayUtf8)
                            VBOX_UTF8_FREE(valueDisplayUtf8);
2472 2473
                    }

2474 2475
                    if (STREQ(valueTypeUtf8, "vrdp"))
                        vrdpPresent = 1;
2476

2477 2478
                    VBOX_UTF8_FREE(valueTypeUtf8);
                }
2479

2480 2481 2482 2483 2484 2485 2486
                if ((totalPresent > 0) && (VIR_ALLOC_N(def->graphics, totalPresent) >= 0)) {
                    if ((guiPresent) && (VIR_ALLOC(def->graphics[def->ngraphics]) >= 0)) {
                        def->graphics[def->ngraphics]->type = VIR_DOMAIN_GRAPHICS_TYPE_DESKTOP;
                        if (guiDisplay)
                            def->graphics[def->ngraphics]->data.desktop.display = guiDisplay;
                        def->ngraphics++;
                    }
2487

2488 2489 2490 2491 2492 2493 2494 2495 2496
                    if ((sdlPresent) && (VIR_ALLOC(def->graphics[def->ngraphics]) >= 0)) {
                        def->graphics[def->ngraphics]->type = VIR_DOMAIN_GRAPHICS_TYPE_SDL;
                        if (sdlDisplay)
                            def->graphics[def->ngraphics]->data.sdl.display = sdlDisplay;
                        def->ngraphics++;
                    }
                } else if ((vrdpPresent != 1) && (totalPresent == 0) && (VIR_ALLOC_N(def->graphics, 1) >= 0)) {
                    if (VIR_ALLOC(def->graphics[def->ngraphics]) >= 0) {
                        def->graphics[def->ngraphics]->type = VIR_DOMAIN_GRAPHICS_TYPE_DESKTOP;
2497 2498 2499 2500 2501 2502 2503 2504 2505
                        tmp = getenv("DISPLAY");
                        if (tmp != NULL) {
                            def->graphics[def->ngraphics]->data.desktop.display = strdup(tmp);
                            if (def->graphics[def->ngraphics]->data.desktop.display == NULL) {
                                virReportOOMError();
                                /* just don't go to cleanup yet as it is ok to have
                                 * display as NULL
                                 */
                            }
2506 2507 2508 2509 2510
                        }
                        totalPresent++;
                        def->ngraphics++;
                    }
                }
2511

2512 2513 2514 2515 2516 2517 2518 2519
#if VBOX_API_VERSION < 4000
                machine->vtbl->GetVRDPServer(machine, &VRDxServer);
#else  /* VBOX_API_VERSION >= 4000 */
                machine->vtbl->GetVRDEServer(machine, &VRDxServer);
#endif /* VBOX_API_VERSION >= 4000 */
                if (VRDxServer) {
                    VRDxServer->vtbl->GetEnabled(VRDxServer, &VRDxEnabled);
                    if (VRDxEnabled) {
2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530

                        totalPresent++;

                        if ((VIR_REALLOC_N(def->graphics, totalPresent) >= 0) &&
                            (VIR_ALLOC(def->graphics[def->ngraphics]) >= 0)) {
                            PRUnichar *netAddressUtf16   = NULL;
                            char      *netAddressUtf8    = NULL;
                            PRBool allowMultiConnection  = PR_FALSE;
                            PRBool reuseSingleConnection = PR_FALSE;
#if VBOX_API_VERSION < 3001
                            PRUint32 VRDPport = 0;
2531
                            VRDxServer->vtbl->GetPort(VRDxServer, &VRDPport);
2532 2533
                            if (VRDPport) {
                                def->graphics[def->ngraphics]->data.rdp.port = VRDPport;
2534
#elif VBOX_API_VERSION < 4000 /* 3001 <= VBOX_API_VERSION < 4000 */
2535
                            PRUnichar *VRDPport = NULL;
2536
                            VRDxServer->vtbl->GetPorts(VRDxServer, &VRDPport);
2537 2538 2539 2540
                            if (VRDPport) {
                                /* even if vbox supports mutilpe ports, single port for now here */
                                def->graphics[def->ngraphics]->data.rdp.port = PRUnicharToInt(VRDPport);
                                VBOX_UTF16_FREE(VRDPport);
2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551
#else /* VBOX_API_VERSION >= 4000 */
                            PRUnichar *VRDEPortsKey = NULL;
                            PRUnichar *VRDEPortsValue = NULL;
                            VBOX_UTF8_TO_UTF16("TCP/Ports", &VRDEPortsKey);
                            VRDxServer->vtbl->GetVRDEProperty(VRDxServer, VRDEPortsKey, &VRDEPortsValue);
                            VBOX_UTF16_FREE(VRDEPortsKey);
                            if (VRDEPortsValue) {
                                /* even if vbox supports mutilpe ports, single port for now here */
                                def->graphics[def->ngraphics]->data.rdp.port = PRUnicharToInt(VRDEPortsValue);
                                VBOX_UTF16_FREE(VRDEPortsValue);
#endif /* VBOX_API_VERSION >= 4000 */
2552 2553 2554
                            } else {
                                def->graphics[def->ngraphics]->data.rdp.autoport = 1;
                            }
2555

2556
                            def->graphics[def->ngraphics]->type = VIR_DOMAIN_GRAPHICS_TYPE_RDP;
2557

2558 2559 2560 2561 2562 2563 2564 2565
#if VBOX_API_VERSION >= 4000
                            PRUnichar *VRDENetAddressKey = NULL;
                            VBOX_UTF8_TO_UTF16("TCP/Address", &VRDENetAddressKey);
                            VRDxServer->vtbl->GetVRDEProperty(VRDxServer, VRDENetAddressKey, &netAddressUtf16);
                            VBOX_UTF16_FREE(VRDENetAddressKey);
#else /* VBOX_API_VERSION < 4000 */
                            VRDxServer->vtbl->GetNetAddress(VRDxServer, &netAddressUtf16);
#endif /* VBOX_API_VERSION < 4000 */
2566 2567 2568
                            if (netAddressUtf16) {
                                VBOX_UTF16_TO_UTF8(netAddressUtf16, &netAddressUtf8);
                                if (STRNEQ(netAddressUtf8, ""))
2569 2570
                                    virDomainGraphicsListenSetAddress(def->graphics[def->ngraphics], 0,
                                                                      netAddressUtf8, -1, true);
2571 2572 2573
                                VBOX_UTF16_FREE(netAddressUtf16);
                                VBOX_UTF8_FREE(netAddressUtf8);
                            }
2574

2575
                            VRDxServer->vtbl->GetAllowMultiConnection(VRDxServer, &allowMultiConnection);
2576 2577 2578
                            if (allowMultiConnection) {
                                def->graphics[def->ngraphics]->data.rdp.multiUser = 1;
                            }
2579

2580
                            VRDxServer->vtbl->GetReuseSingleConnection(VRDxServer, &reuseSingleConnection);
2581 2582 2583
                            if (reuseSingleConnection) {
                                def->graphics[def->ngraphics]->data.rdp.replaceUser = 1;
                            }
2584

2585
                            def->ngraphics++;
2586
                        } else
2587
                            virReportOOMError();
2588
                    }
2589
                    VBOX_RELEASE(VRDxServer);
2590
                }
2591
            }
2592

2593 2594 2595
#if VBOX_API_VERSION < 3001
            /* dump IDE hdds if present */
            VBOX_UTF8_TO_UTF16(hddBus, &hddBusUtf16);
2596

2597 2598 2599 2600
            def->ndisks = 0;
            machine->vtbl->GetHardDisk(machine, hddBusUtf16, 0, 0,  &hardDiskPM);
            if (hardDiskPM)
                def->ndisks++;
2601

2602 2603 2604
            machine->vtbl->GetHardDisk(machine, hddBusUtf16, 0, 1,  &hardDiskPS);
            if (hardDiskPS)
                def->ndisks++;
2605

2606 2607 2608
            machine->vtbl->GetHardDisk(machine, hddBusUtf16, 1, 1,  &hardDiskSS);
            if (hardDiskSS)
                def->ndisks++;
2609

2610 2611 2612 2613 2614 2615 2616 2617 2618
            VBOX_UTF16_FREE(hddBusUtf16);

            if ((def->ndisks > 0) && (VIR_ALLOC_N(def->disks, def->ndisks) >= 0)) {
                for (i = 0; i < def->ndisks; i++) {
                    if (VIR_ALLOC(def->disks[i]) >= 0) {
                        def->disks[i]->device = VIR_DOMAIN_DISK_DEVICE_DISK;
                        def->disks[i]->bus = VIR_DOMAIN_DISK_BUS_IDE;
                        def->disks[i]->type = VIR_DOMAIN_DISK_TYPE_FILE;
                    } else
2619
                        virReportOOMError();
2620
                }
2621
            }
2622

2623 2624 2625 2626
            if (hardDiskPM) {
                PRUnichar *hddlocationUtf16 = NULL;
                char *hddlocation           = NULL;
                PRUint32 hddType            = HardDiskType_Normal;
2627

2628 2629
                hardDiskPM->vtbl->imedium.GetLocation((IMedium *)hardDiskPM, &hddlocationUtf16);
                VBOX_UTF16_TO_UTF8(hddlocationUtf16, &hddlocation);
2630

2631
                hardDiskPM->vtbl->GetType(hardDiskPM, &hddType);
2632

2633 2634 2635 2636 2637
                if (hddType == HardDiskType_Immutable)
                    def->disks[hddNum]->readonly = 1;
                def->disks[hddNum]->src = strdup(hddlocation);
                def->disks[hddNum]->dst = strdup("hda");
                hddNum++;
2638

2639 2640 2641 2642
                VBOX_UTF8_FREE(hddlocation);
                VBOX_UTF16_FREE(hddlocationUtf16);
                VBOX_MEDIUM_RELEASE(hardDiskPM);
            }
2643

2644 2645 2646 2647
            if (hardDiskPS) {
                PRUnichar *hddlocationUtf16 = NULL;
                char *hddlocation           = NULL;
                PRUint32 hddType            = HardDiskType_Normal;
2648

2649 2650
                hardDiskPS->vtbl->imedium.GetLocation((IMedium *)hardDiskPS, &hddlocationUtf16);
                VBOX_UTF16_TO_UTF8(hddlocationUtf16, &hddlocation);
2651

2652
                hardDiskPS->vtbl->GetType(hardDiskPS, &hddType);
2653

2654 2655 2656 2657 2658
                if (hddType == HardDiskType_Immutable)
                    def->disks[hddNum]->readonly = 1;
                def->disks[hddNum]->src = strdup(hddlocation);
                def->disks[hddNum]->dst = strdup("hdb");
                hddNum++;
2659

2660 2661 2662 2663
                VBOX_UTF8_FREE(hddlocation);
                VBOX_UTF16_FREE(hddlocationUtf16);
                VBOX_MEDIUM_RELEASE(hardDiskPS);
            }
2664

2665 2666 2667 2668
            if (hardDiskSS) {
                PRUnichar *hddlocationUtf16 = NULL;
                char *hddlocation           = NULL;
                PRUint32 hddType            = HardDiskType_Normal;
2669

2670 2671
                hardDiskSS->vtbl->imedium.GetLocation((IMedium *)hardDiskSS, &hddlocationUtf16);
                VBOX_UTF16_TO_UTF8(hddlocationUtf16, &hddlocation);
2672

2673
                hardDiskSS->vtbl->GetType(hardDiskSS, &hddType);
2674

2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692
                if (hddType == HardDiskType_Immutable)
                    def->disks[hddNum]->readonly = 1;
                def->disks[hddNum]->src = strdup(hddlocation);
                def->disks[hddNum]->dst = strdup("hdd");
                hddNum++;

                VBOX_UTF8_FREE(hddlocation);
                VBOX_UTF16_FREE(hddlocationUtf16);
                VBOX_MEDIUM_RELEASE(hardDiskSS);
            }
#else  /* VBOX_API_VERSION >= 3001 */
            /* dump IDE hdds if present */

            bool error = false;
            int diskCount = 0;
            PRUint32   maxPortPerInst[StorageBus_Floppy + 1] = {};
            PRUint32   maxSlotPerPort[StorageBus_Floppy + 1] = {};
            def->ndisks = 0;
2693
            vboxArrayGet(&mediumAttachments, machine, machine->vtbl->GetMediumAttachments);
2694 2695

            /* get the number of attachments */
2696 2697
            for (i = 0; i < mediumAttachments.count; i++) {
                IMediumAttachment *imediumattach = mediumAttachments.items[i];
2698 2699 2700 2701 2702 2703 2704
                if (imediumattach) {
                    IMedium *medium = NULL;

                    imediumattach->vtbl->GetMedium(imediumattach, &medium);
                    if (medium) {
                        def->ndisks++;
                        VBOX_RELEASE(medium);
2705 2706
                    }
                }
2707
            }
2708

2709 2710 2711 2712
            /* Allocate mem, if fails return error */
            if (VIR_ALLOC_N(def->disks, def->ndisks) >= 0) {
                for (i = 0; i < def->ndisks; i++) {
                    if (VIR_ALLOC(def->disks[i]) < 0) {
2713
                        virReportOOMError();
2714 2715
                        error = true;
                        break;
2716 2717
                    }
                }
2718
            } else {
2719
                virReportOOMError();
2720 2721 2722 2723 2724 2725 2726
                error = true;
            }

            if (!error)
                error = !vboxGetMaxPortSlotValues(data->vboxObj, maxPortPerInst, maxSlotPerPort);

            /* get the attachment details here */
2727 2728
            for (i = 0; i < mediumAttachments.count && diskCount < def->ndisks && !error; i++) {
                IMediumAttachment *imediumattach = mediumAttachments.items[i];
2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761
                IStorageController *storageController = NULL;
                PRUnichar *storageControllerName = NULL;
                PRUint32   deviceType     = DeviceType_Null;
                PRUint32   storageBus     = StorageBus_Null;
                PRBool     readOnly       = PR_FALSE;
                IMedium   *medium         = NULL;
                PRUnichar *mediumLocUtf16 = NULL;
                char      *mediumLocUtf8  = NULL;
                PRUint32   deviceInst     = 0;
                PRInt32    devicePort     = 0;
                PRInt32    deviceSlot     = 0;

                if (!imediumattach)
                    continue;

                imediumattach->vtbl->GetMedium(imediumattach, &medium);
                if (!medium)
                    continue;

                imediumattach->vtbl->GetController(imediumattach, &storageControllerName);
                if (!storageControllerName) {
                    VBOX_RELEASE(medium);
                    continue;
                }

                machine->vtbl->GetStorageControllerByName(machine,
                                                          storageControllerName,
                                                          &storageController);
                VBOX_UTF16_FREE(storageControllerName);
                if (!storageController) {
                    VBOX_RELEASE(medium);
                    continue;
                }
2762

2763 2764 2765 2766 2767 2768 2769 2770 2771
                medium->vtbl->GetLocation(medium, &mediumLocUtf16);
                VBOX_UTF16_TO_UTF8(mediumLocUtf16, &mediumLocUtf8);
                VBOX_UTF16_FREE(mediumLocUtf16);
                def->disks[diskCount]->src = strdup(mediumLocUtf8);
                VBOX_UTF8_FREE(mediumLocUtf8);

                if (!(def->disks[diskCount]->src)) {
                    VBOX_RELEASE(medium);
                    VBOX_RELEASE(storageController);
2772
                    virReportOOMError();
2773 2774 2775
                    error = true;
                    break;
                }
2776

2777 2778 2779 2780 2781 2782 2783 2784 2785 2786
                storageController->vtbl->GetBus(storageController, &storageBus);
                if (storageBus == StorageBus_IDE) {
                    def->disks[diskCount]->bus = VIR_DOMAIN_DISK_BUS_IDE;
                } else if (storageBus == StorageBus_SATA) {
                    def->disks[diskCount]->bus = VIR_DOMAIN_DISK_BUS_SATA;
                } else if (storageBus == StorageBus_SCSI) {
                    def->disks[diskCount]->bus = VIR_DOMAIN_DISK_BUS_SCSI;
                } else if (storageBus == StorageBus_Floppy) {
                    def->disks[diskCount]->bus = VIR_DOMAIN_DISK_BUS_FDC;
                }
2787

2788 2789 2790 2791 2792 2793 2794 2795 2796 2797
                imediumattach->vtbl->GetType(imediumattach, &deviceType);
                if (deviceType == DeviceType_HardDisk)
                    def->disks[diskCount]->device = VIR_DOMAIN_DISK_DEVICE_DISK;
                else if (deviceType == DeviceType_Floppy)
                    def->disks[diskCount]->device = VIR_DOMAIN_DISK_DEVICE_FLOPPY;
                else if (deviceType == DeviceType_DVD)
                    def->disks[diskCount]->device = VIR_DOMAIN_DISK_DEVICE_CDROM;

                imediumattach->vtbl->GetPort(imediumattach, &devicePort);
                imediumattach->vtbl->GetDevice(imediumattach, &deviceSlot);
2798
                def->disks[diskCount]->dst = vboxGenerateMediumName(storageBus,
2799 2800 2801 2802 2803 2804
                                                                    deviceInst,
                                                                    devicePort,
                                                                    deviceSlot,
                                                                    maxPortPerInst,
                                                                    maxSlotPerPort);
                if (!def->disks[diskCount]->dst) {
2805 2806 2807 2808
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("Could not generate medium name for the disk "
                                     "at: controller instance:%u, port:%d, slot:%d"),
                                   deviceInst, devicePort, deviceSlot);
2809 2810 2811 2812 2813
                    VBOX_RELEASE(medium);
                    VBOX_RELEASE(storageController);
                    error = true;
                    break;
                }
2814

2815 2816 2817
                medium->vtbl->GetReadOnly(medium, &readOnly);
                if (readOnly == PR_TRUE)
                    def->disks[diskCount]->readonly = 1;
2818

2819
                def->disks[diskCount]->type = VIR_DOMAIN_DISK_TYPE_FILE;
2820

2821 2822 2823 2824
                VBOX_RELEASE(medium);
                VBOX_RELEASE(storageController);
                diskCount++;
            }
2825

2826
            vboxArrayRelease(&mediumAttachments);
2827

2828 2829 2830 2831 2832 2833 2834 2835
            /* cleanup on error */
            if (error) {
                for (i = 0; i < def->ndisks; i++) {
                    VIR_FREE(def->disks[i]);
                }
                VIR_FREE(def->disks);
                def->ndisks = 0;
            }
2836

2837
#endif /* VBOX_API_VERSION >= 3001 */
2838

M
Matthias Bolte 已提交
2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899
            /* shared folders */
            vboxArray sharedFolders = VBOX_ARRAY_INITIALIZER;

            def->nfss = 0;

            vboxArrayGet(&sharedFolders, machine,
                         machine->vtbl->GetSharedFolders);

            if (sharedFolders.count > 0) {
                if (VIR_ALLOC_N(def->fss, sharedFolders.count) < 0) {
                    virReportOOMError();
                    goto sharedFoldersCleanup;
                }

                for (i = 0; i < sharedFolders.count; i++) {
                    ISharedFolder *sharedFolder = sharedFolders.items[i];
                    PRUnichar *nameUtf16 = NULL;
                    char *name = NULL;
                    PRUnichar *hostPathUtf16 = NULL;
                    char *hostPath = NULL;
                    PRBool writable = PR_FALSE;

                    if (VIR_ALLOC(def->fss[i]) < 0) {
                        virReportOOMError();
                        goto sharedFoldersCleanup;
                    }

                    def->fss[i]->type = VIR_DOMAIN_FS_TYPE_MOUNT;

                    sharedFolder->vtbl->GetHostPath(sharedFolder, &hostPathUtf16);
                    VBOX_UTF16_TO_UTF8(hostPathUtf16, &hostPath);
                    def->fss[i]->src = strdup(hostPath);
                    VBOX_UTF8_FREE(hostPath);
                    VBOX_UTF16_FREE(hostPathUtf16);

                    if (def->fss[i]->src == NULL) {
                        virReportOOMError();
                        goto sharedFoldersCleanup;
                    }

                    sharedFolder->vtbl->GetName(sharedFolder, &nameUtf16);
                    VBOX_UTF16_TO_UTF8(nameUtf16, &name);
                    def->fss[i]->dst = strdup(name);
                    VBOX_UTF8_FREE(name);
                    VBOX_UTF16_FREE(nameUtf16);

                    if (def->fss[i]->dst == NULL) {
                        virReportOOMError();
                        goto sharedFoldersCleanup;
                    }

                    sharedFolder->vtbl->GetWritable(sharedFolder, &writable);
                    def->fss[i]->readonly = !writable;

                    ++def->nfss;
                }
            }

sharedFoldersCleanup:
            vboxArrayRelease(&sharedFolders);

2900 2901 2902 2903 2904
            /* dump network cards if present */
            def->nnets = 0;
            /* Get which network cards are enabled */
            for (i = 0; i < netAdpCnt; i++) {
                INetworkAdapter *adapter = NULL;
2905

2906 2907 2908
                machine->vtbl->GetNetworkAdapter(machine, i, &adapter);
                if (adapter) {
                    PRBool enabled = PR_FALSE;
2909

2910 2911 2912 2913
                    adapter->vtbl->GetEnabled(adapter, &enabled);
                    if (enabled) {
                        def->nnets++;
                    }
2914

2915 2916 2917
                    VBOX_RELEASE(adapter);
                }
            }
2918

2919 2920 2921 2922 2923
            /* Allocate memory for the networkcards which are enabled */
            if ((def->nnets > 0) && (VIR_ALLOC_N(def->nets, def->nnets) >= 0)) {
                for (i = 0; i < def->nnets; i++) {
                    if (VIR_ALLOC(def->nets[i]) >= 0) {
                    } else
2924
                        virReportOOMError();
2925 2926
                }
            }
2927

2928 2929 2930
            /* Now get the details about the network cards here */
            for (i = 0;(netAdpIncCnt < def->nnets) && (i < netAdpCnt); i++) {
                INetworkAdapter *adapter = NULL;
2931

2932 2933 2934
                machine->vtbl->GetNetworkAdapter(machine, i, &adapter);
                if (adapter) {
                    PRBool enabled = PR_FALSE;
2935

2936 2937 2938 2939 2940 2941 2942
                    adapter->vtbl->GetEnabled(adapter, &enabled);
                    if (enabled) {
                        PRUint32 attachmentType    = NetworkAttachmentType_Null;
                        PRUint32 adapterType       = NetworkAdapterType_Null;
                        PRUnichar *MACAddressUtf16 = NULL;
                        char *MACAddress           = NULL;
                        char macaddr[VIR_MAC_STRING_BUFLEN] = {0};
2943

2944 2945
                        adapter->vtbl->GetAttachmentType(adapter, &attachmentType);
                        if (attachmentType == NetworkAttachmentType_NAT) {
2946

2947
                            def->nets[netAdpIncCnt]->type = VIR_DOMAIN_NET_TYPE_USER;
2948

2949 2950 2951
                        } else if (attachmentType == NetworkAttachmentType_Bridged) {
                            PRUnichar *hostIntUtf16 = NULL;
                            char *hostInt           = NULL;
2952

2953
                            def->nets[netAdpIncCnt]->type = VIR_DOMAIN_NET_TYPE_BRIDGE;
2954

2955
#if VBOX_API_VERSION < 4001
2956
                            adapter->vtbl->GetHostInterface(adapter, &hostIntUtf16);
2957 2958 2959
#else /* VBOX_API_VERSION >= 4001 */
                            adapter->vtbl->GetBridgedInterface(adapter, &hostIntUtf16);
#endif /* VBOX_API_VERSION >= 4001 */
2960

2961 2962
                            VBOX_UTF16_TO_UTF8(hostIntUtf16, &hostInt);
                            def->nets[netAdpIncCnt]->data.bridge.brname = strdup(hostInt);
2963

2964 2965
                            VBOX_UTF8_FREE(hostInt);
                            VBOX_UTF16_FREE(hostIntUtf16);
2966

2967 2968 2969
                        } else if (attachmentType == NetworkAttachmentType_Internal) {
                            PRUnichar *intNetUtf16 = NULL;
                            char *intNet           = NULL;
2970

2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986
                            def->nets[netAdpIncCnt]->type = VIR_DOMAIN_NET_TYPE_INTERNAL;

                            adapter->vtbl->GetInternalNetwork(adapter, &intNetUtf16);

                            VBOX_UTF16_TO_UTF8(intNetUtf16, &intNet);
                            def->nets[netAdpIncCnt]->data.internal.name = strdup(intNet);

                            VBOX_UTF8_FREE(intNet);
                            VBOX_UTF16_FREE(intNetUtf16);

                        } else if (attachmentType == NetworkAttachmentType_HostOnly) {
                            PRUnichar *hostIntUtf16 = NULL;
                            char *hostInt           = NULL;

                            def->nets[netAdpIncCnt]->type = VIR_DOMAIN_NET_TYPE_NETWORK;

2987
#if VBOX_API_VERSION < 4001
2988
                            adapter->vtbl->GetHostInterface(adapter, &hostIntUtf16);
2989 2990 2991
#else /* VBOX_API_VERSION >= 4001 */
                            adapter->vtbl->GetHostOnlyInterface(adapter, &hostIntUtf16);
#endif /* VBOX_API_VERSION >= 4001 */
2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020

                            VBOX_UTF16_TO_UTF8(hostIntUtf16, &hostInt);
                            def->nets[netAdpIncCnt]->data.network.name = strdup(hostInt);

                            VBOX_UTF8_FREE(hostInt);
                            VBOX_UTF16_FREE(hostIntUtf16);

                        } else {
                            /* default to user type i.e. NAT in VirtualBox if this
                             * dump is ever used to create a machine.
                             */
                            def->nets[netAdpIncCnt]->type = VIR_DOMAIN_NET_TYPE_USER;
                        }

                        adapter->vtbl->GetAdapterType(adapter, &adapterType);
                        if (adapterType == NetworkAdapterType_Am79C970A) {
                            def->nets[netAdpIncCnt]->model = strdup("Am79C970A");
                        } else if (adapterType == NetworkAdapterType_Am79C973) {
                            def->nets[netAdpIncCnt]->model = strdup("Am79C973");
                        } else if (adapterType == NetworkAdapterType_I82540EM) {
                            def->nets[netAdpIncCnt]->model = strdup("82540EM");
                        } else if (adapterType == NetworkAdapterType_I82545EM) {
                            def->nets[netAdpIncCnt]->model = strdup("82545EM");
                        } else if (adapterType == NetworkAdapterType_I82543GC) {
                            def->nets[netAdpIncCnt]->model = strdup("82543GC");
#if VBOX_API_VERSION >= 3001
                        } else if (adapterType == NetworkAdapterType_Virtio) {
                            def->nets[netAdpIncCnt]->model = strdup("virtio");
#endif /* VBOX_API_VERSION >= 3001 */
3021 3022
                        }

3023 3024 3025 3026 3027 3028 3029 3030 3031
                        adapter->vtbl->GetMACAddress(adapter, &MACAddressUtf16);
                        VBOX_UTF16_TO_UTF8(MACAddressUtf16, &MACAddress);
                        snprintf(macaddr, VIR_MAC_STRING_BUFLEN,
                                 "%c%c:%c%c:%c%c:%c%c:%c%c:%c%c",
                                 MACAddress[0], MACAddress[1], MACAddress[2], MACAddress[3],
                                 MACAddress[4], MACAddress[5], MACAddress[6], MACAddress[7],
                                 MACAddress[8], MACAddress[9], MACAddress[10], MACAddress[11]);

                        /* XXX some real error handling here some day ... */
3032
                        if (virMacAddrParse(macaddr, &def->nets[netAdpIncCnt]->mac) < 0)
3033 3034 3035 3036 3037 3038
                        {}

                        netAdpIncCnt++;

                        VBOX_UTF16_FREE(MACAddressUtf16);
                        VBOX_UTF8_FREE(MACAddress);
3039
                    }
3040 3041

                    VBOX_RELEASE(adapter);
3042
                }
3043
            }
3044

3045
            /* dump sound card if active */
3046

3047 3048 3049
            /* Set def->nsounds to one as VirtualBox currently supports
             * only one sound card
             */
3050

3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070
            machine->vtbl->GetAudioAdapter(machine, &audioAdapter);
            if (audioAdapter) {
                PRBool enabled = PR_FALSE;

                audioAdapter->vtbl->GetEnabled(audioAdapter, &enabled);
                if (enabled) {
                    PRUint32 audioController = AudioControllerType_AC97;

                    def->nsounds = 1;
                    if (VIR_ALLOC_N(def->sounds, def->nsounds) >= 0) {
                        if (VIR_ALLOC(def->sounds[0]) >= 0) {
                            audioAdapter->vtbl->GetAudioController(audioAdapter, &audioController);
                            if (audioController == AudioControllerType_SB16) {
                                def->sounds[0]->model = VIR_DOMAIN_SOUND_MODEL_SB16;
                            } else if (audioController == AudioControllerType_AC97) {
                                def->sounds[0]->model = VIR_DOMAIN_SOUND_MODEL_AC97;
                            }
                        } else {
                            VIR_FREE(def->sounds);
                            def->nsounds = 0;
3071
                            virReportOOMError();
3072 3073 3074
                        }
                    } else {
                        def->nsounds = 0;
3075
                        virReportOOMError();
3076 3077 3078 3079
                    }
                }
                VBOX_RELEASE(audioAdapter);
            }
3080

3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107
#if VBOX_API_VERSION < 3001
            /* dump CDROM/DVD if the drive is attached and has DVD/CD in it */
            machine->vtbl->GetDVDDrive(machine, &dvdDrive);
            if (dvdDrive) {
                PRUint32 state = DriveState_Null;

                dvdDrive->vtbl->GetState(dvdDrive, &state);
                if (state == DriveState_ImageMounted) {
                    IDVDImage *dvdImage = NULL;

                    dvdDrive->vtbl->GetImage(dvdDrive, &dvdImage);
                    if (dvdImage) {
                        PRUnichar *locationUtf16 = NULL;
                        char *location           = NULL;

                        dvdImage->vtbl->imedium.GetLocation((IMedium *)dvdImage, &locationUtf16);
                        VBOX_UTF16_TO_UTF8(locationUtf16, &location);

                        def->ndisks++;
                        if (VIR_REALLOC_N(def->disks, def->ndisks) >= 0) {
                            if (VIR_ALLOC(def->disks[def->ndisks - 1]) >= 0) {
                                def->disks[def->ndisks - 1]->device = VIR_DOMAIN_DISK_DEVICE_CDROM;
                                def->disks[def->ndisks - 1]->bus = VIR_DOMAIN_DISK_BUS_IDE;
                                def->disks[def->ndisks - 1]->type = VIR_DOMAIN_DISK_TYPE_FILE;
                                def->disks[def->ndisks - 1]->readonly = 1;
                                def->disks[def->ndisks - 1]->src = strdup(location);
                                def->disks[def->ndisks - 1]->dst = strdup("hdc");
3108
                            } else {
3109
                                def->ndisks--;
3110
                                virReportOOMError();
3111 3112
                            }
                        } else {
3113
                            def->ndisks--;
3114
                            virReportOOMError();
3115
                        }
3116 3117 3118 3119

                        VBOX_UTF8_FREE(location);
                        VBOX_UTF16_FREE(locationUtf16);
                        VBOX_MEDIUM_RELEASE(dvdImage);
3120 3121
                    }
                }
3122 3123
                VBOX_RELEASE(dvdDrive);
            }
3124

3125 3126 3127 3128 3129 3130 3131
            /* dump Floppy if the drive is attached and has floppy in it */
            machine->vtbl->GetFloppyDrive(machine, &floppyDrive);
            if (floppyDrive) {
                PRBool enabled = PR_FALSE;

                floppyDrive->vtbl->GetEnabled(floppyDrive, &enabled);
                if (enabled) {
3132 3133
                    PRUint32 state = DriveState_Null;

3134
                    floppyDrive->vtbl->GetState(floppyDrive, &state);
3135
                    if (state == DriveState_ImageMounted) {
3136
                        IFloppyImage *floppyImage = NULL;
3137

3138 3139
                        floppyDrive->vtbl->GetImage(floppyDrive, &floppyImage);
                        if (floppyImage) {
3140 3141 3142
                            PRUnichar *locationUtf16 = NULL;
                            char *location           = NULL;

3143 3144
                            floppyImage->vtbl->imedium.GetLocation((IMedium *)floppyImage, &locationUtf16);
                            VBOX_UTF16_TO_UTF8(locationUtf16, &location);
3145 3146 3147 3148

                            def->ndisks++;
                            if (VIR_REALLOC_N(def->disks, def->ndisks) >= 0) {
                                if (VIR_ALLOC(def->disks[def->ndisks - 1]) >= 0) {
3149 3150
                                    def->disks[def->ndisks - 1]->device = VIR_DOMAIN_DISK_DEVICE_FLOPPY;
                                    def->disks[def->ndisks - 1]->bus = VIR_DOMAIN_DISK_BUS_FDC;
3151
                                    def->disks[def->ndisks - 1]->type = VIR_DOMAIN_DISK_TYPE_FILE;
3152
                                    def->disks[def->ndisks - 1]->readonly = 0;
3153
                                    def->disks[def->ndisks - 1]->src = strdup(location);
3154
                                    def->disks[def->ndisks - 1]->dst = strdup("fda");
3155 3156
                                } else {
                                    def->ndisks--;
3157
                                    virReportOOMError();
3158 3159 3160
                                }
                            } else {
                                def->ndisks--;
3161
                                virReportOOMError();
3162 3163
                            }

3164 3165 3166
                            VBOX_UTF8_FREE(location);
                            VBOX_UTF16_FREE(locationUtf16);
                            VBOX_MEDIUM_RELEASE(floppyImage);
3167 3168 3169 3170
                        }
                    }
                }

3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183
                VBOX_RELEASE(floppyDrive);
            }
#else  /* VBOX_API_VERSION >= 3001 */
#endif /* VBOX_API_VERSION >= 3001 */

            /* dump serial port if active */
            def->nserials = 0;
            /* Get which serial ports are enabled/active */
            for (i = 0; i < serialPortCount; i++) {
                ISerialPort *serialPort = NULL;

                machine->vtbl->GetSerialPort(machine, i, &serialPort);
                if (serialPort) {
3184 3185
                    PRBool enabled = PR_FALSE;

3186
                    serialPort->vtbl->GetEnabled(serialPort, &enabled);
3187
                    if (enabled) {
3188
                        def->nserials++;
3189 3190
                    }

3191
                    VBOX_RELEASE(serialPort);
3192
                }
3193
            }
3194

3195 3196 3197 3198 3199
            /* Allocate memory for the serial ports which are enabled */
            if ((def->nserials > 0) && (VIR_ALLOC_N(def->serials, def->nserials) >= 0)) {
                for (i = 0; i < def->nserials; i++) {
                    if (VIR_ALLOC(def->serials[i]) >= 0) {
                    } else
3200
                        virReportOOMError();
3201 3202
                }
            }
3203

3204 3205 3206
            /* Now get the details about the serial ports here */
            for (i = 0;(serialPortIncCount < def->nserials) && (i < serialPortCount); i++) {
                ISerialPort *serialPort = NULL;
3207

3208 3209 3210
                machine->vtbl->GetSerialPort(machine, i, &serialPort);
                if (serialPort) {
                    PRBool enabled = PR_FALSE;
3211

3212 3213 3214 3215 3216 3217 3218 3219 3220 3221
                    serialPort->vtbl->GetEnabled(serialPort, &enabled);
                    if (enabled) {
                        PRUint32 hostMode    = PortMode_Disconnected;
                        PRUint32 IOBase      = 0;
                        PRUint32 IRQ         = 0;
                        PRUnichar *pathUtf16 = NULL;
                        char *path           = NULL;

                        serialPort->vtbl->GetHostMode(serialPort, &hostMode);
                        if (hostMode == PortMode_HostPipe) {
3222
                            def->serials[serialPortIncCount]->source.type = VIR_DOMAIN_CHR_TYPE_PIPE;
3223
                        } else if (hostMode == PortMode_HostDevice) {
3224
                            def->serials[serialPortIncCount]->source.type = VIR_DOMAIN_CHR_TYPE_DEV;
3225 3226
#if VBOX_API_VERSION >= 3000
                        } else if (hostMode == PortMode_RawFile) {
3227
                            def->serials[serialPortIncCount]->source.type = VIR_DOMAIN_CHR_TYPE_FILE;
3228 3229
#endif /* VBOX_API_VERSION >= 3000 */
                        } else {
3230
                            def->serials[serialPortIncCount]->source.type = VIR_DOMAIN_CHR_TYPE_NULL;
3231
                        }
3232

3233
                        def->serials[serialPortIncCount]->deviceType = VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL;
3234

3235 3236 3237 3238 3239 3240 3241
                        serialPort->vtbl->GetIRQ(serialPort, &IRQ);
                        serialPort->vtbl->GetIOBase(serialPort, &IOBase);
                        if ((IRQ == 4) && (IOBase == 1016)) {
                            def->serials[serialPortIncCount]->target.port = 0;
                        } else if ((IRQ == 3) && (IOBase == 760)) {
                            def->serials[serialPortIncCount]->target.port = 1;
                        }
3242

3243
                        serialPort->vtbl->GetPath(serialPort, &pathUtf16);
3244

3245 3246
                        if (pathUtf16) {
                            VBOX_UTF16_TO_UTF8(pathUtf16, &path);
3247
                            def->serials[serialPortIncCount]->source.data.file.path = strdup(path);
3248 3249
                        }

3250 3251 3252 3253
                        serialPortIncCount++;

                        VBOX_UTF16_FREE(pathUtf16);
                        VBOX_UTF8_FREE(path);
3254 3255
                    }

3256 3257 3258
                    VBOX_RELEASE(serialPort);
                }
            }
3259

3260 3261 3262 3263 3264
            /* dump parallel ports if active */
            def->nparallels = 0;
            /* Get which parallel ports are enabled/active */
            for (i = 0; i < parallelPortCount; i++) {
                IParallelPort *parallelPort = NULL;
3265

3266 3267 3268
                machine->vtbl->GetParallelPort(machine, i, &parallelPort);
                if (parallelPort) {
                    PRBool enabled = PR_FALSE;
3269

3270 3271 3272
                    parallelPort->vtbl->GetEnabled(parallelPort, &enabled);
                    if (enabled) {
                        def->nparallels++;
3273
                    }
3274 3275

                    VBOX_RELEASE(parallelPort);
3276
                }
3277
            }
3278

3279 3280 3281 3282 3283
            /* Allocate memory for the parallel ports which are enabled */
            if ((def->nparallels > 0) && (VIR_ALLOC_N(def->parallels, def->nparallels) >= 0)) {
                for (i = 0; i < def->nparallels; i++) {
                    if (VIR_ALLOC(def->parallels[i]) >= 0) {
                    } else
3284
                        virReportOOMError();
3285
                }
3286
            }
3287

3288 3289 3290
            /* Now get the details about the parallel ports here */
            for (i = 0;(parallelPortIncCount < def->nparallels) && (i < parallelPortCount); i++) {
                IParallelPort *parallelPort = NULL;
3291

3292 3293 3294
                machine->vtbl->GetParallelPort(machine, i, &parallelPort);
                if (parallelPort) {
                    PRBool enabled = PR_FALSE;
3295

3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309
                    parallelPort->vtbl->GetEnabled(parallelPort, &enabled);
                    if (enabled) {
                        PRUint32 IOBase      = 0;
                        PRUint32 IRQ         = 0;
                        PRUnichar *pathUtf16 = NULL;
                        char *path           = NULL;

                        parallelPort->vtbl->GetIRQ(parallelPort, &IRQ);
                        parallelPort->vtbl->GetIOBase(parallelPort, &IOBase);
                        if ((IRQ == 7) && (IOBase == 888)) {
                            def->parallels[parallelPortIncCount]->target.port = 0;
                        } else if ((IRQ == 5) && (IOBase == 632)) {
                            def->parallels[parallelPortIncCount]->target.port = 1;
                        }
3310

3311
                        def->parallels[parallelPortIncCount]->source.type = VIR_DOMAIN_CHR_TYPE_FILE;
3312
                        def->parallels[parallelPortIncCount]->deviceType = VIR_DOMAIN_CHR_DEVICE_TYPE_PARALLEL;
3313

3314
                        parallelPort->vtbl->GetPath(parallelPort, &pathUtf16);
3315

3316
                        VBOX_UTF16_TO_UTF8(pathUtf16, &path);
3317
                        def->parallels[parallelPortIncCount]->source.data.file.path = strdup(path);
3318

3319 3320 3321 3322
                        parallelPortIncCount++;

                        VBOX_UTF16_FREE(pathUtf16);
                        VBOX_UTF8_FREE(path);
3323
                    }
3324 3325

                    VBOX_RELEASE(parallelPort);
3326
                }
3327
            }
3328

3329 3330 3331 3332 3333
            /* dump USB devices/filters if active */
            def->nhostdevs = 0;
            machine->vtbl->GetUSBController(machine, &USBController);
            if (USBController) {
                PRBool enabled = PR_FALSE;
3334

3335 3336
                USBController->vtbl->GetEnabled(USBController, &enabled);
                if (enabled) {
3337
                    vboxArray deviceFilters = VBOX_ARRAY_INITIALIZER;
3338

3339 3340
                    vboxArrayGet(&deviceFilters, USBController,
                                 USBController->vtbl->GetDeviceFilters);
3341

3342
                    if (deviceFilters.count > 0) {
3343

3344 3345 3346
                        /* check if the filters are active and then only
                         * alloc mem and set def->nhostdevs
                         */
3347

3348
                        for (i = 0; i < deviceFilters.count; i++) {
3349
                            PRBool active = PR_FALSE;
3350
                            IUSBDeviceFilter *deviceFilter = deviceFilters.items[i];
3351

3352
                            deviceFilter->vtbl->GetActive(deviceFilter, &active);
3353 3354
                            if (active) {
                                def->nhostdevs++;
3355
                            }
3356
                        }
3357

3358 3359 3360
                        if (def->nhostdevs > 0) {
                            /* Alloc mem needed for the filters now */
                            if (VIR_ALLOC_N(def->hostdevs, def->nhostdevs) >= 0) {
3361

3362
                                for (i = 0; (USBFilterCount < def->nhostdevs) || (i < deviceFilters.count); i++) {
3363
                                    PRBool active = PR_FALSE;
3364
                                    IUSBDeviceFilter *deviceFilter = deviceFilters.items[i];
3365

3366
                                    deviceFilter->vtbl->GetActive(deviceFilter, &active);
3367 3368 3369 3370 3371 3372 3373 3374 3375
                                    if (active) {
                                        if (VIR_ALLOC(def->hostdevs[USBFilterCount]) >= 0) {
                                            PRUnichar *vendorIdUtf16  = NULL;
                                            char *vendorIdUtf8        = NULL;
                                            unsigned vendorId         = 0;
                                            PRUnichar *productIdUtf16 = NULL;
                                            char *productIdUtf8       = NULL;
                                            unsigned productId        = 0;
                                            char *endptr              = NULL;
3376

3377 3378 3379 3380
                                            def->hostdevs[USBFilterCount]->mode =
                                                VIR_DOMAIN_HOSTDEV_MODE_SUBSYS;
                                            def->hostdevs[USBFilterCount]->source.subsys.type =
                                                VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB;
3381

3382 3383
                                            deviceFilter->vtbl->GetVendorId(deviceFilter, &vendorIdUtf16);
                                            deviceFilter->vtbl->GetProductId(deviceFilter, &productIdUtf16);
3384

3385 3386
                                            VBOX_UTF16_TO_UTF8(vendorIdUtf16, &vendorIdUtf8);
                                            VBOX_UTF16_TO_UTF8(productIdUtf16, &productIdUtf8);
3387

3388 3389
                                            vendorId  = strtol(vendorIdUtf8, &endptr, 16);
                                            productId = strtol(productIdUtf8, &endptr, 16);
3390

3391 3392
                                            def->hostdevs[USBFilterCount]->source.subsys.u.usb.vendor  = vendorId;
                                            def->hostdevs[USBFilterCount]->source.subsys.u.usb.product = productId;
3393

3394 3395
                                            VBOX_UTF16_FREE(vendorIdUtf16);
                                            VBOX_UTF8_FREE(vendorIdUtf8);
3396

3397 3398
                                            VBOX_UTF16_FREE(productIdUtf16);
                                            VBOX_UTF8_FREE(productIdUtf8);
3399

3400 3401
                                            USBFilterCount++;
                                        } else
3402
                                            virReportOOMError();
3403
                                    }
3404 3405
                                }
                            } else
3406
                                virReportOOMError();
3407 3408 3409
                        }
                    }

3410
                    /* Cleanup */
3411
                    vboxArrayRelease(&deviceFilters);
3412 3413
                }
                VBOX_RELEASE(USBController);
3414
            }
3415 3416 3417 3418 3419

            /* all done so set gotAllABoutDef and pass def to virDomainDefFormat
             * to generate XML for it
             */
            gotAllABoutDef = 0;
3420
        }
3421 3422
        VBOX_RELEASE(machine);
        machine = NULL;
3423 3424 3425
    }

    if (gotAllABoutDef == 0)
3426
        ret = virDomainDefFormat(def, flags);
3427 3428

cleanup:
3429
    vboxIIDUnalloc(&iid);
3430 3431 3432 3433 3434
    virDomainDefFree(def);
    return ret;
}

static int vboxListDefinedDomains(virConnectPtr conn, char ** const names, int maxnames) {
3435
    VBOX_OBJECT_CHECK(conn, int, -1);
3436
    vboxArray machines = VBOX_ARRAY_INITIALIZER;
3437 3438 3439
    char *machineName    = NULL;
    PRUnichar *machineNameUtf16 = NULL;
    PRUint32 state;
3440
    nsresult rc;
3441 3442
    int i, j;

3443
    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
3444
    if (NS_FAILED(rc)) {
3445 3446 3447
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Could not get list of Defined Domains, rc=%08x"),
                       (unsigned)rc);
3448 3449
        goto cleanup;
    }
3450

3451 3452 3453
    ret = 0;
    for (i = 0, j = 0; (i < machines.count) && (j < maxnames); i++) {
        IMachine *machine = machines.items[i];
3454 3455 3456 3457 3458 3459

        if (machine) {
            PRBool isAccessible = PR_FALSE;
            machine->vtbl->GetAccessible(machine, &isAccessible);
            if (isAccessible) {
                machine->vtbl->GetState(machine, &state);
3460 3461
                if ((state < MachineState_FirstOnline) ||
                    (state > MachineState_LastOnline)) {
3462 3463
                    machine->vtbl->GetName(machine, &machineNameUtf16);
                    VBOX_UTF16_TO_UTF8(machineNameUtf16, &machineName);
3464 3465 3466 3467
                    names[j] = strdup(machineName);
                    VBOX_UTF16_FREE(machineNameUtf16);
                    VBOX_UTF8_FREE(machineName);
                    if (!names[j]) {
3468
                        virReportOOMError();
3469
                        for (; j >= 0 ; j--)
3470 3471 3472
                            VIR_FREE(names[j]);
                        ret = -1;
                        goto cleanup;
3473
                    }
3474
                    j++;
3475
                    ret++;
3476 3477 3478 3479 3480 3481
                }
            }
        }
    }

cleanup:
3482
    vboxArrayRelease(&machines);
3483 3484 3485 3486
    return ret;
}

static int vboxNumOfDefinedDomains(virConnectPtr conn) {
3487
    VBOX_OBJECT_CHECK(conn, int, -1);
3488
    vboxArray machines = VBOX_ARRAY_INITIALIZER;
3489
    PRUint32 state       = MachineState_Null;
3490
    nsresult rc;
3491 3492
    int i;

3493
    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
3494
    if (NS_FAILED(rc)) {
3495 3496 3497
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Could not get number of Defined Domains, rc=%08x"),
                       (unsigned)rc);
3498 3499
        goto cleanup;
    }
3500

3501 3502 3503
    ret = 0;
    for (i = 0; i < machines.count; ++i) {
        IMachine *machine = machines.items[i];
3504 3505 3506 3507 3508 3509

        if (machine) {
            PRBool isAccessible = PR_FALSE;
            machine->vtbl->GetAccessible(machine, &isAccessible);
            if (isAccessible) {
                machine->vtbl->GetState(machine, &state);
3510 3511
                if ((state < MachineState_FirstOnline) ||
                    (state > MachineState_LastOnline)) {
3512
                    ret++;
3513 3514 3515 3516 3517 3518
                }
            }
        }
    }

cleanup:
3519
    vboxArrayRelease(&machines);
3520 3521 3522
    return ret;
}

E
Eric Blake 已提交
3523 3524

static int
3525 3526
vboxStartMachine(virDomainPtr dom, int i, IMachine *machine,
                 vboxIID *iid ATTRIBUTE_UNUSED /* >= 4.0 */)
E
Eric Blake 已提交
3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552
{
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
    int vrdpPresent              = 0;
    int sdlPresent               = 0;
    int guiPresent               = 0;
    char *guiDisplay             = NULL;
    char *sdlDisplay             = NULL;
    PRUnichar *keyTypeUtf16      = NULL;
    PRUnichar *valueTypeUtf16    = NULL;
    char      *valueTypeUtf8     = NULL;
    PRUnichar *keyDislpayUtf16   = NULL;
    PRUnichar *valueDisplayUtf16 = NULL;
    char      *valueDisplayUtf8  = NULL;
    IProgress *progress          = NULL;
    PRUnichar *env               = NULL;
    PRUnichar *sessionType       = NULL;
    nsresult rc;

    VBOX_UTF8_TO_UTF16("FRONTEND/Type", &keyTypeUtf16);
    machine->vtbl->GetExtraData(machine, keyTypeUtf16, &valueTypeUtf16);
    VBOX_UTF16_FREE(keyTypeUtf16);

    if (valueTypeUtf16) {
        VBOX_UTF16_TO_UTF8(valueTypeUtf16, &valueTypeUtf8);
        VBOX_UTF16_FREE(valueTypeUtf16);

3553
        if (STREQ(valueTypeUtf8, "sdl") || STREQ(valueTypeUtf8, "gui")) {
E
Eric Blake 已提交
3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619

            VBOX_UTF8_TO_UTF16("FRONTEND/Display", &keyDislpayUtf16);
            machine->vtbl->GetExtraData(machine, keyDislpayUtf16,
                                        &valueDisplayUtf16);
            VBOX_UTF16_FREE(keyDislpayUtf16);

            if (valueDisplayUtf16) {
                VBOX_UTF16_TO_UTF8(valueDisplayUtf16, &valueDisplayUtf8);
                VBOX_UTF16_FREE(valueDisplayUtf16);

                if (strlen(valueDisplayUtf8) <= 0) {
                    VBOX_UTF8_FREE(valueDisplayUtf8);
                    valueDisplayUtf8 = NULL;
                }
            }

            if (STREQ(valueTypeUtf8, "sdl")) {
                sdlPresent = 1;
                if (valueDisplayUtf8) {
                    sdlDisplay = strdup(valueDisplayUtf8);
                    if (sdlDisplay == NULL) {
                        virReportOOMError();
                        /* just don't go to cleanup yet as it is ok to have
                         * sdlDisplay as NULL and we check it below if it
                         * exist and then only use it there
                         */
                    }
                }
            }

            if (STREQ(valueTypeUtf8, "gui")) {
                guiPresent = 1;
                if (valueDisplayUtf8) {
                    guiDisplay = strdup(valueDisplayUtf8);
                    if (guiDisplay == NULL) {
                        virReportOOMError();
                        /* just don't go to cleanup yet as it is ok to have
                         * guiDisplay as NULL and we check it below if it
                         * exist and then only use it there
                         */
                    }
                }
            }
        }

        if (STREQ(valueTypeUtf8, "vrdp")) {
            vrdpPresent = 1;
        }

        if (!vrdpPresent && !sdlPresent && !guiPresent) {
            /* if nothing is selected it means either the machine xml
             * file is really old or some values are missing so fallback
             */
            guiPresent = 1;
        }

        VBOX_UTF8_FREE(valueTypeUtf8);

    } else {
        guiPresent = 1;
    }
    if (valueDisplayUtf8)
        VBOX_UTF8_FREE(valueDisplayUtf8);

    if (guiPresent) {
        if (guiDisplay) {
E
Eric Blake 已提交
3620 3621 3622 3623 3624 3625 3626
            char *displayutf8;
            if (virAsprintf(&displayutf8, "DISPLAY=%s", guiDisplay) < 0)
                virReportOOMError();
            else {
                VBOX_UTF8_TO_UTF16(displayutf8, &env);
                VIR_FREE(displayutf8);
            }
E
Eric Blake 已提交
3627 3628 3629 3630 3631 3632 3633 3634
            VIR_FREE(guiDisplay);
        }

        VBOX_UTF8_TO_UTF16("gui", &sessionType);
    }

    if (sdlPresent) {
        if (sdlDisplay) {
E
Eric Blake 已提交
3635 3636 3637 3638 3639 3640 3641
            char *displayutf8;
            if (virAsprintf(&displayutf8, "DISPLAY=%s", sdlDisplay) < 0)
                virReportOOMError();
            else {
                VBOX_UTF8_TO_UTF16(displayutf8, &env);
                VIR_FREE(displayutf8);
            }
E
Eric Blake 已提交
3642 3643 3644 3645 3646 3647 3648 3649 3650 3651
            VIR_FREE(sdlDisplay);
        }

        VBOX_UTF8_TO_UTF16("sdl", &sessionType);
    }

    if (vrdpPresent) {
        VBOX_UTF8_TO_UTF16("vrdp", &sessionType);
    }

3652
#if VBOX_API_VERSION < 4000
E
Eric Blake 已提交
3653 3654
    rc = data->vboxObj->vtbl->OpenRemoteSession(data->vboxObj,
                                                data->vboxSession,
3655
                                                iid->value,
E
Eric Blake 已提交
3656 3657
                                                sessionType,
                                                env,
3658
                                                &progress);
3659 3660 3661 3662 3663
#else /* VBOX_API_VERSION >= 4000 */
    rc = machine->vtbl->LaunchVMProcess(machine, data->vboxSession,
                                        sessionType, env, &progress);
#endif /* VBOX_API_VERSION >= 4000 */

E
Eric Blake 已提交
3664
    if (NS_FAILED(rc)) {
3665 3666
        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                       _("OpenRemoteSession/LaunchVMProcess failed, domain can't be started"));
E
Eric Blake 已提交
3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693
        ret = -1;
    } else {
        PRBool completed = 0;
#if VBOX_API_VERSION == 2002
        nsresult resultCode;
#else
        PRInt32  resultCode;
#endif
        progress->vtbl->WaitForCompletion(progress, -1);
        rc = progress->vtbl->GetCompleted(progress, &completed);
        if (NS_FAILED(rc)) {
            /* error */
            ret = -1;
        }
        progress->vtbl->GetResultCode(progress, &resultCode);
        if (NS_FAILED(resultCode)) {
            /* error */
            ret = -1;
        } else {
            /* all ok set the domid */
            dom->id = i + 1;
            ret = 0;
        }
    }

    VBOX_RELEASE(progress);

3694
    VBOX_SESSION_CLOSE();
E
Eric Blake 已提交
3695 3696 3697 3698 3699 3700 3701

    VBOX_UTF16_FREE(env);
    VBOX_UTF16_FREE(sessionType);

    return ret;
}

3702
static int vboxDomainCreateWithFlags(virDomainPtr dom, unsigned int flags) {
3703
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
3704
    vboxArray machines = VBOX_ARRAY_INITIALIZER;
3705
    unsigned char uuid[VIR_UUID_BUFLEN] = {0};
3706 3707
    nsresult rc;
    int i = 0;
3708

3709 3710
    virCheckFlags(0, -1);

3711
    if (!dom->name) {
3712 3713
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("Error while reading the domain name"));
3714 3715 3716
        goto cleanup;
    }

3717
    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
3718
    if (NS_FAILED(rc)) {
3719 3720
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Could not get list of machines, rc=%08x"), (unsigned)rc);
3721 3722
        goto cleanup;
    }
3723

3724 3725
    for (i = 0; i < machines.count; ++i) {
        IMachine *machine = machines.items[i];
3726
        PRBool isAccessible = PR_FALSE;
3727

3728 3729
        if (!machine)
            continue;
3730

3731 3732
        machine->vtbl->GetAccessible(machine, &isAccessible);
        if (isAccessible) {
3733
            vboxIID iid = VBOX_IID_INITIALIZER;
3734

3735 3736
            rc = machine->vtbl->GetId(machine, &iid.value);
            if (NS_FAILED(rc))
3737
                continue;
3738
            vboxIIDToUUID(&iid, uuid);
3739

3740
            if (memcmp(dom->uuid, uuid, VIR_UUID_BUFLEN) == 0) {
3741 3742 3743
                PRUint32 state = MachineState_Null;
                machine->vtbl->GetState(machine, &state);

3744 3745 3746
                if ((state == MachineState_PoweredOff) ||
                    (state == MachineState_Saved) ||
                    (state == MachineState_Aborted)) {
3747
                    ret = vboxStartMachine(dom, i, machine, &iid);
3748
                } else {
3749
                    virReportError(VIR_ERR_OPERATION_FAILED, "%s",
3750 3751 3752
                                   _("machine is not in "
                                     "poweroff|saved|aborted state, so "
                                     "couldn't start it"));
3753
                    ret = -1;
3754 3755
                }
            }
3756
            vboxIIDUnalloc(&iid);
3757 3758
            if (ret != -1)
                break;
3759 3760 3761
        }
    }

3762
    /* Do the cleanup and take care you dont leak any memory */
3763
    vboxArrayRelease(&machines);
3764

3765 3766 3767 3768
cleanup:
    return ret;
}

3769 3770 3771 3772
static int vboxDomainCreate(virDomainPtr dom) {
    return vboxDomainCreateWithFlags(dom, 0);
}

E
Eric Blake 已提交
3773 3774 3775 3776 3777 3778 3779
static void
vboxSetBootDeviceOrder(virDomainDefPtr def, vboxGlobalData *data,
                       IMachine *machine)
{
    ISystemProperties *systemProperties = NULL;
    PRUint32 maxBootPosition            = 0;
    int i = 0;
3780

3781
    VIR_DEBUG("def->os.type             %s", def->os.type);
3782
    VIR_DEBUG("def->os.arch             %s", virArchToString(def->os.arch));
3783
    VIR_DEBUG("def->os.machine          %s", def->os.machine);
3784
    VIR_DEBUG("def->os.nBootDevs        %zu", def->os.nBootDevs);
3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796
    VIR_DEBUG("def->os.bootDevs[0]      %d", def->os.bootDevs[0]);
    VIR_DEBUG("def->os.bootDevs[1]      %d", def->os.bootDevs[1]);
    VIR_DEBUG("def->os.bootDevs[2]      %d", def->os.bootDevs[2]);
    VIR_DEBUG("def->os.bootDevs[3]      %d", def->os.bootDevs[3]);
    VIR_DEBUG("def->os.init             %s", def->os.init);
    VIR_DEBUG("def->os.kernel           %s", def->os.kernel);
    VIR_DEBUG("def->os.initrd           %s", def->os.initrd);
    VIR_DEBUG("def->os.cmdline          %s", def->os.cmdline);
    VIR_DEBUG("def->os.root             %s", def->os.root);
    VIR_DEBUG("def->os.loader           %s", def->os.loader);
    VIR_DEBUG("def->os.bootloader       %s", def->os.bootloader);
    VIR_DEBUG("def->os.bootloaderArgs   %s", def->os.bootloaderArgs);
3797

E
Eric Blake 已提交
3798 3799 3800 3801 3802 3803
    data->vboxObj->vtbl->GetSystemProperties(data->vboxObj, &systemProperties);
    if (systemProperties) {
        systemProperties->vtbl->GetMaxBootPosition(systemProperties,
                                                   &maxBootPosition);
        VBOX_RELEASE(systemProperties);
        systemProperties = NULL;
3804
    }
3805

E
Eric Blake 已提交
3806 3807 3808
    /* Clear the defaults first */
    for (i = 0; i < maxBootPosition; i++) {
        machine->vtbl->SetBootOrder(machine, i+1, DeviceType_Null);
3809
    }
3810

E
Eric Blake 已提交
3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821
    for (i = 0; (i < def->os.nBootDevs) && (i < maxBootPosition); i++) {
        PRUint32 device = DeviceType_Null;

        if (def->os.bootDevs[i] == VIR_DOMAIN_BOOT_FLOPPY) {
            device = DeviceType_Floppy;
        } else if (def->os.bootDevs[i] == VIR_DOMAIN_BOOT_CDROM) {
            device = DeviceType_DVD;
        } else if (def->os.bootDevs[i] == VIR_DOMAIN_BOOT_DISK) {
            device = DeviceType_HardDisk;
        } else if (def->os.bootDevs[i] == VIR_DOMAIN_BOOT_NET) {
            device = DeviceType_Network;
3822
        }
E
Eric Blake 已提交
3823
        machine->vtbl->SetBootOrder(machine, i+1, device);
3824
    }
E
Eric Blake 已提交
3825
}
3826

E
Eric Blake 已提交
3827 3828 3829 3830 3831
static void
vboxAttachDrives(virDomainDefPtr def, vboxGlobalData *data, IMachine *machine)
{
    int i;
    nsresult rc;
3832 3833

#if VBOX_API_VERSION < 3001
E
Eric Blake 已提交
3834 3835 3836 3837
    if (def->ndisks == 0)
        return;

    for (i = 0; i < def->ndisks; i++) {
3838 3839 3840 3841 3842 3843
        VIR_DEBUG("disk(%d) type:       %d", i, def->disks[i]->type);
        VIR_DEBUG("disk(%d) device:     %d", i, def->disks[i]->device);
        VIR_DEBUG("disk(%d) bus:        %d", i, def->disks[i]->bus);
        VIR_DEBUG("disk(%d) src:        %s", i, def->disks[i]->src);
        VIR_DEBUG("disk(%d) dst:        %s", i, def->disks[i]->dst);
        VIR_DEBUG("disk(%d) driverName: %s", i, def->disks[i]->driverName);
3844 3845
        VIR_DEBUG("disk(%d) driverType: %s", i,
                  virStorageFileFormatTypeToString(def->disks[i]->format));
3846 3847
        VIR_DEBUG("disk(%d) cachemode:  %d", i, def->disks[i]->cachemode);
        VIR_DEBUG("disk(%d) readonly:   %s", i, (def->disks[i]->readonly
E
Eric Blake 已提交
3848
                                             ? "True" : "False"));
3849
        VIR_DEBUG("disk(%d) shared:     %s", i, (def->disks[i]->shared
E
Eric Blake 已提交
3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861
                                             ? "True" : "False"));

        if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_CDROM) {
            if (def->disks[i]->type == VIR_DOMAIN_DISK_TYPE_FILE &&
                def->disks[i]->src != NULL) {
                IDVDDrive *dvdDrive = NULL;
                /* Currently CDROM/DVD Drive is always IDE
                 * Secondary Master so neglecting the following
                 * parameters:
                 *      def->disks[i]->bus
                 *      def->disks[i]->dst
                 */
3862

E
Eric Blake 已提交
3863 3864 3865 3866
                machine->vtbl->GetDVDDrive(machine, &dvdDrive);
                if (dvdDrive) {
                    IDVDImage *dvdImage          = NULL;
                    PRUnichar *dvdfileUtf16      = NULL;
3867 3868
                    vboxIID dvduuid = VBOX_IID_INITIALIZER;
                    vboxIID dvdemptyuuid = VBOX_IID_INITIALIZER;
3869

E
Eric Blake 已提交
3870
                    VBOX_UTF8_TO_UTF16(def->disks[i]->src, &dvdfileUtf16);
3871

E
Eric Blake 已提交
3872 3873 3874 3875 3876
                    data->vboxObj->vtbl->FindDVDImage(data->vboxObj,
                                                      dvdfileUtf16, &dvdImage);
                    if (!dvdImage) {
                        data->vboxObj->vtbl->OpenDVDImage(data->vboxObj,
                                                          dvdfileUtf16,
3877
                                                          dvdemptyuuid.value,
E
Eric Blake 已提交
3878 3879 3880 3881
                                                          &dvdImage);
                    }
                    if (dvdImage) {
                        rc = dvdImage->vtbl->imedium.GetId((IMedium *)dvdImage,
3882
                                                           &dvduuid.value);
E
Eric Blake 已提交
3883
                        if (NS_FAILED(rc)) {
3884 3885 3886 3887
                            virReportError(VIR_ERR_INTERNAL_ERROR,
                                           _("can't get the uuid of the file to "
                                             "be attached to cdrom: %s, rc=%08x"),
                                           def->disks[i]->src, (unsigned)rc);
E
Eric Blake 已提交
3888
                        } else {
3889
                            rc = dvdDrive->vtbl->MountImage(dvdDrive, dvduuid.value);
E
Eric Blake 已提交
3890
                            if (NS_FAILED(rc)) {
3891 3892 3893
                                virReportError(VIR_ERR_INTERNAL_ERROR,
                                               _("could not attach the file to cdrom: %s, rc=%08x"),
                                               def->disks[i]->src, (unsigned)rc);
E
Eric Blake 已提交
3894
                            } else {
3895
                                DEBUGIID("CD/DVDImage UUID:", dvduuid.value);
3896
                            }
3897
                        }
E
Eric Blake 已提交
3898 3899

                        VBOX_MEDIUM_RELEASE(dvdImage);
3900
                    }
3901
                    vboxIIDUnalloc(&dvduuid);
E
Eric Blake 已提交
3902 3903 3904 3905 3906 3907 3908 3909 3910 3911
                    VBOX_UTF16_FREE(dvdfileUtf16);
                    VBOX_RELEASE(dvdDrive);
                }
            } else if (def->disks[i]->type == VIR_DOMAIN_DISK_TYPE_BLOCK) {
            }
        } else if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
            if (def->disks[i]->type == VIR_DOMAIN_DISK_TYPE_FILE &&
                def->disks[i]->src != NULL) {
                IHardDisk *hardDisk     = NULL;
                PRUnichar *hddfileUtf16 = NULL;
3912
                vboxIID hdduuid = VBOX_IID_INITIALIZER;
E
Eric Blake 已提交
3913 3914 3915 3916 3917 3918
                PRUnichar *hddEmpty     = NULL;
                /* Current Limitation: Harddisk can't be connected to
                 * Secondary Master as Secondary Master is always used
                 * for CD/DVD Drive, so don't connect the harddisk if it
                 * is requested to be connected to Secondary master
                 */
3919

E
Eric Blake 已提交
3920 3921
                VBOX_UTF8_TO_UTF16(def->disks[i]->src, &hddfileUtf16);
                VBOX_UTF8_TO_UTF16("", &hddEmpty);
3922

E
Eric Blake 已提交
3923 3924
                data->vboxObj->vtbl->FindHardDisk(data->vboxObj, hddfileUtf16,
                                                  &hardDisk);
3925

E
Eric Blake 已提交
3926
                if (!hardDisk) {
3927
# if VBOX_API_VERSION == 2002
E
Eric Blake 已提交
3928 3929 3930 3931
                    data->vboxObj->vtbl->OpenHardDisk(data->vboxObj,
                                                      hddfileUtf16,
                                                      AccessMode_ReadWrite,
                                                      &hardDisk);
3932
# else
E
Eric Blake 已提交
3933 3934 3935 3936 3937 3938 3939 3940
                    data->vboxObj->vtbl->OpenHardDisk(data->vboxObj,
                                                      hddfileUtf16,
                                                      AccessMode_ReadWrite,
                                                      0,
                                                      hddEmpty,
                                                      0,
                                                      hddEmpty,
                                                      &hardDisk);
3941
# endif
E
Eric Blake 已提交
3942
                }
3943

E
Eric Blake 已提交
3944 3945
                if (hardDisk) {
                    rc = hardDisk->vtbl->imedium.GetId((IMedium *)hardDisk,
3946
                                                       &hdduuid.value);
E
Eric Blake 已提交
3947
                    if (NS_FAILED(rc)) {
3948 3949 3950 3951
                        virReportError(VIR_ERR_INTERNAL_ERROR,
                                       _("can't get the uuid of the file to be "
                                         "attached as harddisk: %s, rc=%08x"),
                                       def->disks[i]->src, (unsigned)rc);
E
Eric Blake 已提交
3952 3953 3954 3955
                    } else {
                        if (def->disks[i]->readonly) {
                            hardDisk->vtbl->SetType(hardDisk,
                                                    HardDiskType_Immutable);
3956
                            VIR_DEBUG("setting harddisk to readonly");
E
Eric Blake 已提交
3957 3958 3959
                        } else if (!def->disks[i]->readonly) {
                            hardDisk->vtbl->SetType(hardDisk,
                                                    HardDiskType_Normal);
3960
                            VIR_DEBUG("setting harddisk type to normal");
E
Eric Blake 已提交
3961 3962 3963
                        }
                        if (def->disks[i]->bus == VIR_DOMAIN_DISK_BUS_IDE) {
                            if (STREQ(def->disks[i]->dst, "hdc")) {
3964
                                VIR_DEBUG("Not connecting harddisk to hdc as hdc"
E
Eric Blake 已提交
3965
                                       " is taken by CD/DVD Drive");
3966
                            } else {
E
Eric Blake 已提交
3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983
                                PRInt32 channel          = 0;
                                PRInt32 device           = 0;
                                PRUnichar *hddcnameUtf16 = NULL;

                                char *hddcname = strdup("IDE");
                                VBOX_UTF8_TO_UTF16(hddcname, &hddcnameUtf16);
                                VIR_FREE(hddcname);

                                if (STREQ(def->disks[i]->dst, "hda")) {
                                    channel = 0;
                                    device  = 0;
                                } else if (STREQ(def->disks[i]->dst, "hdb")) {
                                    channel = 0;
                                    device  = 1;
                                } else if (STREQ(def->disks[i]->dst, "hdd")) {
                                    channel = 1;
                                    device  = 1;
3984
                                }
E
Eric Blake 已提交
3985 3986

                                rc = machine->vtbl->AttachHardDisk(machine,
3987
                                                                   hdduuid.value,
E
Eric Blake 已提交
3988 3989 3990 3991 3992 3993
                                                                   hddcnameUtf16,
                                                                   channel,
                                                                   device);
                                VBOX_UTF16_FREE(hddcnameUtf16);

                                if (NS_FAILED(rc)) {
3994 3995 3996 3997
                                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                                   _("could not attach the file as "
                                                     "harddisk: %s, rc=%08x"),
                                                   def->disks[i]->src, (unsigned)rc);
E
Eric Blake 已提交
3998
                                } else {
3999
                                    DEBUGIID("Attached HDD with UUID", hdduuid.value);
4000 4001 4002
                                }
                            }
                        }
4003
                    }
E
Eric Blake 已提交
4004 4005
                    VBOX_MEDIUM_RELEASE(hardDisk);
                }
4006
                vboxIIDUnalloc(&hdduuid);
E
Eric Blake 已提交
4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020
                VBOX_UTF16_FREE(hddEmpty);
                VBOX_UTF16_FREE(hddfileUtf16);
            } else if (def->disks[i]->type == VIR_DOMAIN_DISK_TYPE_BLOCK) {
            }
        } else if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY) {
            if (def->disks[i]->type == VIR_DOMAIN_DISK_TYPE_FILE &&
                def->disks[i]->src != NULL) {
                IFloppyDrive *floppyDrive;
                machine->vtbl->GetFloppyDrive(machine, &floppyDrive);
                if (floppyDrive) {
                    rc = floppyDrive->vtbl->SetEnabled(floppyDrive, 1);
                    if (NS_SUCCEEDED(rc)) {
                        IFloppyImage *floppyImage   = NULL;
                        PRUnichar *fdfileUtf16      = NULL;
4021 4022
                        vboxIID fduuid = VBOX_IID_INITIALIZER;
                        vboxIID fdemptyuuid = VBOX_IID_INITIALIZER;
4023

E
Eric Blake 已提交
4024 4025 4026 4027
                        VBOX_UTF8_TO_UTF16(def->disks[i]->src, &fdfileUtf16);
                        rc = data->vboxObj->vtbl->FindFloppyImage(data->vboxObj,
                                                                  fdfileUtf16,
                                                                  &floppyImage);
4028

E
Eric Blake 已提交
4029 4030 4031
                        if (!floppyImage) {
                            data->vboxObj->vtbl->OpenFloppyImage(data->vboxObj,
                                                                 fdfileUtf16,
4032
                                                                 fdemptyuuid.value,
E
Eric Blake 已提交
4033 4034
                                                                 &floppyImage);
                        }
4035

E
Eric Blake 已提交
4036 4037
                        if (floppyImage) {
                            rc = floppyImage->vtbl->imedium.GetId((IMedium *)floppyImage,
4038
                                                                  &fduuid.value);
E
Eric Blake 已提交
4039
                            if (NS_FAILED(rc)) {
4040 4041 4042 4043
                                virReportError(VIR_ERR_INTERNAL_ERROR,
                                               _("can't get the uuid of the file to "
                                                 "be attached to floppy drive: %s, rc=%08x"),
                                               def->disks[i]->src, (unsigned)rc);
E
Eric Blake 已提交
4044 4045
                            } else {
                                rc = floppyDrive->vtbl->MountImage(floppyDrive,
4046
                                                                   fduuid.value);
E
Eric Blake 已提交
4047
                                if (NS_FAILED(rc)) {
4048 4049 4050 4051
                                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                                   _("could not attach the file to "
                                                     "floppy drive: %s, rc=%08x"),
                                                   def->disks[i]->src, (unsigned)rc);
E
Eric Blake 已提交
4052
                                } else {
4053
                                    DEBUGIID("floppyImage UUID", fduuid.value);
4054 4055
                                }
                            }
E
Eric Blake 已提交
4056
                            VBOX_MEDIUM_RELEASE(floppyImage);
4057
                        }
4058
                        vboxIIDUnalloc(&fduuid);
E
Eric Blake 已提交
4059
                        VBOX_UTF16_FREE(fdfileUtf16);
4060
                    }
E
Eric Blake 已提交
4061
                    VBOX_RELEASE(floppyDrive);
4062
                }
E
Eric Blake 已提交
4063
            } else if (def->disks[i]->type == VIR_DOMAIN_DISK_TYPE_BLOCK) {
4064
            }
4065
        }
E
Eric Blake 已提交
4066
    }
4067
#else  /* VBOX_API_VERSION >= 3001 */
E
Eric Blake 已提交
4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079
    PRUint32 maxPortPerInst[StorageBus_Floppy + 1] = {};
    PRUint32 maxSlotPerPort[StorageBus_Floppy + 1] = {};
    PRUnichar *storageCtlName = NULL;
    bool error = false;

    /* get the max port/slots/etc for the given storage bus */
    error = !vboxGetMaxPortSlotValues(data->vboxObj, maxPortPerInst,
                                      maxSlotPerPort);

    /* add a storage controller for the mediums to be attached */
    /* this needs to change when multiple controller are supported for
     * ver > 3.1 */
4080
    {
E
Eric Blake 已提交
4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115
        IStorageController *storageCtl = NULL;
        PRUnichar *sName = NULL;

        VBOX_UTF8_TO_UTF16("IDE Controller", &sName);
        machine->vtbl->AddStorageController(machine,
                                            sName,
                                            StorageBus_IDE,
                                            &storageCtl);
        VBOX_UTF16_FREE(sName);
        VBOX_RELEASE(storageCtl);

        VBOX_UTF8_TO_UTF16("SATA Controller", &sName);
        machine->vtbl->AddStorageController(machine,
                                            sName,
                                            StorageBus_SATA,
                                            &storageCtl);
        VBOX_UTF16_FREE(sName);
        VBOX_RELEASE(storageCtl);

        VBOX_UTF8_TO_UTF16("SCSI Controller", &sName);
        machine->vtbl->AddStorageController(machine,
                                            sName,
                                            StorageBus_SCSI,
                                            &storageCtl);
        VBOX_UTF16_FREE(sName);
        VBOX_RELEASE(storageCtl);

        VBOX_UTF8_TO_UTF16("Floppy Controller", &sName);
        machine->vtbl->AddStorageController(machine,
                                            sName,
                                            StorageBus_Floppy,
                                            &storageCtl);
        VBOX_UTF16_FREE(sName);
        VBOX_RELEASE(storageCtl);
    }
4116

E
Eric Blake 已提交
4117
    for (i = 0; i < def->ndisks && !error; i++) {
4118 4119 4120 4121 4122 4123
        VIR_DEBUG("disk(%d) type:       %d", i, def->disks[i]->type);
        VIR_DEBUG("disk(%d) device:     %d", i, def->disks[i]->device);
        VIR_DEBUG("disk(%d) bus:        %d", i, def->disks[i]->bus);
        VIR_DEBUG("disk(%d) src:        %s", i, def->disks[i]->src);
        VIR_DEBUG("disk(%d) dst:        %s", i, def->disks[i]->dst);
        VIR_DEBUG("disk(%d) driverName: %s", i, def->disks[i]->driverName);
4124 4125
        VIR_DEBUG("disk(%d) driverType: %s", i,
                  virStorageFileFormatTypeToString(def->disks[i]->format));
4126 4127
        VIR_DEBUG("disk(%d) cachemode:  %d", i, def->disks[i]->cachemode);
        VIR_DEBUG("disk(%d) readonly:   %s", i, (def->disks[i]->readonly
E
Eric Blake 已提交
4128
                                             ? "True" : "False"));
4129
        VIR_DEBUG("disk(%d) shared:     %s", i, (def->disks[i]->shared
E
Eric Blake 已提交
4130 4131 4132 4133 4134 4135 4136 4137 4138
                                             ? "True" : "False"));

        if (def->disks[i]->type == VIR_DOMAIN_DISK_TYPE_FILE &&
            def->disks[i]->src != NULL) {
            IMedium   *medium          = NULL;
            PRUnichar *mediumUUID      = NULL;
            PRUnichar *mediumFileUtf16 = NULL;
            PRUint32   storageBus      = StorageBus_Null;
            PRUint32   deviceType      = DeviceType_Null;
4139
# if VBOX_API_VERSION >= 4000
4140
            PRUint32   accessMode      = AccessMode_ReadOnly;
4141
# endif
E
Eric Blake 已提交
4142 4143 4144 4145 4146 4147 4148 4149
            PRInt32    deviceInst      = 0;
            PRInt32    devicePort      = 0;
            PRInt32    deviceSlot      = 0;

            VBOX_UTF8_TO_UTF16(def->disks[i]->src, &mediumFileUtf16);

            if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
                deviceType = DeviceType_HardDisk;
4150
# if VBOX_API_VERSION < 4000
E
Eric Blake 已提交
4151 4152
                data->vboxObj->vtbl->FindHardDisk(data->vboxObj,
                                                  mediumFileUtf16, &medium);
4153 4154
# else
                accessMode = AccessMode_ReadWrite;
4155
# endif
E
Eric Blake 已提交
4156 4157
            } else if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_CDROM) {
                deviceType = DeviceType_DVD;
4158
# if VBOX_API_VERSION < 4000
E
Eric Blake 已提交
4159 4160
                data->vboxObj->vtbl->FindDVDImage(data->vboxObj,
                                                  mediumFileUtf16, &medium);
4161 4162
# else
                accessMode = AccessMode_ReadOnly;
4163
# endif
E
Eric Blake 已提交
4164 4165
            } else if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY) {
                deviceType = DeviceType_Floppy;
4166
# if VBOX_API_VERSION < 4000
E
Eric Blake 已提交
4167 4168
                data->vboxObj->vtbl->FindFloppyImage(data->vboxObj,
                                                     mediumFileUtf16, &medium);
4169 4170
# else
                accessMode = AccessMode_ReadWrite;
4171
# endif
E
Eric Blake 已提交
4172 4173 4174 4175
            } else {
                VBOX_UTF16_FREE(mediumFileUtf16);
                continue;
            }
4176

4177 4178 4179 4180 4181
# if VBOX_API_VERSION >= 4000
            data->vboxObj->vtbl->FindMedium(data->vboxObj, mediumFileUtf16,
                                            deviceType, &medium);
# endif

E
Eric Blake 已提交
4182 4183
            if (!medium) {
                PRUnichar *mediumEmpty = NULL;
4184

E
Eric Blake 已提交
4185
                VBOX_UTF8_TO_UTF16("", &mediumEmpty);
4186

4187
# if VBOX_API_VERSION < 4000
4188
                if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
4189 4190 4191 4192 4193 4194 4195 4196
                    rc = data->vboxObj->vtbl->OpenHardDisk(data->vboxObj,
                                                           mediumFileUtf16,
                                                           AccessMode_ReadWrite,
                                                           false,
                                                           mediumEmpty,
                                                           false,
                                                           mediumEmpty,
                                                           &medium);
E
Eric Blake 已提交
4197 4198
                } else if (def->disks[i]->device ==
                           VIR_DOMAIN_DISK_DEVICE_CDROM) {
4199 4200 4201 4202
                    rc = data->vboxObj->vtbl->OpenDVDImage(data->vboxObj,
                                                           mediumFileUtf16,
                                                           mediumEmpty,
                                                           &medium);
E
Eric Blake 已提交
4203 4204
                } else if (def->disks[i]->device ==
                           VIR_DOMAIN_DISK_DEVICE_FLOPPY) {
4205 4206 4207 4208 4209 4210
                    rc = data->vboxObj->vtbl->OpenFloppyImage(data->vboxObj,
                                                              mediumFileUtf16,
                                                              mediumEmpty,
                                                              &medium);
                } else {
                    rc = 0;
4211
                }
4212
# elif VBOX_API_VERSION == 4000
4213 4214 4215 4216
                rc = data->vboxObj->vtbl->OpenMedium(data->vboxObj,
                                                     mediumFileUtf16,
                                                     deviceType, accessMode,
                                                     &medium);
4217 4218 4219 4220 4221 4222 4223
# elif VBOX_API_VERSION >= 4001
                rc = data->vboxObj->vtbl->OpenMedium(data->vboxObj,
                                                     mediumFileUtf16,
                                                     deviceType, accessMode,
                                                     false,
                                                     &medium);
# endif /* VBOX_API_VERSION >= 4001 */
4224

E
Eric Blake 已提交
4225 4226
                VBOX_UTF16_FREE(mediumEmpty);
            }
4227

E
Eric Blake 已提交
4228
            if (!medium) {
4229 4230 4231 4232
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Failed to attach the following disk/dvd/floppy "
                                 "to the machine: %s, rc=%08x"),
                               def->disks[i]->src, (unsigned)rc);
E
Eric Blake 已提交
4233 4234 4235
                VBOX_UTF16_FREE(mediumFileUtf16);
                continue;
            }
4236

E
Eric Blake 已提交
4237 4238
            rc = medium->vtbl->GetId(medium, &mediumUUID);
            if (NS_FAILED(rc)) {
4239 4240 4241 4242
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("can't get the uuid of the file to be attached "
                                 "as harddisk/dvd/floppy: %s, rc=%08x"),
                               def->disks[i]->src, (unsigned)rc);
E
Eric Blake 已提交
4243 4244 4245 4246
                VBOX_RELEASE(medium);
                VBOX_UTF16_FREE(mediumFileUtf16);
                continue;
            }
4247

E
Eric Blake 已提交
4248 4249 4250
            if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
                if (def->disks[i]->readonly) {
                    medium->vtbl->SetType(medium, MediumType_Immutable);
4251
                    VIR_DEBUG("setting harddisk to immutable");
E
Eric Blake 已提交
4252 4253
                } else if (!def->disks[i]->readonly) {
                    medium->vtbl->SetType(medium, MediumType_Normal);
4254
                    VIR_DEBUG("setting harddisk type to normal");
4255
                }
E
Eric Blake 已提交
4256
            }
4257

E
Eric Blake 已提交
4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270
            if (def->disks[i]->bus == VIR_DOMAIN_DISK_BUS_IDE) {
                VBOX_UTF8_TO_UTF16("IDE Controller", &storageCtlName);
                storageBus = StorageBus_IDE;
            } else if (def->disks[i]->bus == VIR_DOMAIN_DISK_BUS_SATA) {
                VBOX_UTF8_TO_UTF16("SATA Controller", &storageCtlName);
                storageBus = StorageBus_SATA;
            } else if (def->disks[i]->bus == VIR_DOMAIN_DISK_BUS_SCSI) {
                VBOX_UTF8_TO_UTF16("SCSI Controller", &storageCtlName);
                storageBus = StorageBus_SCSI;
            } else if (def->disks[i]->bus == VIR_DOMAIN_DISK_BUS_FDC) {
                VBOX_UTF8_TO_UTF16("Floppy Controller", &storageCtlName);
                storageBus = StorageBus_Floppy;
            }
4271

E
Eric Blake 已提交
4272 4273 4274 4275 4276 4277 4278 4279
            /* get the device details i.e instance, port and slot */
            if (!vboxGetDeviceDetails(def->disks[i]->dst,
                                      maxPortPerInst,
                                      maxSlotPerPort,
                                      storageBus,
                                      &deviceInst,
                                      &devicePort,
                                      &deviceSlot)) {
4280
                virReportError(VIR_ERR_INTERNAL_ERROR,
4281 4282 4283
                               _("can't get the port/slot number of "
                                 "harddisk/dvd/floppy to be attached: "
                                 "%s, rc=%08x"),
4284
                               def->disks[i]->src, (unsigned)rc);
4285 4286 4287
                VBOX_RELEASE(medium);
                VBOX_UTF16_FREE(mediumUUID);
                VBOX_UTF16_FREE(mediumFileUtf16);
E
Eric Blake 已提交
4288 4289 4290 4291 4292 4293 4294 4295 4296
                continue;
            }

            /* attach the harddisk/dvd/Floppy to the storage controller */
            rc = machine->vtbl->AttachDevice(machine,
                                             storageCtlName,
                                             devicePort,
                                             deviceSlot,
                                             deviceType,
4297
# if VBOX_API_VERSION < 4000
E
Eric Blake 已提交
4298
                                             mediumUUID);
4299 4300 4301
# else /* VBOX_API_VERSION >= 4000 */
                                             medium);
# endif /* VBOX_API_VERSION >= 4000 */
E
Eric Blake 已提交
4302 4303

            if (NS_FAILED(rc)) {
4304
                virReportError(VIR_ERR_INTERNAL_ERROR,
4305 4306
                               _("could not attach the file as "
                                 "harddisk/dvd/floppy: %s, rc=%08x"),
4307
                               def->disks[i]->src, (unsigned)rc);
E
Eric Blake 已提交
4308 4309
            } else {
                DEBUGIID("Attached HDD/DVD/Floppy with UUID", mediumUUID);
4310
            }
E
Eric Blake 已提交
4311 4312 4313 4314 4315

            VBOX_RELEASE(medium);
            VBOX_UTF16_FREE(mediumUUID);
            VBOX_UTF16_FREE(mediumFileUtf16);
            VBOX_UTF16_FREE(storageCtlName);
4316 4317 4318
        }
    }
#endif /* VBOX_API_VERSION >= 3001 */
E
Eric Blake 已提交
4319
}
4320

E
Eric Blake 已提交
4321 4322 4323 4324
static void
vboxAttachSound(virDomainDefPtr def, IMachine *machine)
{
    nsresult rc;
4325

E
Eric Blake 已提交
4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341
    /* Check if def->nsounds is one as VirtualBox currently supports
     * only one sound card
     */
    if (def->nsounds == 1) {
        IAudioAdapter *audioAdapter = NULL;

        machine->vtbl->GetAudioAdapter(machine, &audioAdapter);
        if (audioAdapter) {
            rc = audioAdapter->vtbl->SetEnabled(audioAdapter, 1);
            if (NS_SUCCEEDED(rc)) {
                if (def->sounds[0]->model == VIR_DOMAIN_SOUND_MODEL_SB16) {
                    audioAdapter->vtbl->SetAudioController(audioAdapter,
                                                           AudioControllerType_SB16);
                } else if (def->sounds[0]->model == VIR_DOMAIN_SOUND_MODEL_AC97) {
                    audioAdapter->vtbl->SetAudioController(audioAdapter,
                                                           AudioControllerType_AC97);
4342
                }
4343
            }
E
Eric Blake 已提交
4344
            VBOX_RELEASE(audioAdapter);
4345
        }
E
Eric Blake 已提交
4346 4347 4348 4349 4350 4351 4352
    }
}

static void
vboxAttachNetwork(virDomainDefPtr def, vboxGlobalData *data, IMachine *machine)
{
    ISystemProperties *systemProperties = NULL;
4353 4354 4355
#if VBOX_API_VERSION >= 4001
    PRUint32 chipsetType                = ChipsetType_Null;
#endif /* VBOX_API_VERSION >= 4001 */
E
Eric Blake 已提交
4356 4357 4358
    PRUint32 networkAdapterCount        = 0;
    int i = 0;

4359 4360 4361 4362
#if VBOX_API_VERSION >= 4001
    machine->vtbl->GetChipsetType(machine, &chipsetType);
#endif /* VBOX_API_VERSION >= 4001 */

E
Eric Blake 已提交
4363 4364
    data->vboxObj->vtbl->GetSystemProperties(data->vboxObj, &systemProperties);
    if (systemProperties) {
4365
#if VBOX_API_VERSION < 4001
E
Eric Blake 已提交
4366 4367
        systemProperties->vtbl->GetNetworkAdapterCount(systemProperties,
                                                       &networkAdapterCount);
4368 4369 4370 4371
#else  /* VBOX_API_VERSION >= 4000 */
        systemProperties->vtbl->GetMaxNetworkAdapters(systemProperties, chipsetType,
                                                      &networkAdapterCount);
#endif /* VBOX_API_VERSION >= 4000 */
E
Eric Blake 已提交
4372 4373 4374 4375
        VBOX_RELEASE(systemProperties);
        systemProperties = NULL;
    }

4376
    VIR_DEBUG("Number of Network Cards to be connected: %zu", def->nnets);
4377
    VIR_DEBUG("Number of Network Cards available: %d", networkAdapterCount);
E
Eric Blake 已提交
4378 4379 4380 4381 4382 4383 4384

    for (i = 0; (i < def->nnets) && (i < networkAdapterCount); i++) {
        INetworkAdapter *adapter = NULL;
        PRUint32 adapterType     = NetworkAdapterType_Null;
        char macaddr[VIR_MAC_STRING_BUFLEN] = {0};
        char macaddrvbox[VIR_MAC_STRING_BUFLEN - 5] = {0};

4385
        virMacAddrFormat(&def->nets[i]->mac, macaddr);
E
Eric Blake 已提交
4386 4387
        snprintf(macaddrvbox, VIR_MAC_STRING_BUFLEN - 5,
                 "%02X%02X%02X%02X%02X%02X",
4388 4389 4390 4391 4392 4393
                 def->nets[i]->mac.addr[0],
                 def->nets[i]->mac.addr[1],
                 def->nets[i]->mac.addr[2],
                 def->nets[i]->mac.addr[3],
                 def->nets[i]->mac.addr[4],
                 def->nets[i]->mac.addr[5]);
E
Eric Blake 已提交
4394 4395
        macaddrvbox[VIR_MAC_STRING_BUFLEN - 6] = '\0';

4396 4397 4398 4399
        VIR_DEBUG("NIC(%d): Type:   %d", i, def->nets[i]->type);
        VIR_DEBUG("NIC(%d): Model:  %s", i, def->nets[i]->model);
        VIR_DEBUG("NIC(%d): Mac:    %s", i, macaddr);
        VIR_DEBUG("NIC(%d): ifname: %s", i, def->nets[i]->ifname);
E
Eric Blake 已提交
4400
        if (def->nets[i]->type == VIR_DOMAIN_NET_TYPE_NETWORK) {
4401
            VIR_DEBUG("NIC(%d): name:    %s", i, def->nets[i]->data.network.name);
E
Eric Blake 已提交
4402
        } else if (def->nets[i]->type == VIR_DOMAIN_NET_TYPE_INTERNAL) {
4403
            VIR_DEBUG("NIC(%d): name:   %s", i, def->nets[i]->data.internal.name);
E
Eric Blake 已提交
4404
        } else if (def->nets[i]->type == VIR_DOMAIN_NET_TYPE_USER) {
4405
            VIR_DEBUG("NIC(%d): NAT.", i);
E
Eric Blake 已提交
4406
        } else if (def->nets[i]->type == VIR_DOMAIN_NET_TYPE_BRIDGE) {
4407
            VIR_DEBUG("NIC(%d): brname: %s", i, def->nets[i]->data.bridge.brname);
4408
            VIR_DEBUG("NIC(%d): script: %s", i, def->nets[i]->script);
4409
            VIR_DEBUG("NIC(%d): ipaddr: %s", i, def->nets[i]->data.bridge.ipaddr);
4410 4411
        }

E
Eric Blake 已提交
4412 4413 4414 4415 4416
        machine->vtbl->GetNetworkAdapter(machine, i, &adapter);
        if (adapter) {
            PRUnichar *MACAddress = NULL;

            adapter->vtbl->SetEnabled(adapter, 1);
4417

E
Eric Blake 已提交
4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428
            if (def->nets[i]->model) {
                if (STRCASEEQ(def->nets[i]->model , "Am79C970A")) {
                    adapterType = NetworkAdapterType_Am79C970A;
                } else if (STRCASEEQ(def->nets[i]->model , "Am79C973")) {
                    adapterType = NetworkAdapterType_Am79C973;
                } else if (STRCASEEQ(def->nets[i]->model , "82540EM")) {
                    adapterType = NetworkAdapterType_I82540EM;
                } else if (STRCASEEQ(def->nets[i]->model , "82545EM")) {
                    adapterType = NetworkAdapterType_I82545EM;
                } else if (STRCASEEQ(def->nets[i]->model , "82543GC")) {
                    adapterType = NetworkAdapterType_I82543GC;
4429
#if VBOX_API_VERSION >= 3001
E
Eric Blake 已提交
4430 4431
                } else if (STRCASEEQ(def->nets[i]->model , "virtio")) {
                    adapterType = NetworkAdapterType_Virtio;
4432 4433
#endif /* VBOX_API_VERSION >= 3001 */
                }
E
Eric Blake 已提交
4434 4435 4436
            } else {
                adapterType = NetworkAdapterType_Am79C973;
            }
4437

E
Eric Blake 已提交
4438
            adapter->vtbl->SetAdapterType(adapter, adapterType);
4439

E
Eric Blake 已提交
4440 4441 4442
            if (def->nets[i]->type == VIR_DOMAIN_NET_TYPE_BRIDGE) {
                PRUnichar *hostInterface = NULL;
                /* Bridged Network */
4443

4444
#if VBOX_API_VERSION < 4001
E
Eric Blake 已提交
4445
                adapter->vtbl->AttachToBridgedInterface(adapter);
4446 4447 4448
#else /* VBOX_API_VERSION >= 4001 */
                adapter->vtbl->SetAttachmentType(adapter, NetworkAttachmentType_Bridged);
#endif /* VBOX_API_VERSION >= 4001 */
4449

E
Eric Blake 已提交
4450 4451 4452
                if (def->nets[i]->data.bridge.brname) {
                    VBOX_UTF8_TO_UTF16(def->nets[i]->data.bridge.brname,
                                       &hostInterface);
4453
#if VBOX_API_VERSION < 4001
E
Eric Blake 已提交
4454
                    adapter->vtbl->SetHostInterface(adapter, hostInterface);
4455 4456 4457
#else /* VBOX_API_VERSION >= 4001 */
                    adapter->vtbl->SetBridgedInterface(adapter, hostInterface);
#endif /* VBOX_API_VERSION >= 4001 */
E
Eric Blake 已提交
4458 4459 4460 4461 4462
                    VBOX_UTF16_FREE(hostInterface);
                }
            } else if (def->nets[i]->type == VIR_DOMAIN_NET_TYPE_INTERNAL) {
                PRUnichar *internalNetwork = NULL;
                /* Internal Network */
4463

4464
#if VBOX_API_VERSION < 4001
E
Eric Blake 已提交
4465
                adapter->vtbl->AttachToInternalNetwork(adapter);
4466 4467 4468
#else /* VBOX_API_VERSION >= 4001 */
                adapter->vtbl->SetAttachmentType(adapter, NetworkAttachmentType_Internal);
#endif /* VBOX_API_VERSION >= 4001 */
4469

E
Eric Blake 已提交
4470 4471 4472 4473 4474
                if (def->nets[i]->data.internal.name) {
                    VBOX_UTF8_TO_UTF16(def->nets[i]->data.internal.name,
                                       &internalNetwork);
                    adapter->vtbl->SetInternalNetwork(adapter, internalNetwork);
                    VBOX_UTF16_FREE(internalNetwork);
4475
                }
E
Eric Blake 已提交
4476 4477 4478 4479 4480 4481
            } else if (def->nets[i]->type == VIR_DOMAIN_NET_TYPE_NETWORK) {
                PRUnichar *hostInterface = NULL;
                /* Host Only Networking (currently only vboxnet0 available
                 * on *nix and mac, on windows you can create and configure
                 * as many as you want)
                 */
4482
#if VBOX_API_VERSION < 4001
E
Eric Blake 已提交
4483
                adapter->vtbl->AttachToHostOnlyInterface(adapter);
4484 4485 4486
#else /* VBOX_API_VERSION >= 4001 */
                adapter->vtbl->SetAttachmentType(adapter, NetworkAttachmentType_HostOnly);
#endif /* VBOX_API_VERSION >= 4001 */
4487

E
Eric Blake 已提交
4488 4489 4490
                if (def->nets[i]->data.network.name) {
                    VBOX_UTF8_TO_UTF16(def->nets[i]->data.network.name,
                                       &hostInterface);
4491
#if VBOX_API_VERSION < 4001
E
Eric Blake 已提交
4492
                    adapter->vtbl->SetHostInterface(adapter, hostInterface);
4493 4494 4495
#else /* VBOX_API_VERSION >= 4001 */
                    adapter->vtbl->SetHostOnlyInterface(adapter, hostInterface);
#endif /* VBOX_API_VERSION >= 4001 */
E
Eric Blake 已提交
4496 4497 4498 4499
                    VBOX_UTF16_FREE(hostInterface);
                }
            } else if (def->nets[i]->type == VIR_DOMAIN_NET_TYPE_USER) {
                /* NAT */
4500
#if VBOX_API_VERSION < 4001
E
Eric Blake 已提交
4501
                adapter->vtbl->AttachToNAT(adapter);
4502 4503 4504
#else /* VBOX_API_VERSION >= 4001 */
                adapter->vtbl->SetAttachmentType(adapter, NetworkAttachmentType_NAT);
#endif /* VBOX_API_VERSION >= 4001 */
E
Eric Blake 已提交
4505 4506 4507 4508
            } else {
                /* else always default to NAT if we don't understand
                 * what option is been passed to us
                 */
4509
#if VBOX_API_VERSION < 4001
E
Eric Blake 已提交
4510
                adapter->vtbl->AttachToNAT(adapter);
4511 4512 4513
#else /* VBOX_API_VERSION >= 4001 */
                adapter->vtbl->SetAttachmentType(adapter, NetworkAttachmentType_NAT);
#endif /* VBOX_API_VERSION >= 4001 */
4514
            }
E
Eric Blake 已提交
4515 4516 4517 4518

            VBOX_UTF8_TO_UTF16(macaddrvbox, &MACAddress);
            adapter->vtbl->SetMACAddress(adapter, MACAddress);
            VBOX_UTF16_FREE(MACAddress);
4519
        }
E
Eric Blake 已提交
4520 4521 4522 4523 4524 4525 4526 4527 4528
    }
}

static void
vboxAttachSerial(virDomainDefPtr def, vboxGlobalData *data, IMachine *machine)
{
    ISystemProperties *systemProperties = NULL;
    PRUint32 serialPortCount            = 0;
    int i = 0;
4529

E
Eric Blake 已提交
4530 4531 4532 4533 4534 4535 4536
    data->vboxObj->vtbl->GetSystemProperties(data->vboxObj, &systemProperties);
    if (systemProperties) {
        systemProperties->vtbl->GetSerialPortCount(systemProperties,
                                                   &serialPortCount);
        VBOX_RELEASE(systemProperties);
        systemProperties = NULL;
    }
4537

4538
    VIR_DEBUG("Number of Serial Ports to be connected: %zu", def->nserials);
4539
    VIR_DEBUG("Number of Serial Ports available: %d", serialPortCount);
E
Eric Blake 已提交
4540 4541
    for (i = 0; (i < def->nserials) && (i < serialPortCount); i++) {
        ISerialPort *serialPort = NULL;
4542

4543 4544
        VIR_DEBUG("SerialPort(%d): Type: %d", i, def->serials[i]->source.type);
        VIR_DEBUG("SerialPort(%d): target.port: %d", i,
E
Eric Blake 已提交
4545
              def->serials[i]->target.port);
4546

E
Eric Blake 已提交
4547 4548 4549
        machine->vtbl->GetSerialPort(machine, i, &serialPort);
        if (serialPort) {
            PRUnichar *pathUtf16 = NULL;
4550

E
Eric Blake 已提交
4551
            serialPort->vtbl->SetEnabled(serialPort, 1);
4552

4553 4554 4555
            if (def->serials[i]->source.data.file.path) {
                VBOX_UTF8_TO_UTF16(def->serials[i]->source.data.file.path,
                                   &pathUtf16);
E
Eric Blake 已提交
4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570
                serialPort->vtbl->SetPath(serialPort, pathUtf16);
            }

            /* For now hard code the serial ports to COM1 and COM2,
             * COM1 (Base Addr: 0x3F8 (decimal: 1016), IRQ: 4)
             * COM2 (Base Addr: 0x2F8 (decimal:  760), IRQ: 3)
             * TODO: make this more flexible
             */
            /* TODO: to improve the libvirt XMl handling so
             * that def->serials[i]->target.port shows real port
             * and not always start at 0
             */
            if (def->serials[i]->target.port == 0) {
                serialPort->vtbl->SetIRQ(serialPort, 4);
                serialPort->vtbl->SetIOBase(serialPort, 1016);
4571
                VIR_DEBUG(" serialPort-%d irq: %d, iobase 0x%x, path: %s",
4572
                      i, 4, 1016, def->serials[i]->source.data.file.path);
E
Eric Blake 已提交
4573 4574 4575
            } else if (def->serials[i]->target.port == 1) {
                serialPort->vtbl->SetIRQ(serialPort, 3);
                serialPort->vtbl->SetIOBase(serialPort, 760);
4576
                VIR_DEBUG(" serialPort-%d irq: %d, iobase 0x%x, path: %s",
4577
                      i, 3, 760, def->serials[i]->source.data.file.path);
E
Eric Blake 已提交
4578
            }
4579

4580
            if (def->serials[i]->source.type == VIR_DOMAIN_CHR_TYPE_DEV) {
E
Eric Blake 已提交
4581
                serialPort->vtbl->SetHostMode(serialPort, PortMode_HostDevice);
4582
            } else if (def->serials[i]->source.type == VIR_DOMAIN_CHR_TYPE_PIPE) {
E
Eric Blake 已提交
4583
                serialPort->vtbl->SetHostMode(serialPort, PortMode_HostPipe);
4584
#if VBOX_API_VERSION >= 3000
4585
            } else if (def->serials[i]->source.type == VIR_DOMAIN_CHR_TYPE_FILE) {
E
Eric Blake 已提交
4586
                serialPort->vtbl->SetHostMode(serialPort, PortMode_RawFile);
4587
#endif /* VBOX_API_VERSION >= 3000 */
E
Eric Blake 已提交
4588 4589 4590 4591
            } else {
                serialPort->vtbl->SetHostMode(serialPort,
                                              PortMode_Disconnected);
            }
4592

E
Eric Blake 已提交
4593 4594 4595 4596
            VBOX_RELEASE(serialPort);
            if (pathUtf16) {
                VBOX_UTF16_FREE(pathUtf16);
                pathUtf16 = NULL;
4597
            }
4598
        }
E
Eric Blake 已提交
4599 4600
    }
}
4601

E
Eric Blake 已提交
4602 4603 4604 4605 4606 4607
static void
vboxAttachParallel(virDomainDefPtr def, vboxGlobalData *data, IMachine *machine)
{
    ISystemProperties *systemProperties = NULL;
    PRUint32 parallelPortCount          = 0;
    int i = 0;
4608

E
Eric Blake 已提交
4609 4610 4611 4612 4613 4614 4615
    data->vboxObj->vtbl->GetSystemProperties(data->vboxObj, &systemProperties);
    if (systemProperties) {
        systemProperties->vtbl->GetParallelPortCount(systemProperties,
                                                     &parallelPortCount);
        VBOX_RELEASE(systemProperties);
        systemProperties = NULL;
    }
4616

4617
    VIR_DEBUG("Number of Parallel Ports to be connected: %zu", def->nparallels);
4618
    VIR_DEBUG("Number of Parallel Ports available: %d", parallelPortCount);
E
Eric Blake 已提交
4619 4620
    for (i = 0; (i < def->nparallels) && (i < parallelPortCount); i++) {
        IParallelPort *parallelPort = NULL;
4621

4622 4623
        VIR_DEBUG("ParallelPort(%d): Type: %d", i, def->parallels[i]->source.type);
        VIR_DEBUG("ParallelPort(%d): target.port: %d", i,
E
Eric Blake 已提交
4624
              def->parallels[i]->target.port);
4625

E
Eric Blake 已提交
4626 4627 4628
        machine->vtbl->GetParallelPort(machine, i, &parallelPort);
        if (parallelPort) {
            PRUnichar *pathUtf16 = NULL;
4629

4630
            VBOX_UTF8_TO_UTF16(def->parallels[i]->source.data.file.path, &pathUtf16);
4631

E
Eric Blake 已提交
4632 4633 4634 4635 4636
            /* For now hard code the parallel ports to
             * LPT1 (Base Addr: 0x378 (decimal: 888), IRQ: 7)
             * LPT2 (Base Addr: 0x278 (decimal: 632), IRQ: 5)
             * TODO: make this more flexible
             */
4637 4638 4639 4640
            if ((def->parallels[i]->source.type == VIR_DOMAIN_CHR_TYPE_DEV)  ||
                (def->parallels[i]->source.type == VIR_DOMAIN_CHR_TYPE_PTY)  ||
                (def->parallels[i]->source.type == VIR_DOMAIN_CHR_TYPE_FILE) ||
                (def->parallels[i]->source.type == VIR_DOMAIN_CHR_TYPE_PIPE)) {
E
Eric Blake 已提交
4641 4642 4643 4644
                parallelPort->vtbl->SetPath(parallelPort, pathUtf16);
                if (i == 0) {
                    parallelPort->vtbl->SetIRQ(parallelPort, 7);
                    parallelPort->vtbl->SetIOBase(parallelPort, 888);
4645
                    VIR_DEBUG(" parallePort-%d irq: %d, iobase 0x%x, path: %s",
4646
                          i, 7, 888, def->parallels[i]->source.data.file.path);
E
Eric Blake 已提交
4647 4648 4649
                } else if (i == 1) {
                    parallelPort->vtbl->SetIRQ(parallelPort, 5);
                    parallelPort->vtbl->SetIOBase(parallelPort, 632);
4650
                    VIR_DEBUG(" parallePort-%d irq: %d, iobase 0x%x, path: %s",
4651
                          i, 5, 632, def->parallels[i]->source.data.file.path);
4652 4653
                }
            }
E
Eric Blake 已提交
4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664

            /* like serial port, parallel port can't be enabled unless
             * correct IRQ and IOBase values are specified.
             */
            parallelPort->vtbl->SetEnabled(parallelPort, 1);

            VBOX_RELEASE(parallelPort);
            if (pathUtf16) {
                VBOX_UTF16_FREE(pathUtf16);
                pathUtf16 = NULL;
            }
4665
        }
E
Eric Blake 已提交
4666 4667 4668 4669 4670 4671 4672 4673
    }
}

static void
vboxAttachVideo(virDomainDefPtr def, IMachine *machine)
{
    if ((def->nvideos == 1) &&
        (def->videos[0]->type == VIR_DOMAIN_VIDEO_TYPE_VBOX)) {
4674 4675
        machine->vtbl->SetVRAMSize(machine,
                                   VIR_DIV_UP(def->videos[0]->vram, 1024));
E
Eric Blake 已提交
4676 4677 4678 4679
        machine->vtbl->SetMonitorCount(machine, def->videos[0]->heads);
        if (def->videos[0]->accel) {
            machine->vtbl->SetAccelerate3DEnabled(machine,
                                                  def->videos[0]->accel->support3d);
4680
#if VBOX_API_VERSION >= 3001
E
Eric Blake 已提交
4681 4682
            machine->vtbl->SetAccelerate2DVideoEnabled(machine,
                                                       def->videos[0]->accel->support2d);
4683
#endif /* VBOX_API_VERSION >= 3001 */
E
Eric Blake 已提交
4684 4685
        } else {
            machine->vtbl->SetAccelerate3DEnabled(machine, 0);
4686
#if VBOX_API_VERSION >= 3001
E
Eric Blake 已提交
4687
            machine->vtbl->SetAccelerate2DVideoEnabled(machine, 0);
4688 4689
#endif /* VBOX_API_VERSION >= 3001 */
        }
E
Eric Blake 已提交
4690 4691
    }
}
4692

E
Eric Blake 已提交
4693 4694 4695 4696 4697 4698 4699 4700 4701
static void
vboxAttachDisplay(virDomainDefPtr def, vboxGlobalData *data, IMachine *machine)
{
    int vrdpPresent  = 0;
    int sdlPresent   = 0;
    int guiPresent   = 0;
    char *guiDisplay = NULL;
    char *sdlDisplay = NULL;
    int i = 0;
4702

E
Eric Blake 已提交
4703
    for (i = 0; i < def->ngraphics; i++) {
4704 4705 4706 4707 4708
#if VBOX_API_VERSION < 4000
        IVRDPServer *VRDxServer = NULL;
#else /* VBOX_API_VERSION >= 4000 */
        IVRDEServer *VRDxServer = NULL;
#endif /* VBOX_API_VERSION >= 4000 */
4709

E
Eric Blake 已提交
4710 4711
        if ((def->graphics[i]->type == VIR_DOMAIN_GRAPHICS_TYPE_RDP) &&
            (vrdpPresent == 0)) {
4712

E
Eric Blake 已提交
4713
            vrdpPresent = 1;
4714 4715 4716 4717 4718 4719
#if VBOX_API_VERSION < 4000
            machine->vtbl->GetVRDPServer(machine, &VRDxServer);
#else /* VBOX_API_VERSION >= 4000 */
            machine->vtbl->GetVRDEServer(machine, &VRDxServer);
#endif /* VBOX_API_VERSION >= 4000 */
            if (VRDxServer) {
4720 4721 4722
                const char *listenAddr
                    = virDomainGraphicsListenGetAddress(def->graphics[i], 0);

4723
                VRDxServer->vtbl->SetEnabled(VRDxServer, PR_TRUE);
4724
                VIR_DEBUG("VRDP Support turned ON.");
4725 4726

#if VBOX_API_VERSION < 3001
E
Eric Blake 已提交
4727
                if (def->graphics[i]->data.rdp.port) {
4728
                    VRDxServer->vtbl->SetPort(VRDxServer,
E
Eric Blake 已提交
4729
                                              def->graphics[i]->data.rdp.port);
4730
                    VIR_DEBUG("VRDP Port changed to: %d",
E
Eric Blake 已提交
4731 4732 4733 4734 4735
                          def->graphics[i]->data.rdp.port);
                } else if (def->graphics[i]->data.rdp.autoport) {
                    /* Setting the port to 0 will reset its value to
                     * the default one which is 3389 currently
                     */
4736
                    VRDxServer->vtbl->SetPort(VRDxServer, 0);
4737
                    VIR_DEBUG("VRDP Port changed to default, which is 3389 currently");
E
Eric Blake 已提交
4738
                }
4739
#elif VBOX_API_VERSION < 4000 /* 3001 <= VBOX_API_VERSION < 4000 */
E
Eric Blake 已提交
4740 4741
                PRUnichar *portUtf16 = NULL;
                portUtf16 = PRUnicharFromInt(def->graphics[i]->data.rdp.port);
4742
                VRDxServer->vtbl->SetPorts(VRDxServer, portUtf16);
E
Eric Blake 已提交
4743
                VBOX_UTF16_FREE(portUtf16);
4744 4745 4746 4747 4748 4749 4750 4751 4752 4753
#else /* VBOX_API_VERSION >= 4000 */
                PRUnichar *VRDEPortsKey = NULL;
                PRUnichar *VRDEPortsValue = NULL;
                VBOX_UTF8_TO_UTF16("TCP/Ports", &VRDEPortsKey);
                VRDEPortsValue = PRUnicharFromInt(def->graphics[i]->data.rdp.port);
                VRDxServer->vtbl->SetVRDEProperty(VRDxServer, VRDEPortsKey,
                                                  VRDEPortsValue);
                VBOX_UTF16_FREE(VRDEPortsKey);
                VBOX_UTF16_FREE(VRDEPortsValue);
#endif /* VBOX_API_VERSION >= 4000 */
4754

E
Eric Blake 已提交
4755
                if (def->graphics[i]->data.rdp.replaceUser) {
4756
                    VRDxServer->vtbl->SetReuseSingleConnection(VRDxServer,
E
Eric Blake 已提交
4757
                                                               PR_TRUE);
4758
                    VIR_DEBUG("VRDP set to reuse single connection");
E
Eric Blake 已提交
4759
                }
4760

E
Eric Blake 已提交
4761
                if (def->graphics[i]->data.rdp.multiUser) {
4762
                    VRDxServer->vtbl->SetAllowMultiConnection(VRDxServer,
E
Eric Blake 已提交
4763
                                                              PR_TRUE);
4764
                    VIR_DEBUG("VRDP set to allow multiple connection");
E
Eric Blake 已提交
4765
                }
4766

4767
                if (listenAddr) {
4768 4769 4770
#if VBOX_API_VERSION >= 4000
                    PRUnichar *netAddressKey = NULL;
#endif
E
Eric Blake 已提交
4771
                    PRUnichar *netAddressUtf16 = NULL;
4772

4773
                    VBOX_UTF8_TO_UTF16(listenAddr, &netAddressUtf16);
4774 4775
#if VBOX_API_VERSION < 4000
                    VRDxServer->vtbl->SetNetAddress(VRDxServer,
E
Eric Blake 已提交
4776
                                                    netAddressUtf16);
4777 4778 4779 4780 4781 4782
#else /* VBOX_API_VERSION >= 4000 */
                    VBOX_UTF8_TO_UTF16("TCP/Address", &netAddressKey);
                    VRDxServer->vtbl->SetVRDEProperty(VRDxServer, netAddressKey,
                                                      netAddressUtf16);
                    VBOX_UTF16_FREE(netAddressKey);
#endif /* VBOX_API_VERSION >= 4000 */
4783
                    VIR_DEBUG("VRDP listen address is set to: %s",
4784
                              listenAddr);
4785

E
Eric Blake 已提交
4786
                    VBOX_UTF16_FREE(netAddressUtf16);
4787
                }
E
Eric Blake 已提交
4788

4789
                VBOX_RELEASE(VRDxServer);
4790
            }
E
Eric Blake 已提交
4791
        }
4792

E
Eric Blake 已提交
4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803
        if ((def->graphics[i]->type == VIR_DOMAIN_GRAPHICS_TYPE_DESKTOP) &&
            (guiPresent == 0)) {
            guiPresent = 1;
            if (def->graphics[i]->data.desktop.display) {
                guiDisplay = strdup(def->graphics[i]->data.desktop.display);
                if (guiDisplay == NULL) {
                    virReportOOMError();
                    /* just don't go to cleanup yet as it is ok to have
                     * guiDisplay as NULL and we check it below if it
                     * exist and then only use it there
                     */
4804
                }
4805
            }
E
Eric Blake 已提交
4806
        }
4807

E
Eric Blake 已提交
4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818
        if ((def->graphics[i]->type == VIR_DOMAIN_GRAPHICS_TYPE_SDL) &&
            (sdlPresent == 0)) {
            sdlPresent = 1;
            if (def->graphics[i]->data.sdl.display) {
                sdlDisplay = strdup(def->graphics[i]->data.sdl.display);
                if (sdlDisplay == NULL) {
                    virReportOOMError();
                    /* just don't go to cleanup yet as it is ok to have
                     * sdlDisplay as NULL and we check it below if it
                     * exist and then only use it there
                     */
4819
                }
4820
            }
4821
        }
E
Eric Blake 已提交
4822
    }
4823

E
Eric Blake 已提交
4824 4825 4826 4827
    if ((vrdpPresent == 1) && (guiPresent == 0) && (sdlPresent == 0)) {
        /* store extradata key that frontend is set to vrdp */
        PRUnichar *keyTypeUtf16   = NULL;
        PRUnichar *valueTypeUtf16 = NULL;
4828

E
Eric Blake 已提交
4829 4830
        VBOX_UTF8_TO_UTF16("FRONTEND/Type", &keyTypeUtf16);
        VBOX_UTF8_TO_UTF16("vrdp", &valueTypeUtf16);
4831

E
Eric Blake 已提交
4832
        machine->vtbl->SetExtraData(machine, keyTypeUtf16, valueTypeUtf16);
4833

E
Eric Blake 已提交
4834 4835
        VBOX_UTF16_FREE(keyTypeUtf16);
        VBOX_UTF16_FREE(valueTypeUtf16);
4836

E
Eric Blake 已提交
4837 4838 4839 4840 4841 4842
    } else if ((guiPresent == 0) && (sdlPresent == 1)) {
        /* store extradata key that frontend is set to sdl */
        PRUnichar *keyTypeUtf16      = NULL;
        PRUnichar *valueTypeUtf16    = NULL;
        PRUnichar *keyDislpayUtf16   = NULL;
        PRUnichar *valueDisplayUtf16 = NULL;
4843

E
Eric Blake 已提交
4844 4845
        VBOX_UTF8_TO_UTF16("FRONTEND/Type", &keyTypeUtf16);
        VBOX_UTF8_TO_UTF16("sdl", &valueTypeUtf16);
4846

E
Eric Blake 已提交
4847
        machine->vtbl->SetExtraData(machine, keyTypeUtf16, valueTypeUtf16);
4848

E
Eric Blake 已提交
4849 4850
        VBOX_UTF16_FREE(keyTypeUtf16);
        VBOX_UTF16_FREE(valueTypeUtf16);
4851

E
Eric Blake 已提交
4852 4853 4854
        if (sdlDisplay) {
            VBOX_UTF8_TO_UTF16("FRONTEND/Display", &keyDislpayUtf16);
            VBOX_UTF8_TO_UTF16(sdlDisplay, &valueDisplayUtf16);
4855

E
Eric Blake 已提交
4856 4857
            machine->vtbl->SetExtraData(machine, keyDislpayUtf16,
                                        valueDisplayUtf16);
4858

E
Eric Blake 已提交
4859 4860 4861
            VBOX_UTF16_FREE(keyDislpayUtf16);
            VBOX_UTF16_FREE(valueDisplayUtf16);
        }
4862

E
Eric Blake 已提交
4863 4864 4865 4866 4867 4868
    } else {
        /* if all are set then default is gui, with vrdp turned on */
        PRUnichar *keyTypeUtf16      = NULL;
        PRUnichar *valueTypeUtf16    = NULL;
        PRUnichar *keyDislpayUtf16   = NULL;
        PRUnichar *valueDisplayUtf16 = NULL;
4869

E
Eric Blake 已提交
4870 4871
        VBOX_UTF8_TO_UTF16("FRONTEND/Type", &keyTypeUtf16);
        VBOX_UTF8_TO_UTF16("gui", &valueTypeUtf16);
4872

E
Eric Blake 已提交
4873
        machine->vtbl->SetExtraData(machine, keyTypeUtf16, valueTypeUtf16);
4874

E
Eric Blake 已提交
4875 4876
        VBOX_UTF16_FREE(keyTypeUtf16);
        VBOX_UTF16_FREE(valueTypeUtf16);
4877

E
Eric Blake 已提交
4878 4879 4880
        if (guiDisplay) {
            VBOX_UTF8_TO_UTF16("FRONTEND/Display", &keyDislpayUtf16);
            VBOX_UTF8_TO_UTF16(guiDisplay, &valueDisplayUtf16);
4881

E
Eric Blake 已提交
4882 4883
            machine->vtbl->SetExtraData(machine, keyDislpayUtf16,
                                        valueDisplayUtf16);
4884

E
Eric Blake 已提交
4885 4886
            VBOX_UTF16_FREE(keyDislpayUtf16);
            VBOX_UTF16_FREE(valueDisplayUtf16);
4887
        }
E
Eric Blake 已提交
4888
    }
4889

E
Eric Blake 已提交
4890 4891 4892
    VIR_FREE(guiDisplay);
    VIR_FREE(sdlDisplay);
}
4893

E
Eric Blake 已提交
4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915
static void
vboxAttachUSB(virDomainDefPtr def, vboxGlobalData *data, IMachine *machine)
{
    IUSBController *USBController = NULL;
    int i = 0;
    bool isUSB = false;

    if (def->nhostdevs == 0)
        return;

    /* Loop through the devices first and see if you
     * have a USB Device, only if you have one then
     * start the USB controller else just proceed as
     * usual
     */
    for (i = 0; i < def->nhostdevs; i++) {
        if (def->hostdevs[i]->mode ==
            VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
            if (def->hostdevs[i]->source.subsys.type ==
                VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) {
                if (def->hostdevs[i]->source.subsys.u.usb.vendor ||
                    def->hostdevs[i]->source.subsys.u.usb.product) {
4916
                    VIR_DEBUG("USB Device detected, VendorId:0x%x, ProductId:0x%x",
E
Eric Blake 已提交
4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933
                          def->hostdevs[i]->source.subsys.u.usb.vendor,
                          def->hostdevs[i]->source.subsys.u.usb.product);
                    isUSB = true;
                    break;
                }
            }
        }
    }

    if (isUSB) {
        /* First Start the USB Controller and then loop
         * to attach USB Devices to it
         */
        machine->vtbl->GetUSBController(machine, &USBController);
        if (USBController) {
            USBController->vtbl->SetEnabled(USBController, 1);
            USBController->vtbl->SetEnabledEhci(USBController, 1);
4934

4935 4936
            for (i = 0; i < def->nhostdevs; i++) {
                if (def->hostdevs[i]->mode ==
E
Eric Blake 已提交
4937
                    VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
4938
                    if (def->hostdevs[i]->source.subsys.type ==
E
Eric Blake 已提交
4939
                        VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) {
4940

E
Eric Blake 已提交
4941
                        char *filtername           = NULL;
E
Eric Blake 已提交
4942 4943
                        PRUnichar *filternameUtf16 = NULL;
                        IUSBDeviceFilter *filter   = NULL;
4944

E
Eric Blake 已提交
4945 4946
                        /* Zero pad for nice alignment when fewer than 9999
                         * devices.
E
Eric Blake 已提交
4947
                         */
E
Eric Blake 已提交
4948 4949 4950 4951 4952 4953 4954 4955 4956
                        if (virAsprintf(&filtername, "filter%04d", i) < 0) {
                            virReportOOMError();
                        } else {
                            VBOX_UTF8_TO_UTF16(filtername, &filternameUtf16);
                            VIR_FREE(filtername);
                            USBController->vtbl->CreateDeviceFilter(USBController,
                                                                    filternameUtf16,
                                                                    &filter);
                        }
E
Eric Blake 已提交
4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968
                        VBOX_UTF16_FREE(filternameUtf16);

                        if (filter &&
                            (def->hostdevs[i]->source.subsys.u.usb.vendor ||
                             def->hostdevs[i]->source.subsys.u.usb.product)) {

                            PRUnichar *vendorIdUtf16  = NULL;
                            char vendorId[40]         = {0};
                            PRUnichar *productIdUtf16 = NULL;
                            char productId[40]        = {0};

                            if (def->hostdevs[i]->source.subsys.u.usb.vendor) {
E
Eric Blake 已提交
4969 4970
                                snprintf(vendorId, sizeof(vendorId), "%x",
                                         def->hostdevs[i]->source.subsys.u.usb.vendor);
E
Eric Blake 已提交
4971 4972 4973 4974 4975
                                VBOX_UTF8_TO_UTF16(vendorId, &vendorIdUtf16);
                                filter->vtbl->SetVendorId(filter, vendorIdUtf16);
                                VBOX_UTF16_FREE(vendorIdUtf16);
                            }
                            if (def->hostdevs[i]->source.subsys.u.usb.product) {
E
Eric Blake 已提交
4976 4977
                                snprintf(productId, sizeof(productId), "%x",
                                         def->hostdevs[i]->source.subsys.u.usb.product);
E
Eric Blake 已提交
4978 4979 4980 4981
                                VBOX_UTF8_TO_UTF16(productId, &productIdUtf16);
                                filter->vtbl->SetProductId(filter,
                                                           productIdUtf16);
                                VBOX_UTF16_FREE(productIdUtf16);
4982
                            }
E
Eric Blake 已提交
4983 4984 4985 4986 4987
                            filter->vtbl->SetActive(filter, 1);
                            USBController->vtbl->InsertDeviceFilter(USBController,
                                                                    i,
                                                                    filter);
                            VBOX_RELEASE(filter);
4988
                        }
E
Eric Blake 已提交
4989

4990 4991 4992
                    }
                }
            }
E
Eric Blake 已提交
4993 4994 4995 4996 4997
            VBOX_RELEASE(USBController);
        }
    }
}

M
Matthias Bolte 已提交
4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029
static void
vboxAttachSharedFolder(virDomainDefPtr def, vboxGlobalData *data, IMachine *machine)
{
    int i;
    PRUnichar *nameUtf16;
    PRUnichar *hostPathUtf16;
    PRBool writable;

    if (def->nfss == 0)
        return;

    for (i = 0; i < def->nfss; i++) {
        if (def->fss[i]->type != VIR_DOMAIN_FS_TYPE_MOUNT)
            continue;

        VBOX_UTF8_TO_UTF16(def->fss[i]->dst, &nameUtf16);
        VBOX_UTF8_TO_UTF16(def->fss[i]->src, &hostPathUtf16);
        writable = !def->fss[i]->readonly;

#if VBOX_API_VERSION < 4000
        machine->vtbl->CreateSharedFolder(machine, nameUtf16, hostPathUtf16,
                                          writable);
#else /* VBOX_API_VERSION >= 4000 */
        machine->vtbl->CreateSharedFolder(machine, nameUtf16, hostPathUtf16,
                                          writable, PR_FALSE);
#endif /* VBOX_API_VERSION >= 4000 */

        VBOX_UTF16_FREE(nameUtf16);
        VBOX_UTF16_FREE(hostPathUtf16);
    }
}

E
Eric Blake 已提交
5030 5031 5032 5033
static virDomainPtr vboxDomainDefineXML(virConnectPtr conn, const char *xml) {
    VBOX_OBJECT_CHECK(conn, virDomainPtr, NULL);
    IMachine       *machine     = NULL;
    IBIOSSettings  *bios        = NULL;
5034 5035
    vboxIID iid = VBOX_IID_INITIALIZER;
    vboxIID mchiid = VBOX_IID_INITIALIZER;
E
Eric Blake 已提交
5036 5037 5038 5039 5040 5041 5042 5043
    virDomainDefPtr def         = NULL;
    PRUnichar *machineNameUtf16 = NULL;
#if VBOX_API_VERSION >= 3002
    PRBool override             = PR_FALSE;
#endif
    nsresult rc;

    if (!(def = virDomainDefParseString(data->caps, xml,
M
Matthias Bolte 已提交
5044
                                        1 << VIR_DOMAIN_VIRT_VBOX,
E
Eric Blake 已提交
5045 5046 5047 5048 5049
                                        VIR_DOMAIN_XML_INACTIVE))) {
        goto cleanup;
    }

    VBOX_UTF8_TO_UTF16(def->name, &machineNameUtf16);
5050
    vboxIIDFromUUID(&iid, def->uuid);
E
Eric Blake 已提交
5051 5052 5053 5054 5055
#if VBOX_API_VERSION < 3002
    rc = data->vboxObj->vtbl->CreateMachine(data->vboxObj,
                                            machineNameUtf16,
                                            NULL,
                                            NULL,
5056
                                            iid.value,
E
Eric Blake 已提交
5057
                                            &machine);
5058
#elif VBOX_API_VERSION < 4000 /* 3002 <= VBOX_API_VERSION < 4000 */
E
Eric Blake 已提交
5059 5060 5061 5062
    rc = data->vboxObj->vtbl->CreateMachine(data->vboxObj,
                                            machineNameUtf16,
                                            NULL,
                                            NULL,
5063
                                            iid.value,
E
Eric Blake 已提交
5064 5065
                                            override,
                                            &machine);
5066 5067 5068 5069 5070 5071 5072 5073 5074
#else /* VBOX_API_VERSION >= 4000 */
    rc = data->vboxObj->vtbl->CreateMachine(data->vboxObj,
                                            NULL,
                                            machineNameUtf16,
                                            NULL,
                                            iid.value,
                                            override,
                                            &machine);
#endif /* VBOX_API_VERSION >= 4000 */
E
Eric Blake 已提交
5075 5076 5077
    VBOX_UTF16_FREE(machineNameUtf16);

    if (NS_FAILED(rc)) {
5078 5079
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not define a domain, rc=%08x"), (unsigned)rc);
E
Eric Blake 已提交
5080 5081 5082
        goto cleanup;
    }

5083 5084
    rc = machine->vtbl->SetMemorySize(machine,
                                      VIR_DIV_UP(def->mem.cur_balloon, 1024));
E
Eric Blake 已提交
5085
    if (NS_FAILED(rc)) {
5086 5087 5088 5089
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not set the memory size of the domain to: %llu Kb, "
                         "rc=%08x"),
                       def->mem.cur_balloon, (unsigned)rc);
E
Eric Blake 已提交
5090 5091
    }

E
Eric Blake 已提交
5092
    if (def->vcpus != def->maxvcpus) {
5093 5094
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("current vcpu count must equal maximum"));
E
Eric Blake 已提交
5095 5096
    }
    rc = machine->vtbl->SetCPUCount(machine, def->maxvcpus);
E
Eric Blake 已提交
5097
    if (NS_FAILED(rc)) {
5098 5099 5100
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not set the number of virtual CPUs to: %u, rc=%08x"),
                       def->maxvcpus, (unsigned)rc);
E
Eric Blake 已提交
5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115
    }

#if VBOX_API_VERSION < 3001
    rc = machine->vtbl->SetPAEEnabled(machine, (def->features) &
                                      (1 << VIR_DOMAIN_FEATURE_PAE));
#elif VBOX_API_VERSION == 3001
    rc = machine->vtbl->SetCpuProperty(machine, CpuPropertyType_PAE,
                                       (def->features) &
                                       (1 << VIR_DOMAIN_FEATURE_PAE));
#elif VBOX_API_VERSION >= 3002
    rc = machine->vtbl->SetCPUProperty(machine, CPUPropertyType_PAE,
                                       (def->features) &
                                       (1 << VIR_DOMAIN_FEATURE_PAE));
#endif
    if (NS_FAILED(rc)) {
5116 5117 5118 5119
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not change PAE status to: %s, rc=%08x"),
                       ((def->features) & (1 << VIR_DOMAIN_FEATURE_PAE))
                       ? _("Enabled") : _("Disabled"), (unsigned)rc);
E
Eric Blake 已提交
5120 5121 5122 5123 5124 5125 5126
    }

    machine->vtbl->GetBIOSSettings(machine, &bios);
    if (bios) {
        rc = bios->vtbl->SetACPIEnabled(bios, (def->features) &
                                        (1 << VIR_DOMAIN_FEATURE_ACPI));
        if (NS_FAILED(rc)) {
5127 5128 5129 5130
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("could not change ACPI status to: %s, rc=%08x"),
                           ((def->features) & (1 << VIR_DOMAIN_FEATURE_ACPI))
                           ? _("Enabled") : _("Disabled"), (unsigned)rc);
E
Eric Blake 已提交
5131 5132 5133 5134
        }
        rc = bios->vtbl->SetIOAPICEnabled(bios, (def->features) &
                                          (1 << VIR_DOMAIN_FEATURE_APIC));
        if (NS_FAILED(rc)) {
5135 5136 5137 5138
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("could not change APIC status to: %s, rc=%08x"),
                           ((def->features) & (1 << VIR_DOMAIN_FEATURE_APIC))
                           ? _("Enabled") : _("Disabled"), (unsigned)rc);
5139
        }
E
Eric Blake 已提交
5140 5141 5142 5143 5144 5145
        VBOX_RELEASE(bios);
    }

    /* Register the machine before attaching other devices to it */
    rc = data->vboxObj->vtbl->RegisterMachine(data->vboxObj, machine);
    if (NS_FAILED(rc)) {
5146 5147
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not define a domain, rc=%08x"), (unsigned)rc);
E
Eric Blake 已提交
5148 5149 5150 5151 5152 5153 5154
        goto cleanup;
    }

    /* Get the uuid of the machine, currently it is immutable
     * object so open a session to it and get it back, so that
     * you can make changes to the machine setting
     */
5155
    machine->vtbl->GetId(machine, &mchiid.value);
5156
    VBOX_SESSION_OPEN(mchiid.value, machine);
E
Eric Blake 已提交
5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167
    data->vboxSession->vtbl->GetMachine(data->vboxSession, &machine);

    vboxSetBootDeviceOrder(def, data, machine);
    vboxAttachDrives(def, data, machine);
    vboxAttachSound(def, machine);
    vboxAttachNetwork(def, data, machine);
    vboxAttachSerial(def, data, machine);
    vboxAttachParallel(def, data, machine);
    vboxAttachVideo(def, machine);
    vboxAttachDisplay(def, data, machine);
    vboxAttachUSB(def, data, machine);
M
Matthias Bolte 已提交
5168
    vboxAttachSharedFolder(def, data, machine);
5169

5170 5171 5172 5173
    /* Save the machine settings made till now and close the
     * session. also free up the mchiid variable used.
     */
    rc = machine->vtbl->SaveSettings(machine);
5174
    VBOX_SESSION_CLOSE();
5175
    vboxIIDUnalloc(&mchiid);
5176

5177 5178
    ret = virGetDomain(conn, def->name, def->uuid);
    VBOX_RELEASE(machine);
5179

5180
    vboxIIDUnalloc(&iid);
5181 5182
    virDomainDefFree(def);

5183
    return ret;
5184 5185

cleanup:
5186
    VBOX_RELEASE(machine);
5187
    vboxIIDUnalloc(&iid);
5188 5189 5190 5191
    virDomainDefFree(def);
    return NULL;
}

5192
static int
5193
vboxDomainUndefineFlags(virDomainPtr dom, unsigned int flags)
5194
{
5195
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
5196
    IMachine *machine    = NULL;
5197
    vboxIID iid = VBOX_IID_INITIALIZER;
5198
    nsresult rc;
5199 5200 5201
#if VBOX_API_VERSION >= 4000
    vboxArray media = VBOX_ARRAY_INITIALIZER;
#endif
5202 5203 5204 5205
    /* No managed save, so we explicitly reject
     * VIR_DOMAIN_UNDEFINE_MANAGED_SAVE.  No snapshot metadata for
     * VBox, so we can trivially ignore that flag.  */
    virCheckFlags(VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA, -1);
5206

5207
    vboxIIDFromUUID(&iid, dom->uuid);
5208

5209
#if VBOX_API_VERSION < 4000
5210 5211 5212
    /* Block for checking if HDD's are attched to VM.
     * considering just IDE bus for now. Also skipped
     * chanel=1 and device=0 (Secondary Master) as currenlty
5213 5214 5215 5216
     * it is allocated to CD/DVD Drive by default.
     *
     * Only do this for VirtualBox 3.x and before. Since
     * VirtualBox 4.0 the Unregister method can do this for use.
5217 5218 5219
     */
    {
        PRUnichar *hddcnameUtf16 = NULL;
5220

5221 5222 5223
        char *hddcname = strdup("IDE");
        VBOX_UTF8_TO_UTF16(hddcname, &hddcnameUtf16);
        VIR_FREE(hddcname);
5224

5225
        /* Open a Session for the machine */
5226
        rc = VBOX_SESSION_OPEN(iid.value, machine);
5227 5228 5229 5230
        if (NS_SUCCEEDED(rc)) {
            rc = data->vboxSession->vtbl->GetMachine(data->vboxSession, &machine);
            if (NS_SUCCEEDED(rc) && machine) {

5231
# if VBOX_API_VERSION < 3001
5232 5233 5234 5235
                /* Disconnect all the drives if present */
                machine->vtbl->DetachHardDisk(machine, hddcnameUtf16, 0, 0);
                machine->vtbl->DetachHardDisk(machine, hddcnameUtf16, 0, 1);
                machine->vtbl->DetachHardDisk(machine, hddcnameUtf16, 1, 1);
5236
# else  /* VBOX_API_VERSION >= 3001 */
5237 5238 5239
                /* get all the controller first, then the attachments and
                 * remove them all so that the machine can be undefined
                 */
5240
                vboxArray storageControllers = VBOX_ARRAY_INITIALIZER;
5241 5242
                int i = 0, j = 0;

5243 5244
                vboxArrayGet(&storageControllers, machine,
                             machine->vtbl->GetStorageControllers);
5245

5246 5247
                for (i = 0; i < storageControllers.count; i++) {
                    IStorageController *strCtl = storageControllers.items[i];
5248
                    PRUnichar *strCtlName = NULL;
5249
                    vboxArray mediumAttachments = VBOX_ARRAY_INITIALIZER;
5250 5251 5252 5253 5254

                    if (!strCtl)
                        continue;

                    strCtl->vtbl->GetName(strCtl, &strCtlName);
5255 5256 5257
                    vboxArrayGetWithPtrArg(&mediumAttachments, machine,
                                           machine->vtbl->GetMediumAttachmentsOfController,
                                           strCtlName);
5258

5259 5260
                    for (j = 0; j < mediumAttachments.count; j++) {
                        IMediumAttachment *medAtt = mediumAttachments.items[j];
5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276
                        PRInt32 port = ~0U;
                        PRInt32 device = ~0U;

                        if (!medAtt)
                            continue;

                        medAtt->vtbl->GetPort(medAtt, &port);
                        medAtt->vtbl->GetDevice(medAtt, &device);

                        if ((port != ~0U) && (device != ~0U)) {
                            machine->vtbl->DetachDevice(machine,
                                                        strCtlName,
                                                        port,
                                                        device);
                        }
                    }
5277

5278 5279
                    vboxArrayRelease(&storageControllers);

5280 5281
                    machine->vtbl->RemoveStorageController(machine, strCtlName);
                    VBOX_UTF16_FREE(strCtlName);
5282
                }
5283 5284

                vboxArrayRelease(&storageControllers);
5285
# endif /* VBOX_API_VERSION >= 3001 */
5286 5287

                machine->vtbl->SaveSettings(machine);
5288
            }
5289
            VBOX_SESSION_CLOSE();
5290
        }
5291 5292
        VBOX_UTF16_FREE(hddcnameUtf16);
    }
5293
#endif
5294

5295
#if VBOX_API_VERSION < 4000
5296
    rc = data->vboxObj->vtbl->UnregisterMachine(data->vboxObj, iid.value, &machine);
5297 5298 5299
#else /* VBOX_API_VERSION >= 4000 */
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
    if (NS_FAILED(rc)) {
5300 5301
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching uuid"));
5302 5303 5304 5305 5306 5307 5308 5309 5310 5311
        return -1;
    }

    /* We're not interested in the array returned by the Unregister method,
     * but in the side effect of unregistering the virtual machine. In order
     * to call the Unregister method correctly we need to use the vboxArray
     * wrapper here. */
    rc = vboxArrayGetWithUintArg(&media, machine, machine->vtbl->Unregister,
                                 CleanupMode_DetachAllReturnNone);
#endif /* VBOX_API_VERSION >= 4000 */
5312
    DEBUGIID("UUID of machine being undefined", iid.value);
5313

5314 5315
    if (NS_SUCCEEDED(rc)) {
#if VBOX_API_VERSION < 4000
5316
        machine->vtbl->DeleteSettings(machine);
5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332
#else /* VBOX_API_VERSION >= 4000 */
        IProgress *progress = NULL;

        /* The IMachine Delete method takes an array of IMedium items to be
         * deleted along with the virtual machine. We just want to pass an
         * empty array. But instead of adding a full vboxArraySetWithReturn to
         * the glue layer (in order to handle the required signature of the
         * Delete method) we use a local solution here. */
# ifdef WIN32
        SAFEARRAY *safeArray = NULL;
        typedef HRESULT __stdcall (*IMachine_Delete)(IMachine *self,
                                                     SAFEARRAY **media,
                                                     IProgress **progress);

        ((IMachine_Delete)machine->vtbl->Delete)(machine, &safeArray, &progress);
# else
5333 5334 5335 5336
        /* XPCOM doesn't like NULL as an array, even when the array size is 0.
         * Instead pass it a dummy array to avoid passing NULL. */
        IMedium *array[] = { NULL };
        machine->vtbl->Delete(machine, 0, array, &progress);
5337 5338 5339 5340 5341 5342
# endif
        if (progress != NULL) {
            progress->vtbl->WaitForCompletion(progress, -1);
            VBOX_RELEASE(progress);
        }
#endif /* VBOX_API_VERSION >= 4000 */
5343 5344
        ret = 0;
    } else {
5345 5346
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not delete the domain, rc=%08x"), (unsigned)rc);
5347 5348
    }

5349 5350 5351
#if VBOX_API_VERSION >= 4000
    vboxArrayUnalloc(&media);
#endif
5352
    vboxIIDUnalloc(&iid);
5353
    VBOX_RELEASE(machine);
5354 5355 5356 5357

    return ret;
}

5358 5359 5360 5361 5362 5363
static int
vboxDomainUndefine(virDomainPtr dom)
{
    return vboxDomainUndefineFlags(dom, 0);
}

5364 5365 5366
static int vboxDomainAttachDeviceImpl(virDomainPtr dom,
                                      const char *xml,
                                      int mediaChangeOnly ATTRIBUTE_UNUSED) {
5367
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
5368
    IMachine *machine    = NULL;
5369
    vboxIID iid = VBOX_IID_INITIALIZER;
5370 5371 5372
    PRUint32 state       = MachineState_Null;
    virDomainDefPtr def  = NULL;
    virDomainDeviceDefPtr dev  = NULL;
5373
    nsresult rc;
5374 5375

    if (VIR_ALLOC(def) < 0) {
5376
        virReportOOMError();
5377 5378 5379 5380 5381
        return ret;
    }

    def->os.type = strdup("hvm");

5382
    if (def->os.type == NULL) {
5383
        virReportOOMError();
5384 5385 5386
        goto cleanup;
    }

5387
    dev = virDomainDeviceDefParse(data->caps, def, xml,
5388 5389
                                  VIR_DOMAIN_XML_INACTIVE);
    if (dev == NULL) {
5390
        virReportOOMError();
5391 5392 5393
        goto cleanup;
    }

5394
    vboxIIDFromUUID(&iid, dom->uuid);
5395
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
5396
    if (NS_FAILED(rc)) {
5397 5398
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching uuid"));
5399 5400
        goto cleanup;
    }
5401

5402 5403
    if (machine) {
        machine->vtbl->GetState(machine, &state);
5404

5405 5406
        if ((state == MachineState_Running) ||
            (state == MachineState_Paused)) {
5407
            rc = VBOX_SESSION_OPEN_EXISTING(iid.value, machine);
5408
        } else {
5409
            rc = VBOX_SESSION_OPEN(iid.value, machine);
5410 5411 5412 5413 5414 5415 5416
        }
        if (NS_SUCCEEDED(rc)) {
            rc = data->vboxSession->vtbl->GetMachine(data->vboxSession, &machine);
            if (NS_SUCCEEDED(rc) && machine) {
                if (dev->type == VIR_DOMAIN_DEVICE_DISK) {
#if VBOX_API_VERSION < 3001
                    if (dev->data.disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) {
5417 5418
                        if (dev->data.disk->type == VIR_DOMAIN_DISK_TYPE_FILE &&
                            dev->data.disk->src != NULL) {
5419 5420 5421 5422 5423 5424 5425 5426 5427
                            IDVDDrive *dvdDrive = NULL;
                            /* Currently CDROM/DVD Drive is always IDE
                             * Secondary Master so neglecting the following
                             * parameter dev->data.disk->bus
                             */
                            machine->vtbl->GetDVDDrive(machine, &dvdDrive);
                            if (dvdDrive) {
                                IDVDImage *dvdImage          = NULL;
                                PRUnichar *dvdfileUtf16      = NULL;
5428 5429
                                vboxIID dvduuid = VBOX_IID_INITIALIZER;
                                vboxIID dvdemptyuuid = VBOX_IID_INITIALIZER;
5430

5431
                                VBOX_UTF8_TO_UTF16(dev->data.disk->src, &dvdfileUtf16);
5432

5433 5434
                                data->vboxObj->vtbl->FindDVDImage(data->vboxObj, dvdfileUtf16, &dvdImage);
                                if (!dvdImage) {
5435
                                    data->vboxObj->vtbl->OpenDVDImage(data->vboxObj, dvdfileUtf16, dvdemptyuuid.value, &dvdImage);
5436 5437
                                }
                                if (dvdImage) {
5438
                                    rc = dvdImage->vtbl->imedium.GetId((IMedium *)dvdImage, &dvduuid.value);
5439
                                    if (NS_FAILED(rc)) {
5440 5441 5442 5443
                                        virReportError(VIR_ERR_INTERNAL_ERROR,
                                                       _("can't get the uuid of the file to "
                                                         "be attached to cdrom: %s, rc=%08x"),
                                                       dev->data.disk->src, (unsigned)rc);
5444 5445 5446
                                    } else {
                                        /* unmount the previous mounted image */
                                        dvdDrive->vtbl->Unmount(dvdDrive);
5447
                                        rc = dvdDrive->vtbl->MountImage(dvdDrive, dvduuid.value);
5448
                                        if (NS_FAILED(rc)) {
5449 5450 5451
                                            virReportError(VIR_ERR_INTERNAL_ERROR,
                                                           _("could not attach the file to cdrom: %s, rc=%08x"),
                                                           dev->data.disk->src, (unsigned)rc);
5452
                                        } else {
5453
                                            ret = 0;
5454
                                            DEBUGIID("CD/DVD Image UUID:", dvduuid.value);
5455 5456
                                        }
                                    }
5457 5458

                                    VBOX_MEDIUM_RELEASE(dvdImage);
5459
                                }
5460
                                vboxIIDUnalloc(&dvduuid);
5461 5462
                                VBOX_UTF16_FREE(dvdfileUtf16);
                                VBOX_RELEASE(dvdDrive);
5463
                            }
5464 5465 5466
                        } else if (dev->data.disk->type == VIR_DOMAIN_DISK_TYPE_BLOCK) {
                        }
                    } else if (dev->data.disk->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY) {
5467 5468
                        if (dev->data.disk->type == VIR_DOMAIN_DISK_TYPE_FILE &&
                            dev->data.disk->src != NULL) {
5469 5470 5471 5472 5473 5474 5475
                            IFloppyDrive *floppyDrive;
                            machine->vtbl->GetFloppyDrive(machine, &floppyDrive);
                            if (floppyDrive) {
                                rc = floppyDrive->vtbl->SetEnabled(floppyDrive, 1);
                                if (NS_SUCCEEDED(rc)) {
                                    IFloppyImage *floppyImage   = NULL;
                                    PRUnichar *fdfileUtf16      = NULL;
5476 5477
                                    vboxIID fduuid = VBOX_IID_INITIALIZER;
                                    vboxIID fdemptyuuid = VBOX_IID_INITIALIZER;
5478 5479 5480 5481 5482 5483 5484 5485
                                    VBOX_UTF8_TO_UTF16(dev->data.disk->src, &fdfileUtf16);
                                    rc = data->vboxObj->vtbl->FindFloppyImage(data->vboxObj,
                                                                              fdfileUtf16,
                                                                              &floppyImage);

                                    if (!floppyImage) {
                                        data->vboxObj->vtbl->OpenFloppyImage(data->vboxObj,
                                                                             fdfileUtf16,
5486
                                                                             fdemptyuuid.value,
5487 5488
                                                                             &floppyImage);
                                    }
5489

5490
                                    if (floppyImage) {
5491
                                        rc = floppyImage->vtbl->imedium.GetId((IMedium *)floppyImage, &fduuid.value);
5492
                                        if (NS_FAILED(rc)) {
5493 5494 5495 5496
                                            virReportError(VIR_ERR_INTERNAL_ERROR,
                                                           _("can't get the uuid of the file to be "
                                                             "attached to floppy drive: %s, rc=%08x"),
                                                           dev->data.disk->src, (unsigned)rc);
5497
                                        } else {
5498
                                            rc = floppyDrive->vtbl->MountImage(floppyDrive, fduuid.value);
5499
                                            if (NS_FAILED(rc)) {
5500 5501 5502
                                                virReportError(VIR_ERR_INTERNAL_ERROR,
                                                               _("could not attach the file to floppy drive: %s, rc=%08x"),
                                                               dev->data.disk->src, (unsigned)rc);
5503
                                            } else {
5504
                                                ret = 0;
5505
                                                DEBUGIID("attached floppy, UUID:", fduuid.value);
5506 5507
                                            }
                                        }
5508
                                        VBOX_MEDIUM_RELEASE(floppyImage);
5509
                                    }
5510
                                    vboxIIDUnalloc(&fduuid);
5511
                                    VBOX_UTF16_FREE(fdfileUtf16);
5512
                                }
5513
                                VBOX_RELEASE(floppyDrive);
5514
                            }
5515
                        } else if (dev->data.disk->type == VIR_DOMAIN_DISK_TYPE_BLOCK) {
5516
                        }
5517 5518 5519 5520 5521 5522 5523
                    }
#else  /* VBOX_API_VERSION >= 3001 */
#endif /* VBOX_API_VERSION >= 3001 */
                } else if (dev->type == VIR_DOMAIN_DEVICE_NET) {
                } else if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV) {
                    if (dev->data.hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
                        if (dev->data.hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) {
5524 5525
                        }
                    }
M
Matthias Bolte 已提交
5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544
                } else if (dev->type == VIR_DOMAIN_DEVICE_FS &&
                           dev->data.fs->type == VIR_DOMAIN_FS_TYPE_MOUNT) {
                    PRUnichar *nameUtf16;
                    PRUnichar *hostPathUtf16;
                    PRBool writable;

                    VBOX_UTF8_TO_UTF16(dev->data.fs->dst, &nameUtf16);
                    VBOX_UTF8_TO_UTF16(dev->data.fs->src, &hostPathUtf16);
                    writable = !dev->data.fs->readonly;

#if VBOX_API_VERSION < 4000
                    rc = machine->vtbl->CreateSharedFolder(machine, nameUtf16, hostPathUtf16,
                                                           writable);
#else /* VBOX_API_VERSION >= 4000 */
                    rc = machine->vtbl->CreateSharedFolder(machine, nameUtf16, hostPathUtf16,
                                                           writable, PR_FALSE);
#endif /* VBOX_API_VERSION >= 4000 */

                    if (NS_FAILED(rc)) {
5545 5546 5547
                        virReportError(VIR_ERR_INTERNAL_ERROR,
                                       _("could not attach shared folder '%s', rc=%08x"),
                                       dev->data.fs->dst, (unsigned)rc);
M
Matthias Bolte 已提交
5548 5549 5550 5551 5552 5553
                    } else {
                        ret = 0;
                    }

                    VBOX_UTF16_FREE(nameUtf16);
                    VBOX_UTF16_FREE(hostPathUtf16);
5554
                }
5555 5556
                machine->vtbl->SaveSettings(machine);
                VBOX_RELEASE(machine);
5557
            }
5558
            VBOX_SESSION_CLOSE();
5559 5560 5561 5562
        }
    }

cleanup:
5563
    vboxIIDUnalloc(&iid);
5564 5565 5566 5567 5568
    virDomainDefFree(def);
    virDomainDeviceDefFree(dev);
    return ret;
}

5569 5570 5571 5572
static int vboxDomainAttachDevice(virDomainPtr dom, const char *xml) {
    return vboxDomainAttachDeviceImpl(dom, xml, 0);
}

5573 5574 5575 5576 5577 5578
static int
vboxDomainAttachDeviceFlags(virDomainPtr dom, const char *xml,
                            unsigned int flags)
{
    virCheckFlags(VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG, -1);

5579
    if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
5580 5581
        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                       _("cannot modify the persistent configuration of a domain"));
5582 5583 5584
        return -1;
    }

5585 5586 5587 5588 5589
    return vboxDomainAttachDeviceImpl(dom, xml, 0);
}

static int vboxDomainUpdateDeviceFlags(virDomainPtr dom, const char *xml,
                                       unsigned int flags) {
5590 5591 5592
    virCheckFlags(VIR_DOMAIN_AFFECT_CURRENT |
                  VIR_DOMAIN_AFFECT_LIVE |
                  VIR_DOMAIN_AFFECT_CONFIG, -1);
5593

5594
    if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
5595 5596
        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                       _("cannot modify the persistent configuration of a domain"));
5597 5598 5599 5600
        return -1;
    }

    return vboxDomainAttachDeviceImpl(dom, xml, 1);
5601 5602
}

5603
static int vboxDomainDetachDevice(virDomainPtr dom, const char *xml) {
5604
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
5605
    IMachine *machine    = NULL;
5606
    vboxIID iid = VBOX_IID_INITIALIZER;
5607 5608 5609
    PRUint32 state       = MachineState_Null;
    virDomainDefPtr def  = NULL;
    virDomainDeviceDefPtr dev  = NULL;
5610
    nsresult rc;
5611 5612

    if (VIR_ALLOC(def) < 0) {
5613
        virReportOOMError();
5614 5615 5616 5617 5618
        return ret;
    }

    def->os.type = strdup("hvm");

5619
    if (def->os.type == NULL) {
5620
        virReportOOMError();
5621 5622 5623
        goto cleanup;
    }

5624
    dev = virDomainDeviceDefParse(data->caps, def, xml,
5625 5626
                                  VIR_DOMAIN_XML_INACTIVE);
    if (dev == NULL) {
5627
        virReportOOMError();
5628 5629 5630
        goto cleanup;
    }

5631
    vboxIIDFromUUID(&iid, dom->uuid);
5632
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
5633
    if (NS_FAILED(rc)) {
5634 5635
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching uuid"));
5636 5637
        goto cleanup;
    }
5638

5639 5640
    if (machine) {
        machine->vtbl->GetState(machine, &state);
5641

5642 5643
        if ((state == MachineState_Running) ||
            (state == MachineState_Paused)) {
5644
            rc = VBOX_SESSION_OPEN_EXISTING(iid.value, machine);
5645
        } else {
5646
            rc = VBOX_SESSION_OPEN(iid.value, machine);
5647
        }
5648

5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664
        if (NS_SUCCEEDED(rc)) {
            rc = data->vboxSession->vtbl->GetMachine(data->vboxSession, &machine);
            if (NS_SUCCEEDED(rc) && machine) {
                if (dev->type == VIR_DOMAIN_DEVICE_DISK) {
#if VBOX_API_VERSION < 3001
                    if (dev->data.disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) {
                        if (dev->data.disk->type == VIR_DOMAIN_DISK_TYPE_FILE) {
                            IDVDDrive *dvdDrive = NULL;
                            /* Currently CDROM/DVD Drive is always IDE
                             * Secondary Master so neglecting the following
                             * parameter dev->data.disk->bus
                             */
                            machine->vtbl->GetDVDDrive(machine, &dvdDrive);
                            if (dvdDrive) {
                                rc = dvdDrive->vtbl->Unmount(dvdDrive);
                                if (NS_FAILED(rc)) {
5665 5666 5667
                                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                                   _("could not de-attach the mounted ISO, rc=%08x"),
                                                   (unsigned)rc);
5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684
                                } else {
                                    ret = 0;
                                }
                                VBOX_RELEASE(dvdDrive);
                            }
                        } else if (dev->data.disk->type == VIR_DOMAIN_DISK_TYPE_BLOCK) {
                        }
                    } else if (dev->data.disk->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY) {
                        if (dev->data.disk->type == VIR_DOMAIN_DISK_TYPE_FILE) {
                            IFloppyDrive *floppyDrive;
                            machine->vtbl->GetFloppyDrive(machine, &floppyDrive);
                            if (floppyDrive) {
                                PRBool enabled = PR_FALSE;

                                floppyDrive->vtbl->GetEnabled(floppyDrive, &enabled);
                                if (enabled) {
                                    rc = floppyDrive->vtbl->Unmount(floppyDrive);
5685
                                    if (NS_FAILED(rc)) {
5686 5687 5688 5689
                                        virReportError(VIR_ERR_INTERNAL_ERROR,
                                                       _("could not attach the file "
                                                         "to floppy drive, rc=%08x"),
                                                       (unsigned)rc);
5690 5691 5692
                                    } else {
                                        ret = 0;
                                    }
5693 5694 5695 5696 5697
                                } else {
                                    /* If you are here means floppy drive is already unmounted
                                     * so don't flag error, just say everything is fine and quit
                                     */
                                    ret = 0;
5698
                                }
5699
                                VBOX_RELEASE(floppyDrive);
5700
                            }
5701
                        } else if (dev->data.disk->type == VIR_DOMAIN_DISK_TYPE_BLOCK) {
5702
                        }
5703 5704 5705 5706 5707 5708 5709
                    }
#else  /* VBOX_API_VERSION >= 3001 */
#endif /* VBOX_API_VERSION >= 3001 */
                } else if (dev->type == VIR_DOMAIN_DEVICE_NET) {
                } else if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV) {
                    if (dev->data.hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
                        if (dev->data.hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) {
5710 5711
                        }
                    }
M
Matthias Bolte 已提交
5712 5713 5714 5715 5716 5717 5718 5719 5720
                } else if (dev->type == VIR_DOMAIN_DEVICE_FS &&
                           dev->data.fs->type == VIR_DOMAIN_FS_TYPE_MOUNT) {
                    PRUnichar *nameUtf16;

                    VBOX_UTF8_TO_UTF16(dev->data.fs->dst, &nameUtf16);

                    rc = machine->vtbl->RemoveSharedFolder(machine, nameUtf16);

                    if (NS_FAILED(rc)) {
5721 5722 5723
                        virReportError(VIR_ERR_INTERNAL_ERROR,
                                       _("could not detach shared folder '%s', rc=%08x"),
                                       dev->data.fs->dst, (unsigned)rc);
M
Matthias Bolte 已提交
5724 5725 5726 5727 5728
                    } else {
                        ret = 0;
                    }

                    VBOX_UTF16_FREE(nameUtf16);
5729
                }
5730 5731
                machine->vtbl->SaveSettings(machine);
                VBOX_RELEASE(machine);
5732
            }
5733
            VBOX_SESSION_CLOSE();
5734 5735 5736 5737
        }
    }

cleanup:
5738
    vboxIIDUnalloc(&iid);
5739 5740 5741 5742 5743
    virDomainDefFree(def);
    virDomainDeviceDefFree(dev);
    return ret;
}

5744 5745 5746 5747 5748 5749
static int
vboxDomainDetachDeviceFlags(virDomainPtr dom, const char *xml,
                            unsigned int flags)
{
    virCheckFlags(VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG, -1);

5750
    if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
5751 5752
        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                       _("cannot modify the persistent configuration of a domain"));
5753 5754 5755 5756 5757 5758
        return -1;
    }

    return vboxDomainDetachDevice(dom, xml);
}

J
Jiri Denemark 已提交
5759 5760 5761 5762 5763
static int
vboxDomainSnapshotGetAll(virDomainPtr dom,
                         IMachine *machine,
                         ISnapshot ***snapshots)
{
5764
    vboxIID empty = VBOX_IID_INITIALIZER;
J
Jiri Denemark 已提交
5765 5766 5767 5768 5769 5770 5771 5772
    ISnapshot **list = NULL;
    PRUint32 count;
    nsresult rc;
    unsigned int next;
    unsigned int top;

    rc = machine->vtbl->GetSnapshotCount(machine, &count);
    if (NS_FAILED(rc)) {
5773 5774 5775
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not get snapshot count for domain %s"),
                       dom->name);
J
Jiri Denemark 已提交
5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786
        goto error;
    }

    if (count == 0)
        goto out;

    if (VIR_ALLOC_N(list, count) < 0) {
        virReportOOMError();
        goto error;
    }

5787
#if VBOX_API_VERSION < 4000
5788
    rc = machine->vtbl->GetSnapshot(machine, empty.value, list);
5789 5790 5791
#else /* VBOX_API_VERSION >= 4000 */
    rc = machine->vtbl->FindSnapshot(machine, empty.value, list);
#endif /* VBOX_API_VERSION >= 4000 */
J
Jiri Denemark 已提交
5792
    if (NS_FAILED(rc) || !list[0]) {
5793 5794 5795
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not get root snapshot for domain %s"),
                       dom->name);
J
Jiri Denemark 已提交
5796 5797 5798 5799 5800 5801
        goto error;
    }

    /* BFS walk through snapshot tree */
    top = 1;
    for (next = 0; next < count; next++) {
5802
        vboxArray children = VBOX_ARRAY_INITIALIZER;
J
Jiri Denemark 已提交
5803 5804 5805
        unsigned int i;

        if (!list[next]) {
5806 5807
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("unexpected number of snapshots < %u"), count);
J
Jiri Denemark 已提交
5808 5809 5810
            goto error;
        }

5811 5812
        rc = vboxArrayGet(&children, list[next],
                               list[next]->vtbl->GetChildren);
J
Jiri Denemark 已提交
5813
        if (NS_FAILED(rc)) {
5814 5815
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("could not get children snapshots"));
J
Jiri Denemark 已提交
5816 5817
            goto error;
        }
5818 5819 5820
        for (i = 0; i < children.count; i++) {
            ISnapshot *child = children.items[i];
            if (!child)
J
Jiri Denemark 已提交
5821 5822
                continue;
            if (top == count) {
5823 5824
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("unexpected number of snapshots > %u"), count);
5825
                vboxArrayRelease(&children);
J
Jiri Denemark 已提交
5826 5827
                goto error;
            }
5828 5829
            VBOX_ADDREF(child);
            list[top++] = child;
J
Jiri Denemark 已提交
5830
        }
5831
        vboxArrayRelease(&children);
J
Jiri Denemark 已提交
5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868
    }

out:
    *snapshots = list;
    return count;

error:
    if (list) {
        for (next = 0; next < count; next++)
            VBOX_RELEASE(list[next]);
    }
    VIR_FREE(list);

    return -1;
}

static ISnapshot *
vboxDomainSnapshotGet(vboxGlobalData *data,
                      virDomainPtr dom,
                      IMachine *machine,
                      const char *name)
{
    ISnapshot **snapshots = NULL;
    ISnapshot *snapshot = NULL;
    nsresult rc;
    int count = 0;
    int i;

    if ((count = vboxDomainSnapshotGetAll(dom, machine, &snapshots)) < 0)
        goto cleanup;

    for (i = 0; i < count; i++) {
        PRUnichar *nameUtf16;
        char *nameUtf8;

        rc = snapshots[i]->vtbl->GetName(snapshots[i], &nameUtf16);
        if (NS_FAILED(rc) || !nameUtf16) {
5869 5870
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("could not get snapshot name"));
J
Jiri Denemark 已提交
5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883
            goto cleanup;
        }
        VBOX_UTF16_TO_UTF8(nameUtf16, &nameUtf8);
        VBOX_UTF16_FREE(nameUtf16);
        if (STREQ(name, nameUtf8))
            snapshot = snapshots[i];
        VBOX_UTF8_FREE(nameUtf8);

        if (snapshot)
            break;
    }

    if (!snapshot) {
5884 5885 5886
        virReportError(VIR_ERR_OPERATION_INVALID,
                       _("domain %s has no snapshots with name %s"),
                       dom->name, name);
J
Jiri Denemark 已提交
5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903
        goto cleanup;
    }

cleanup:
    if (count > 0) {
        for (i = 0; i < count; i++) {
            if (snapshots[i] != snapshot)
                VBOX_RELEASE(snapshots[i]);
        }
    }
    VIR_FREE(snapshots);
    return snapshot;
}

static virDomainSnapshotPtr
vboxDomainSnapshotCreateXML(virDomainPtr dom,
                            const char *xmlDesc,
5904
                            unsigned int flags)
J
Jiri Denemark 已提交
5905 5906 5907
{
    VBOX_OBJECT_CHECK(dom->conn, virDomainSnapshotPtr, NULL);
    virDomainSnapshotDefPtr def = NULL;
5908
    vboxIID domiid = VBOX_IID_INITIALIZER;
J
Jiri Denemark 已提交
5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922
    IMachine *machine = NULL;
    IConsole *console = NULL;
    IProgress *progress = NULL;
    ISnapshot *snapshot = NULL;
    PRUnichar *name = NULL;
    PRUnichar *description = NULL;
    PRUint32 state;
    nsresult rc;
#if VBOX_API_VERSION == 2002
    nsresult result;
#else
    PRInt32 result;
#endif

5923 5924
    /* VBox has no snapshot metadata, so this flag is trivial.  */
    virCheckFlags(VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA, NULL);
5925

5926
    if (!(def = virDomainSnapshotDefParseString(xmlDesc, NULL, 0, 0)))
J
Jiri Denemark 已提交
5927 5928
        goto cleanup;

5929
    if (def->ndisks) {
5930 5931
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("disk snapshots not supported yet"));
5932 5933 5934
        goto cleanup;
    }

5935
    vboxIIDFromUUID(&domiid, dom->uuid);
5936
    rc = VBOX_OBJECT_GET_MACHINE(domiid.value, &machine);
5937
    if (NS_FAILED(rc)) {
5938 5939
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching UUID"));
J
Jiri Denemark 已提交
5940 5941 5942 5943 5944
        goto cleanup;
    }

    rc = machine->vtbl->GetState(machine, &state);
    if (NS_FAILED(rc)) {
5945 5946
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("could not get domain state"));
J
Jiri Denemark 已提交
5947 5948 5949 5950 5951
        goto cleanup;
    }

    if ((state >= MachineState_FirstOnline)
        && (state <= MachineState_LastOnline)) {
5952
        rc = VBOX_SESSION_OPEN_EXISTING(domiid.value, machine);
J
Jiri Denemark 已提交
5953
    } else {
5954
        rc = VBOX_SESSION_OPEN(domiid.value, machine);
J
Jiri Denemark 已提交
5955
    }
5956

J
Jiri Denemark 已提交
5957 5958 5959
    if (NS_SUCCEEDED(rc))
        rc = data->vboxSession->vtbl->GetConsole(data->vboxSession, &console);
    if (NS_FAILED(rc)) {
5960 5961 5962
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not open VirtualBox session with domain %s"),
                       dom->name);
J
Jiri Denemark 已提交
5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981
        goto cleanup;
    }

    VBOX_UTF8_TO_UTF16(def->name, &name);
    if (!name) {
        virReportOOMError();
        goto cleanup;
    }

    if (def->description) {
        VBOX_UTF8_TO_UTF16(def->description, &description);
        if (!description) {
            virReportOOMError();
            goto cleanup;
        }
    }

    rc = console->vtbl->TakeSnapshot(console, name, description, &progress);
    if (NS_FAILED(rc) || !progress) {
5982 5983
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not take snapshot of domain %s"), dom->name);
J
Jiri Denemark 已提交
5984 5985 5986 5987 5988 5989
        goto cleanup;
    }

    progress->vtbl->WaitForCompletion(progress, -1);
    progress->vtbl->GetResultCode(progress, &result);
    if (NS_FAILED(result)) {
5990 5991
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not take snapshot of domain %s"), dom->name);
J
Jiri Denemark 已提交
5992 5993 5994 5995 5996
        goto cleanup;
    }

    rc = machine->vtbl->GetCurrentSnapshot(machine, &snapshot);
    if (NS_FAILED(rc)) {
5997 5998
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not get current snapshot of domain %s"),
J
Jiri Denemark 已提交
5999 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009
                  dom->name);
        goto cleanup;
    }

    ret = virGetDomainSnapshot(dom, def->name);

cleanup:
    VBOX_RELEASE(progress);
    VBOX_UTF16_FREE(description);
    VBOX_UTF16_FREE(name);
    VBOX_RELEASE(console);
6010
    VBOX_SESSION_CLOSE();
J
Jiri Denemark 已提交
6011
    VBOX_RELEASE(machine);
6012
    vboxIIDUnalloc(&domiid);
J
Jiri Denemark 已提交
6013 6014 6015 6016 6017
    virDomainSnapshotDefFree(def);
    return ret;
}

static char *
6018 6019
vboxDomainSnapshotGetXMLDesc(virDomainSnapshotPtr snapshot,
                             unsigned int flags)
J
Jiri Denemark 已提交
6020 6021 6022
{
    virDomainPtr dom = snapshot->domain;
    VBOX_OBJECT_CHECK(dom->conn, char *, NULL);
6023
    vboxIID domiid = VBOX_IID_INITIALIZER;
J
Jiri Denemark 已提交
6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034
    IMachine *machine = NULL;
    ISnapshot *snap = NULL;
    ISnapshot *parent = NULL;
    nsresult rc;
    virDomainSnapshotDefPtr def = NULL;
    PRUnichar *str16;
    char *str8;
    PRInt64 timestamp;
    PRBool online = PR_FALSE;
    char uuidstr[VIR_UUID_STRING_BUFLEN];

6035 6036
    virCheckFlags(0, NULL);

6037
    vboxIIDFromUUID(&domiid, dom->uuid);
6038
    rc = VBOX_OBJECT_GET_MACHINE(domiid.value, &machine);
J
Jiri Denemark 已提交
6039
    if (NS_FAILED(rc)) {
6040 6041
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching UUID"));
J
Jiri Denemark 已提交
6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053
        goto cleanup;
    }

    if (!(snap = vboxDomainSnapshotGet(data, dom, machine, snapshot->name)))
        goto cleanup;

    if (VIR_ALLOC(def) < 0
        || !(def->name = strdup(snapshot->name)))
        goto no_memory;

    rc = snap->vtbl->GetDescription(snap, &str16);
    if (NS_FAILED(rc)) {
6054 6055 6056
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not get description of snapshot %s"),
                       snapshot->name);
J
Jiri Denemark 已提交
6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069
        goto cleanup;
    }
    if (str16) {
        VBOX_UTF16_TO_UTF8(str16, &str8);
        VBOX_UTF16_FREE(str16);
        def->description = strdup(str8);
        VBOX_UTF8_FREE(str8);
        if (!def->description)
            goto no_memory;
    }

    rc = snap->vtbl->GetTimeStamp(snap, &timestamp);
    if (NS_FAILED(rc)) {
6070 6071 6072
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not get creation time of snapshot %s"),
                       snapshot->name);
J
Jiri Denemark 已提交
6073 6074 6075 6076 6077 6078 6079
        goto cleanup;
    }
    /* timestamp is in milliseconds while creationTime in seconds */
    def->creationTime = timestamp / 1000;

    rc = snap->vtbl->GetParent(snap, &parent);
    if (NS_FAILED(rc)) {
6080 6081 6082
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not get parent of snapshot %s"),
                       snapshot->name);
J
Jiri Denemark 已提交
6083 6084 6085 6086 6087
        goto cleanup;
    }
    if (parent) {
        rc = parent->vtbl->GetName(parent, &str16);
        if (NS_FAILED(rc) || !str16) {
6088 6089 6090
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("could not get name of parent of snapshot %s"),
                           snapshot->name);
J
Jiri Denemark 已提交
6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102
            goto cleanup;
        }
        VBOX_UTF16_TO_UTF8(str16, &str8);
        VBOX_UTF16_FREE(str16);
        def->parent = strdup(str8);
        VBOX_UTF8_FREE(str8);
        if (!def->parent)
            goto no_memory;
    }

    rc = snap->vtbl->GetOnline(snap, &online);
    if (NS_FAILED(rc)) {
6103 6104 6105
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not get online state of snapshot %s"),
                       snapshot->name);
J
Jiri Denemark 已提交
6106 6107 6108 6109 6110 6111 6112 6113
        goto cleanup;
    }
    if (online)
        def->state = VIR_DOMAIN_RUNNING;
    else
        def->state = VIR_DOMAIN_SHUTOFF;

    virUUIDFormat(dom->uuid, uuidstr);
6114
    ret = virDomainSnapshotDefFormat(uuidstr, def, flags, 0);
J
Jiri Denemark 已提交
6115 6116 6117 6118 6119 6120

cleanup:
    virDomainSnapshotDefFree(def);
    VBOX_RELEASE(parent);
    VBOX_RELEASE(snap);
    VBOX_RELEASE(machine);
6121
    vboxIIDUnalloc(&domiid);
J
Jiri Denemark 已提交
6122 6123 6124 6125 6126 6127 6128 6129 6130
    return ret;

no_memory:
    virReportOOMError();
    goto cleanup;
}

static int
vboxDomainSnapshotNum(virDomainPtr dom,
6131
                      unsigned int flags)
J
Jiri Denemark 已提交
6132 6133
{
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
6134
    vboxIID iid = VBOX_IID_INITIALIZER;
J
Jiri Denemark 已提交
6135 6136 6137 6138
    IMachine *machine = NULL;
    nsresult rc;
    PRUint32 snapshotCount;

6139 6140
    virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS |
                  VIR_DOMAIN_SNAPSHOT_LIST_METADATA, -1);
6141

6142
    vboxIIDFromUUID(&iid, dom->uuid);
6143
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
J
Jiri Denemark 已提交
6144
    if (NS_FAILED(rc)) {
6145 6146
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching UUID"));
J
Jiri Denemark 已提交
6147 6148 6149
        goto cleanup;
    }

6150 6151 6152 6153 6154 6155
    /* VBox snapshots do not require libvirt to maintain any metadata.  */
    if (flags & VIR_DOMAIN_SNAPSHOT_LIST_METADATA) {
        ret = 0;
        goto cleanup;
    }

J
Jiri Denemark 已提交
6156 6157
    rc = machine->vtbl->GetSnapshotCount(machine, &snapshotCount);
    if (NS_FAILED(rc)) {
6158 6159 6160
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not get snapshot count for domain %s"),
                       dom->name);
J
Jiri Denemark 已提交
6161 6162 6163
        goto cleanup;
    }

6164 6165 6166 6167 6168
    /* VBox has at most one root snapshot.  */
    if (snapshotCount && (flags & VIR_DOMAIN_SNAPSHOT_LIST_ROOTS))
        ret = 1;
    else
        ret = snapshotCount;
J
Jiri Denemark 已提交
6169 6170 6171

cleanup:
    VBOX_RELEASE(machine);
6172
    vboxIIDUnalloc(&iid);
J
Jiri Denemark 已提交
6173 6174 6175 6176 6177 6178 6179
    return ret;
}

static int
vboxDomainSnapshotListNames(virDomainPtr dom,
                            char **names,
                            int nameslen,
6180
                            unsigned int flags)
J
Jiri Denemark 已提交
6181 6182
{
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
6183
    vboxIID iid = VBOX_IID_INITIALIZER;
J
Jiri Denemark 已提交
6184 6185 6186 6187 6188 6189
    IMachine *machine = NULL;
    nsresult rc;
    ISnapshot **snapshots = NULL;
    int count = 0;
    int i;

6190 6191
    virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS |
                  VIR_DOMAIN_SNAPSHOT_LIST_METADATA, -1);
6192

6193
    vboxIIDFromUUID(&iid, dom->uuid);
6194
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
J
Jiri Denemark 已提交
6195
    if (NS_FAILED(rc)) {
6196 6197
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching UUID"));
J
Jiri Denemark 已提交
6198 6199 6200
        goto cleanup;
    }

6201 6202 6203 6204 6205
    if (flags & VIR_DOMAIN_SNAPSHOT_LIST_METADATA) {
        ret = 0;
        goto cleanup;
    }

6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218
    if (flags & VIR_DOMAIN_SNAPSHOT_LIST_ROOTS) {
        vboxIID empty = VBOX_IID_INITIALIZER;

        if (VIR_ALLOC_N(snapshots, 1) < 0) {
            virReportOOMError();
            goto cleanup;
        }
#if VBOX_API_VERSION < 4000
        rc = machine->vtbl->GetSnapshot(machine, empty.value, snapshots);
#else /* VBOX_API_VERSION >= 4000 */
        rc = machine->vtbl->FindSnapshot(machine, empty.value, snapshots);
#endif /* VBOX_API_VERSION >= 4000 */
        if (NS_FAILED(rc) || !snapshots[0]) {
6219 6220 6221
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("could not get root snapshot for domain %s"),
                           dom->name);
6222 6223 6224 6225 6226 6227 6228
            goto cleanup;
        }
        count = 1;
    } else {
        if ((count = vboxDomainSnapshotGetAll(dom, machine, &snapshots)) < 0)
            goto cleanup;
    }
J
Jiri Denemark 已提交
6229 6230 6231 6232 6233 6234 6235 6236 6237 6238

    for (i = 0; i < nameslen; i++) {
        PRUnichar *nameUtf16;
        char *name;

        if (i >= count)
            break;

        rc = snapshots[i]->vtbl->GetName(snapshots[i], &nameUtf16);
        if (NS_FAILED(rc) || !nameUtf16) {
6239 6240
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("could not get snapshot name"));
J
Jiri Denemark 已提交
6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264
            goto cleanup;
        }
        VBOX_UTF16_TO_UTF8(nameUtf16, &name);
        VBOX_UTF16_FREE(nameUtf16);
        names[i] = strdup(name);
        VBOX_UTF8_FREE(name);
        if (!names[i]) {
            virReportOOMError();
            goto cleanup;
        }
    }

    if (count <= nameslen)
        ret = count;
    else
        ret = nameslen;

cleanup:
    if (count > 0) {
        for (i = 0; i < count; i++)
            VBOX_RELEASE(snapshots[i]);
    }
    VIR_FREE(snapshots);
    VBOX_RELEASE(machine);
6265
    vboxIIDUnalloc(&iid);
J
Jiri Denemark 已提交
6266 6267 6268 6269 6270 6271
    return ret;
}

static virDomainSnapshotPtr
vboxDomainSnapshotLookupByName(virDomainPtr dom,
                               const char *name,
6272
                               unsigned int flags)
J
Jiri Denemark 已提交
6273 6274
{
    VBOX_OBJECT_CHECK(dom->conn, virDomainSnapshotPtr, NULL);
6275
    vboxIID iid = VBOX_IID_INITIALIZER;
J
Jiri Denemark 已提交
6276 6277 6278 6279
    IMachine *machine = NULL;
    ISnapshot *snapshot = NULL;
    nsresult rc;

6280 6281
    virCheckFlags(0, NULL);

6282
    vboxIIDFromUUID(&iid, dom->uuid);
6283
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
J
Jiri Denemark 已提交
6284
    if (NS_FAILED(rc)) {
6285 6286
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching UUID"));
J
Jiri Denemark 已提交
6287 6288 6289 6290 6291 6292 6293 6294 6295 6296 6297
        goto cleanup;
    }

    if (!(snapshot = vboxDomainSnapshotGet(data, dom, machine, name)))
        goto cleanup;

    ret = virGetDomainSnapshot(dom, name);

cleanup:
    VBOX_RELEASE(snapshot);
    VBOX_RELEASE(machine);
6298
    vboxIIDUnalloc(&iid);
J
Jiri Denemark 已提交
6299 6300 6301 6302 6303
    return ret;
}

static int
vboxDomainHasCurrentSnapshot(virDomainPtr dom,
6304
                             unsigned int flags)
J
Jiri Denemark 已提交
6305 6306
{
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
6307
    vboxIID iid = VBOX_IID_INITIALIZER;
J
Jiri Denemark 已提交
6308 6309 6310 6311
    IMachine *machine = NULL;
    ISnapshot *snapshot = NULL;
    nsresult rc;

6312 6313
    virCheckFlags(0, -1);

6314
    vboxIIDFromUUID(&iid, dom->uuid);
6315
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
6316
    if (NS_FAILED(rc)) {
6317 6318
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching UUID"));
J
Jiri Denemark 已提交
6319 6320 6321 6322 6323
        goto cleanup;
    }

    rc = machine->vtbl->GetCurrentSnapshot(machine, &snapshot);
    if (NS_FAILED(rc)) {
6324 6325
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("could not get current snapshot"));
J
Jiri Denemark 已提交
6326 6327 6328 6329 6330 6331 6332 6333 6334 6335
        goto cleanup;
    }

    if (snapshot)
        ret = 1;
    else
        ret = 0;

cleanup:
    VBOX_RELEASE(machine);
6336
    vboxIIDUnalloc(&iid);
J
Jiri Denemark 已提交
6337 6338 6339
    return ret;
}

6340 6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358
static virDomainSnapshotPtr
vboxDomainSnapshotGetParent(virDomainSnapshotPtr snapshot,
                            unsigned int flags)
{
    virDomainPtr dom = snapshot->domain;
    VBOX_OBJECT_CHECK(dom->conn, virDomainSnapshotPtr, NULL);
    vboxIID iid = VBOX_IID_INITIALIZER;
    IMachine *machine = NULL;
    ISnapshot *snap = NULL;
    ISnapshot *parent = NULL;
    PRUnichar *nameUtf16 = NULL;
    char *name = NULL;
    nsresult rc;

    virCheckFlags(0, NULL);

    vboxIIDFromUUID(&iid, dom->uuid);
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
    if (NS_FAILED(rc)) {
6359 6360
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching UUID"));
6361 6362 6363 6364 6365 6366 6367 6368
        goto cleanup;
    }

    if (!(snap = vboxDomainSnapshotGet(data, dom, machine, snapshot->name)))
        goto cleanup;

    rc = snap->vtbl->GetParent(snap, &parent);
    if (NS_FAILED(rc)) {
6369 6370 6371
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not get parent of snapshot %s"),
                       snapshot->name);
6372 6373 6374
        goto cleanup;
    }
    if (!parent) {
6375 6376 6377
        virReportError(VIR_ERR_NO_DOMAIN_SNAPSHOT,
                       _("snapshot '%s' does not have a parent"),
                       snapshot->name);
6378 6379 6380 6381 6382
        goto cleanup;
    }

    rc = parent->vtbl->GetName(parent, &nameUtf16);
    if (NS_FAILED(rc) || !nameUtf16) {
6383 6384 6385
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not get name of parent of snapshot %s"),
                       snapshot->name);
6386 6387 6388 6389 6390 6391 6392 6393 6394 6395 6396 6397 6398 6399 6400 6401 6402 6403 6404 6405
        goto cleanup;
    }
    VBOX_UTF16_TO_UTF8(nameUtf16, &name);
    if (!name) {
        virReportOOMError();
        goto cleanup;
    }

    ret = virGetDomainSnapshot(dom, name);

cleanup:
    VBOX_UTF8_FREE(name);
    VBOX_UTF16_FREE(nameUtf16);
    VBOX_RELEASE(snap);
    VBOX_RELEASE(parent);
    VBOX_RELEASE(machine);
    vboxIIDUnalloc(&iid);
    return ret;
}

J
Jiri Denemark 已提交
6406 6407
static virDomainSnapshotPtr
vboxDomainSnapshotCurrent(virDomainPtr dom,
6408
                          unsigned int flags)
J
Jiri Denemark 已提交
6409 6410
{
    VBOX_OBJECT_CHECK(dom->conn, virDomainSnapshotPtr, NULL);
6411
    vboxIID iid = VBOX_IID_INITIALIZER;
J
Jiri Denemark 已提交
6412 6413 6414 6415 6416 6417
    IMachine *machine = NULL;
    ISnapshot *snapshot = NULL;
    PRUnichar *nameUtf16 = NULL;
    char *name = NULL;
    nsresult rc;

6418 6419
    virCheckFlags(0, NULL);

6420
    vboxIIDFromUUID(&iid, dom->uuid);
6421
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
6422
    if (NS_FAILED(rc)) {
6423 6424
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching UUID"));
J
Jiri Denemark 已提交
6425 6426 6427 6428 6429
        goto cleanup;
    }

    rc = machine->vtbl->GetCurrentSnapshot(machine, &snapshot);
    if (NS_FAILED(rc)) {
6430 6431
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("could not get current snapshot"));
J
Jiri Denemark 已提交
6432 6433 6434 6435
        goto cleanup;
    }

    if (!snapshot) {
6436 6437
        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                       _("domain has no snapshots"));
J
Jiri Denemark 已提交
6438 6439 6440 6441 6442
        goto cleanup;
    }

    rc = snapshot->vtbl->GetName(snapshot, &nameUtf16);
    if (NS_FAILED(rc) || !nameUtf16) {
6443 6444
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("could not get current snapshot name"));
J
Jiri Denemark 已提交
6445 6446 6447 6448 6449 6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460
        goto cleanup;
    }

    VBOX_UTF16_TO_UTF8(nameUtf16, &name);
    if (!name) {
        virReportOOMError();
        goto cleanup;
    }

    ret = virGetDomainSnapshot(dom, name);

cleanup:
    VBOX_UTF8_FREE(name);
    VBOX_UTF16_FREE(nameUtf16);
    VBOX_RELEASE(snapshot);
    VBOX_RELEASE(machine);
6461
    vboxIIDUnalloc(&iid);
J
Jiri Denemark 已提交
6462 6463 6464
    return ret;
}

6465 6466 6467 6468 6469 6470 6471 6472 6473 6474 6475 6476 6477 6478 6479 6480 6481 6482 6483
static int
vboxDomainSnapshotIsCurrent(virDomainSnapshotPtr snapshot,
                            unsigned int flags)
{
    virDomainPtr dom = snapshot->domain;
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
    vboxIID iid = VBOX_IID_INITIALIZER;
    IMachine *machine = NULL;
    ISnapshot *snap = NULL;
    ISnapshot *current = NULL;
    PRUnichar *nameUtf16 = NULL;
    char *name = NULL;
    nsresult rc;

    virCheckFlags(0, -1);

    vboxIIDFromUUID(&iid, dom->uuid);
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
    if (NS_FAILED(rc)) {
6484 6485
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching UUID"));
6486 6487 6488 6489 6490 6491 6492 6493
        goto cleanup;
    }

    if (!(snap = vboxDomainSnapshotGet(data, dom, machine, snapshot->name)))
        goto cleanup;

    rc = machine->vtbl->GetCurrentSnapshot(machine, &current);
    if (NS_FAILED(rc)) {
6494 6495
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("could not get current snapshot"));
6496 6497 6498 6499 6500 6501 6502 6503 6504
        goto cleanup;
    }
    if (!current) {
        ret = 0;
        goto cleanup;
    }

    rc = current->vtbl->GetName(current, &nameUtf16);
    if (NS_FAILED(rc) || !nameUtf16) {
6505 6506
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("could not get current snapshot name"));
6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526 6527 6528 6529 6530 6531 6532 6533 6534 6535 6536 6537 6538 6539 6540 6541 6542 6543
        goto cleanup;
    }

    VBOX_UTF16_TO_UTF8(nameUtf16, &name);
    if (!name) {
        virReportOOMError();
        goto cleanup;
    }

    ret = STREQ(snapshot->name, name);

cleanup:
    VBOX_UTF8_FREE(name);
    VBOX_UTF16_FREE(nameUtf16);
    VBOX_RELEASE(snap);
    VBOX_RELEASE(current);
    VBOX_RELEASE(machine);
    vboxIIDUnalloc(&iid);
    return ret;
}

static int
vboxDomainSnapshotHasMetadata(virDomainSnapshotPtr snapshot,
                              unsigned int flags)
{
    virDomainPtr dom = snapshot->domain;
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
    vboxIID iid = VBOX_IID_INITIALIZER;
    IMachine *machine = NULL;
    ISnapshot *snap = NULL;
    nsresult rc;

    virCheckFlags(0, -1);

    vboxIIDFromUUID(&iid, dom->uuid);
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
    if (NS_FAILED(rc)) {
6544 6545
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching UUID"));
6546 6547 6548 6549 6550 6551 6552 6553 6554 6555 6556 6557 6558 6559 6560 6561
        goto cleanup;
    }

    /* Check that snapshot exists.  If so, there is no metadata.  */
    if (!(snap = vboxDomainSnapshotGet(data, dom, machine, snapshot->name)))
        goto cleanup;

    ret = 0;

cleanup:
    VBOX_RELEASE(snap);
    VBOX_RELEASE(machine);
    vboxIIDUnalloc(&iid);
    return ret;
}

J
Jiri Denemark 已提交
6562 6563 6564 6565 6566 6567 6568
#if VBOX_API_VERSION < 3001
static int
vboxDomainSnapshotRestore(virDomainPtr dom,
                          IMachine *machine,
                          ISnapshot *snapshot)
{
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
6569
    vboxIID iid = VBOX_IID_INITIALIZER;
J
Jiri Denemark 已提交
6570 6571
    nsresult rc;

6572 6573
    rc = snapshot->vtbl->GetId(snapshot, &iid.value);
    if (NS_FAILED(rc)) {
6574 6575
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("could not get snapshot UUID"));
J
Jiri Denemark 已提交
6576 6577 6578
        goto cleanup;
    }

6579
    rc = machine->vtbl->SetCurrentSnapshot(machine, iid.value);
J
Jiri Denemark 已提交
6580
    if (NS_FAILED(rc)) {
6581 6582
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not restore snapshot for domain %s"), dom->name);
J
Jiri Denemark 已提交
6583 6584 6585 6586 6587 6588
        goto cleanup;
    }

    ret = 0;

cleanup:
6589
    vboxIIDUnalloc(&iid);
J
Jiri Denemark 已提交
6590 6591 6592 6593 6594 6595 6596 6597 6598 6599 6600 6601 6602 6603
    return ret;
}
#else
static int
vboxDomainSnapshotRestore(virDomainPtr dom,
                          IMachine *machine,
                          ISnapshot *snapshot)
{
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
    IConsole *console = NULL;
    IProgress *progress = NULL;
    PRUint32 state;
    nsresult rc;
    PRInt32 result;
6604
    vboxIID domiid = VBOX_IID_INITIALIZER;
J
Jiri Denemark 已提交
6605

6606 6607
    rc = machine->vtbl->GetId(machine, &domiid.value);
    if (NS_FAILED(rc)) {
6608 6609
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("could not get domain UUID"));
J
Jiri Denemark 已提交
6610 6611 6612 6613 6614
        goto cleanup;
    }

    rc = machine->vtbl->GetState(machine, &state);
    if (NS_FAILED(rc)) {
6615 6616
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("could not get domain state"));
J
Jiri Denemark 已提交
6617 6618 6619 6620 6621
        goto cleanup;
    }

    if (state >= MachineState_FirstOnline
        && state <= MachineState_LastOnline) {
6622 6623
        virReportError(VIR_ERR_OPERATION_INVALID,
                       _("domain %s is already running"), dom->name);
J
Jiri Denemark 已提交
6624 6625 6626
        goto cleanup;
    }

6627
    rc = VBOX_SESSION_OPEN(domiid.value, machine);
J
Jiri Denemark 已提交
6628 6629 6630
    if (NS_SUCCEEDED(rc))
        rc = data->vboxSession->vtbl->GetConsole(data->vboxSession, &console);
    if (NS_FAILED(rc)) {
6631 6632 6633
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not open VirtualBox session with domain %s"),
                       dom->name);
J
Jiri Denemark 已提交
6634 6635 6636 6637 6638 6639
        goto cleanup;
    }

    rc = console->vtbl->RestoreSnapshot(console, snapshot, &progress);
    if (NS_FAILED(rc) || !progress) {
        if (rc == VBOX_E_INVALID_VM_STATE) {
6640 6641
            virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                           _("cannot restore domain snapshot for running domain"));
J
Jiri Denemark 已提交
6642
        } else {
6643 6644 6645
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("could not restore snapshot for domain %s"),
                           dom->name);
J
Jiri Denemark 已提交
6646 6647 6648 6649 6650 6651 6652
        }
        goto cleanup;
    }

    progress->vtbl->WaitForCompletion(progress, -1);
    progress->vtbl->GetResultCode(progress, &result);
    if (NS_FAILED(result)) {
6653 6654
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not restore snapshot for domain %s"), dom->name);
J
Jiri Denemark 已提交
6655 6656 6657 6658 6659 6660 6661 6662
        goto cleanup;
    }

    ret = 0;

cleanup:
    VBOX_RELEASE(progress);
    VBOX_RELEASE(console);
6663
    VBOX_SESSION_CLOSE();
6664
    vboxIIDUnalloc(&domiid);
J
Jiri Denemark 已提交
6665 6666 6667 6668 6669 6670
    return ret;
}
#endif

static int
vboxDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
6671
                           unsigned int flags)
J
Jiri Denemark 已提交
6672 6673 6674
{
    virDomainPtr dom = snapshot->domain;
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
6675
    vboxIID domiid = VBOX_IID_INITIALIZER;
J
Jiri Denemark 已提交
6676 6677 6678 6679 6680 6681 6682
    IMachine *machine = NULL;
    ISnapshot *newSnapshot = NULL;
    ISnapshot *prevSnapshot = NULL;
    PRBool online = PR_FALSE;
    PRUint32 state;
    nsresult rc;

6683 6684
    virCheckFlags(0, -1);

6685
    vboxIIDFromUUID(&domiid, dom->uuid);
6686
    rc = VBOX_OBJECT_GET_MACHINE(domiid.value, &machine);
J
Jiri Denemark 已提交
6687
    if (NS_FAILED(rc)) {
6688 6689
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching UUID"));
J
Jiri Denemark 已提交
6690 6691 6692 6693 6694 6695 6696 6697 6698
        goto cleanup;
    }

    newSnapshot = vboxDomainSnapshotGet(data, dom, machine, snapshot->name);
    if (!newSnapshot)
        goto cleanup;

    rc = newSnapshot->vtbl->GetOnline(newSnapshot, &online);
    if (NS_FAILED(rc)) {
6699 6700 6701
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not get online state of snapshot %s"),
                       snapshot->name);
J
Jiri Denemark 已提交
6702 6703 6704 6705 6706
        goto cleanup;
    }

    rc = machine->vtbl->GetCurrentSnapshot(machine, &prevSnapshot);
    if (NS_FAILED(rc)) {
6707 6708 6709
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not get current snapshot of domain %s"),
                       dom->name);
J
Jiri Denemark 已提交
6710 6711 6712 6713 6714
        goto cleanup;
    }

    rc = machine->vtbl->GetState(machine, &state);
    if (NS_FAILED(rc)) {
6715 6716
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("could not get domain state"));
J
Jiri Denemark 已提交
6717 6718 6719 6720 6721
        goto cleanup;
    }

    if (state >= MachineState_FirstOnline
        && state <= MachineState_LastOnline) {
6722 6723
        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                       _("cannot revert snapshot of running domain"));
J
Jiri Denemark 已提交
6724 6725 6726 6727 6728 6729 6730 6731 6732 6733 6734 6735 6736 6737 6738 6739
        goto cleanup;
    }

    if (vboxDomainSnapshotRestore(dom, machine, newSnapshot))
        goto cleanup;

    if (online) {
        ret = vboxDomainCreate(dom);
        if (!ret)
            vboxDomainSnapshotRestore(dom, machine, prevSnapshot);
    } else
        ret = 0;

cleanup:
    VBOX_RELEASE(prevSnapshot);
    VBOX_RELEASE(newSnapshot);
6740
    vboxIIDUnalloc(&domiid);
J
Jiri Denemark 已提交
6741 6742 6743 6744 6745 6746 6747 6748 6749
    return ret;
}

static int
vboxDomainSnapshotDeleteSingle(vboxGlobalData *data,
                               IConsole *console,
                               ISnapshot *snapshot)
{
    IProgress *progress = NULL;
6750
    vboxIID iid = VBOX_IID_INITIALIZER;
J
Jiri Denemark 已提交
6751 6752 6753 6754 6755 6756 6757 6758
    int ret = -1;
    nsresult rc;
#if VBOX_API_VERSION == 2002
    nsresult result;
#else
    PRInt32 result;
#endif

6759 6760
    rc = snapshot->vtbl->GetId(snapshot, &iid.value);
    if (NS_FAILED(rc)) {
6761 6762
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("could not get snapshot UUID"));
J
Jiri Denemark 已提交
6763 6764 6765 6766
        goto cleanup;
    }

#if VBOX_API_VERSION < 3001
6767
    rc = console->vtbl->DiscardSnapshot(console, iid.value, &progress);
J
Jiri Denemark 已提交
6768
#else
6769
    rc = console->vtbl->DeleteSnapshot(console, iid.value, &progress);
J
Jiri Denemark 已提交
6770 6771 6772
#endif
    if (NS_FAILED(rc) || !progress) {
        if (rc == VBOX_E_INVALID_VM_STATE) {
6773 6774
            virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                           _("cannot delete domain snapshot for running domain"));
J
Jiri Denemark 已提交
6775
        } else {
6776 6777
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("could not delete snapshot"));
J
Jiri Denemark 已提交
6778 6779 6780 6781 6782 6783 6784
        }
        goto cleanup;
    }

    progress->vtbl->WaitForCompletion(progress, -1);
    progress->vtbl->GetResultCode(progress, &result);
    if (NS_FAILED(result)) {
6785 6786
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("could not delete snapshot"));
J
Jiri Denemark 已提交
6787 6788 6789 6790 6791 6792 6793
        goto cleanup;
    }

    ret = 0;

cleanup:
    VBOX_RELEASE(progress);
6794
    vboxIIDUnalloc(&iid);
J
Jiri Denemark 已提交
6795 6796 6797 6798 6799 6800 6801 6802
    return ret;
}

static int
vboxDomainSnapshotDeleteTree(vboxGlobalData *data,
                             IConsole *console,
                             ISnapshot *snapshot)
{
6803
    vboxArray children = VBOX_ARRAY_INITIALIZER;
J
Jiri Denemark 已提交
6804 6805 6806 6807
    int ret = -1;
    nsresult rc;
    unsigned int i;

6808
    rc = vboxArrayGet(&children, snapshot, snapshot->vtbl->GetChildren);
J
Jiri Denemark 已提交
6809
    if (NS_FAILED(rc)) {
6810 6811
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("could not get children snapshots"));
J
Jiri Denemark 已提交
6812 6813 6814
        goto cleanup;
    }

6815 6816 6817
    for (i = 0; i < children.count; i++) {
        if (vboxDomainSnapshotDeleteTree(data, console, children.items[i]))
            goto cleanup;
J
Jiri Denemark 已提交
6818 6819 6820 6821 6822
    }

    ret = vboxDomainSnapshotDeleteSingle(data, console, snapshot);

cleanup:
6823
    vboxArrayRelease(&children);
J
Jiri Denemark 已提交
6824 6825 6826 6827 6828 6829 6830 6831 6832
    return ret;
}

static int
vboxDomainSnapshotDelete(virDomainSnapshotPtr snapshot,
                         unsigned int flags)
{
    virDomainPtr dom = snapshot->domain;
    VBOX_OBJECT_CHECK(dom->conn, int, -1);
6833
    vboxIID domiid = VBOX_IID_INITIALIZER;
J
Jiri Denemark 已提交
6834 6835 6836 6837 6838 6839
    IMachine *machine = NULL;
    ISnapshot *snap = NULL;
    IConsole *console = NULL;
    PRUint32 state;
    nsresult rc;

6840 6841
    virCheckFlags(VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN |
                  VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY, -1);
6842

6843
    vboxIIDFromUUID(&domiid, dom->uuid);
6844
    rc = VBOX_OBJECT_GET_MACHINE(domiid.value, &machine);
J
Jiri Denemark 已提交
6845
    if (NS_FAILED(rc)) {
6846 6847
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching UUID"));
J
Jiri Denemark 已提交
6848 6849 6850 6851 6852 6853 6854 6855 6856
        goto cleanup;
    }

    snap = vboxDomainSnapshotGet(data, dom, machine, snapshot->name);
    if (!snap)
        goto cleanup;

    rc = machine->vtbl->GetState(machine, &state);
    if (NS_FAILED(rc)) {
6857 6858
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("could not get domain state"));
J
Jiri Denemark 已提交
6859 6860 6861
        goto cleanup;
    }

6862 6863 6864 6865 6866 6867 6868
    /* VBOX snapshots do not require any libvirt metadata, making this
     * flag trivial once we know we have a valid snapshot.  */
    if (flags & VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY) {
        ret = 0;
        goto cleanup;
    }

J
Jiri Denemark 已提交
6869 6870
    if (state >= MachineState_FirstOnline
        && state <= MachineState_LastOnline) {
6871 6872
        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                       _("cannot delete snapshots of running domain"));
J
Jiri Denemark 已提交
6873 6874 6875
        goto cleanup;
    }

6876
    rc = VBOX_SESSION_OPEN(domiid.value, machine);
J
Jiri Denemark 已提交
6877 6878 6879
    if (NS_SUCCEEDED(rc))
        rc = data->vboxSession->vtbl->GetConsole(data->vboxSession, &console);
    if (NS_FAILED(rc)) {
6880 6881 6882
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not open VirtualBox session with domain %s"),
                       dom->name);
J
Jiri Denemark 已提交
6883 6884 6885 6886 6887 6888 6889 6890 6891 6892 6893
        goto cleanup;
    }

    if (flags & VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN)
        ret = vboxDomainSnapshotDeleteTree(data, console, snap);
    else
        ret = vboxDomainSnapshotDeleteSingle(data, console, snap);

cleanup:
    VBOX_RELEASE(console);
    VBOX_RELEASE(snap);
6894
    vboxIIDUnalloc(&domiid);
6895
    VBOX_SESSION_CLOSE();
J
Jiri Denemark 已提交
6896 6897 6898
    return ret;
}

6899
#if VBOX_API_VERSION <= 2002 || VBOX_API_VERSION >= 4000
6900
    /* No Callback support for VirtualBox 2.2.* series */
6901 6902
    /* No Callback support for VirtualBox 4.* series */
#else /* !(VBOX_API_VERSION == 2002 || VBOX_API_VERSION >= 4000) */
6903 6904

/* Functions needed for Callbacks */
6905
static nsresult PR_COM_METHOD
6906
vboxCallbackOnMachineStateChange(IVirtualBoxCallback *pThis ATTRIBUTE_UNUSED,
6907 6908
                                 PRUnichar *machineId, PRUint32 state)
{
6909 6910 6911 6912 6913 6914
    virDomainPtr dom = NULL;
    int event        = 0;
    int detail       = 0;

    vboxDriverLock(g_pVBoxGlobalData);

6915
    VIR_DEBUG("IVirtualBoxCallback: %p, State: %d", pThis, state);
6916 6917 6918 6919 6920 6921 6922
    DEBUGPRUnichar("machineId", machineId);

    if (machineId) {
        char *machineIdUtf8       = NULL;
        unsigned char uuid[VIR_UUID_BUFLEN];

        g_pVBoxGlobalData->pFuncs->pfnUtf16ToUtf8(machineId, &machineIdUtf8);
6923
        ignore_value(virUUIDParse(machineIdUtf8, uuid));
6924 6925 6926

        dom = vboxDomainLookupByUUID(g_pVBoxGlobalData->conn, uuid);
        if (dom) {
6927
            virDomainEventPtr ev;
6928 6929 6930 6931 6932 6933 6934 6935 6936 6937 6938 6939 6940 6941 6942 6943 6944 6945 6946 6947 6948 6949 6950 6951 6952 6953 6954 6955 6956 6957

            if (state == MachineState_Starting) {
                event  = VIR_DOMAIN_EVENT_STARTED;
                detail = VIR_DOMAIN_EVENT_STARTED_BOOTED;
            } else if (state == MachineState_Restoring) {
                event  = VIR_DOMAIN_EVENT_STARTED;
                detail = VIR_DOMAIN_EVENT_STARTED_RESTORED;
            } else if (state == MachineState_Paused) {
                event  = VIR_DOMAIN_EVENT_SUSPENDED;
                detail = VIR_DOMAIN_EVENT_SUSPENDED_PAUSED;
            } else if (state == MachineState_Running) {
                event  = VIR_DOMAIN_EVENT_RESUMED;
                detail = VIR_DOMAIN_EVENT_RESUMED_UNPAUSED;
            } else if (state == MachineState_PoweredOff) {
                event  = VIR_DOMAIN_EVENT_STOPPED;
                detail = VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN;
            } else if (state == MachineState_Stopping) {
                event  = VIR_DOMAIN_EVENT_STOPPED;
                detail = VIR_DOMAIN_EVENT_STOPPED_DESTROYED;
            } else if (state == MachineState_Aborted) {
                event  = VIR_DOMAIN_EVENT_STOPPED;
                detail = VIR_DOMAIN_EVENT_STOPPED_CRASHED;
            } else if (state == MachineState_Saving) {
                event  = VIR_DOMAIN_EVENT_STOPPED;
                detail = VIR_DOMAIN_EVENT_STOPPED_SAVED;
            } else {
                event  = VIR_DOMAIN_EVENT_STOPPED;
                detail = VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN;
            }

6958 6959
            ev = virDomainEventNewFromDom(dom, event, detail);

6960 6961
            if (ev)
                virDomainEventStateQueue(g_pVBoxGlobalData->domainEvents, ev);
6962 6963 6964 6965 6966 6967 6968 6969
        }
    }

    vboxDriverUnlock(g_pVBoxGlobalData);

    return NS_OK;
}

6970
static nsresult PR_COM_METHOD
6971
vboxCallbackOnMachineDataChange(IVirtualBoxCallback *pThis ATTRIBUTE_UNUSED,
6972 6973
                                PRUnichar *machineId)
{
6974
    VIR_DEBUG("IVirtualBoxCallback: %p", pThis);
6975 6976 6977 6978 6979
    DEBUGPRUnichar("machineId", machineId);

    return NS_OK;
}

6980
static nsresult PR_COM_METHOD
6981
vboxCallbackOnExtraDataCanChange(IVirtualBoxCallback *pThis ATTRIBUTE_UNUSED,
6982 6983 6984
                                 PRUnichar *machineId, PRUnichar *key,
                                 PRUnichar *value,
                                 PRUnichar **error ATTRIBUTE_UNUSED,
6985
                                 PRBool *allowChange ATTRIBUTE_UNUSED)
6986
{
6987
    VIR_DEBUG("IVirtualBoxCallback: %p, allowChange: %s", pThis, *allowChange ? "true" : "false");
6988 6989 6990 6991 6992 6993 6994
    DEBUGPRUnichar("machineId", machineId);
    DEBUGPRUnichar("key", key);
    DEBUGPRUnichar("value", value);

    return NS_OK;
}

6995
static nsresult PR_COM_METHOD
6996 6997
vboxCallbackOnExtraDataChange(IVirtualBoxCallback *pThis ATTRIBUTE_UNUSED,
                              PRUnichar *machineId,
6998 6999
                              PRUnichar *key, PRUnichar *value)
{
7000
    VIR_DEBUG("IVirtualBoxCallback: %p", pThis);
7001 7002 7003 7004 7005 7006 7007
    DEBUGPRUnichar("machineId", machineId);
    DEBUGPRUnichar("key", key);
    DEBUGPRUnichar("value", value);

    return NS_OK;
}

7008
# if VBOX_API_VERSION < 3001
7009
static nsresult PR_COM_METHOD
7010 7011 7012 7013
vboxCallbackOnMediaRegistered(IVirtualBoxCallback *pThis ATTRIBUTE_UNUSED,
                              PRUnichar *mediaId,
                              PRUint32 mediaType ATTRIBUTE_UNUSED,
                              PRBool registered ATTRIBUTE_UNUSED)
7014
{
7015 7016
    VIR_DEBUG("IVirtualBoxCallback: %p, registered: %s", pThis, registered ? "true" : "false");
    VIR_DEBUG("mediaType: %d", mediaType);
7017 7018 7019 7020
    DEBUGPRUnichar("mediaId", mediaId);

    return NS_OK;
}
7021 7022
# else  /* VBOX_API_VERSION >= 3001 */
# endif /* VBOX_API_VERSION >= 3001 */
7023

7024
static nsresult PR_COM_METHOD
7025
vboxCallbackOnMachineRegistered(IVirtualBoxCallback *pThis ATTRIBUTE_UNUSED,
7026 7027
                                PRUnichar *machineId, PRBool registered)
{
7028 7029 7030 7031 7032 7033
    virDomainPtr dom = NULL;
    int event        = 0;
    int detail       = 0;

    vboxDriverLock(g_pVBoxGlobalData);

7034
    VIR_DEBUG("IVirtualBoxCallback: %p, registered: %s", pThis, registered ? "true" : "false");
7035 7036 7037 7038 7039 7040 7041
    DEBUGPRUnichar("machineId", machineId);

    if (machineId) {
        char *machineIdUtf8       = NULL;
        unsigned char uuid[VIR_UUID_BUFLEN];

        g_pVBoxGlobalData->pFuncs->pfnUtf16ToUtf8(machineId, &machineIdUtf8);
7042
        ignore_value(virUUIDParse(machineIdUtf8, uuid));
7043 7044 7045

        dom = vboxDomainLookupByUUID(g_pVBoxGlobalData->conn, uuid);
        if (dom) {
7046
            virDomainEventPtr ev;
7047 7048

            /* CURRENT LIMITATION: we never get the VIR_DOMAIN_EVENT_UNDEFINED
J
Ján Tomko 已提交
7049
             * event because the when the machine is de-registered the call
7050 7051 7052 7053 7054 7055 7056 7057 7058 7059 7060 7061
             * to vboxDomainLookupByUUID fails and thus we don't get any
             * dom pointer which is necessary (null dom pointer doesn't work)
             * to show the VIR_DOMAIN_EVENT_UNDEFINED event
             */
            if (registered) {
                event  = VIR_DOMAIN_EVENT_DEFINED;
                detail = VIR_DOMAIN_EVENT_DEFINED_ADDED;
            } else {
                event  = VIR_DOMAIN_EVENT_UNDEFINED;
                detail = VIR_DOMAIN_EVENT_UNDEFINED_REMOVED;
            }

7062 7063
            ev = virDomainEventNewFromDom(dom, event, detail);

7064 7065
            if (ev)
                virDomainEventStateQueue(g_pVBoxGlobalData->domainEvents, ev);
7066 7067 7068 7069 7070 7071 7072 7073
        }
    }

    vboxDriverUnlock(g_pVBoxGlobalData);

    return NS_OK;
}

7074
static nsresult PR_COM_METHOD
7075 7076 7077
vboxCallbackOnSessionStateChange(IVirtualBoxCallback *pThis ATTRIBUTE_UNUSED,
                                 PRUnichar *machineId,
                                 PRUint32 state ATTRIBUTE_UNUSED)
7078
{
7079
    VIR_DEBUG("IVirtualBoxCallback: %p, state: %d", pThis, state);
7080 7081 7082 7083 7084
    DEBUGPRUnichar("machineId", machineId);

    return NS_OK;
}

7085
static nsresult PR_COM_METHOD
7086 7087
vboxCallbackOnSnapshotTaken(IVirtualBoxCallback *pThis ATTRIBUTE_UNUSED,
                            PRUnichar *machineId,
7088 7089
                            PRUnichar *snapshotId)
{
7090
    VIR_DEBUG("IVirtualBoxCallback: %p", pThis);
7091 7092 7093 7094 7095 7096
    DEBUGPRUnichar("machineId", machineId);
    DEBUGPRUnichar("snapshotId", snapshotId);

    return NS_OK;
}

7097
static nsresult PR_COM_METHOD
7098 7099
vboxCallbackOnSnapshotDiscarded(IVirtualBoxCallback *pThis ATTRIBUTE_UNUSED,
                                PRUnichar *machineId,
7100 7101
                                PRUnichar *snapshotId)
{
7102
    VIR_DEBUG("IVirtualBoxCallback: %p", pThis);
7103 7104 7105 7106 7107 7108
    DEBUGPRUnichar("machineId", machineId);
    DEBUGPRUnichar("snapshotId", snapshotId);

    return NS_OK;
}

7109
static nsresult PR_COM_METHOD
7110 7111
vboxCallbackOnSnapshotChange(IVirtualBoxCallback *pThis ATTRIBUTE_UNUSED,
                             PRUnichar *machineId,
7112 7113
                             PRUnichar *snapshotId)
{
7114
    VIR_DEBUG("IVirtualBoxCallback: %p", pThis);
7115 7116 7117 7118 7119 7120
    DEBUGPRUnichar("machineId", machineId);
    DEBUGPRUnichar("snapshotId", snapshotId);

    return NS_OK;
}

7121
static nsresult PR_COM_METHOD
7122
vboxCallbackOnGuestPropertyChange(IVirtualBoxCallback *pThis ATTRIBUTE_UNUSED,
7123 7124 7125
                                  PRUnichar *machineId, PRUnichar *name,
                                  PRUnichar *value, PRUnichar *flags)
{
7126
    VIR_DEBUG("IVirtualBoxCallback: %p", pThis);
7127 7128 7129 7130 7131 7132 7133 7134
    DEBUGPRUnichar("machineId", machineId);
    DEBUGPRUnichar("name", name);
    DEBUGPRUnichar("value", value);
    DEBUGPRUnichar("flags", flags);

    return NS_OK;
}

7135
static nsresult PR_COM_METHOD
7136
vboxCallbackAddRef(nsISupports *pThis ATTRIBUTE_UNUSED)
7137
{
7138 7139 7140 7141
    nsresult c;

    c = ++g_pVBoxGlobalData->vboxCallBackRefCount;

7142
    VIR_DEBUG("pThis: %p, vboxCallback AddRef: %d", pThis, c);
7143 7144 7145 7146

    return c;
}

7147 7148 7149
static nsresult PR_COM_METHOD
vboxCallbackRelease(nsISupports *pThis)
{
7150 7151 7152 7153 7154 7155 7156 7157 7158
    nsresult c;

    c = --g_pVBoxGlobalData->vboxCallBackRefCount;
    if (c == 0) {
        /* delete object */
        VIR_FREE(pThis->vtbl);
        VIR_FREE(pThis);
    }

7159
    VIR_DEBUG("pThis: %p, vboxCallback Release: %d", pThis, c);
7160 7161 7162 7163

    return c;
}

7164 7165 7166
static nsresult PR_COM_METHOD
vboxCallbackQueryInterface(nsISupports *pThis, const nsID *iid, void **resultp)
{
7167 7168 7169 7170 7171
    IVirtualBoxCallback *that = (IVirtualBoxCallback *)pThis;
    static const nsID ivirtualboxCallbackUUID = IVIRTUALBOXCALLBACK_IID;
    static const nsID isupportIID = NS_ISUPPORTS_IID;

    /* Match UUID for IVirtualBoxCallback class */
7172 7173
    if (memcmp(iid, &ivirtualboxCallbackUUID, sizeof(nsID)) == 0 ||
        memcmp(iid, &isupportIID, sizeof(nsID)) == 0) {
7174 7175 7176
        g_pVBoxGlobalData->vboxCallBackRefCount++;
        *resultp = that;

7177
        VIR_DEBUG("pThis: %p, vboxCallback QueryInterface: %d", pThis, g_pVBoxGlobalData->vboxCallBackRefCount);
7178 7179 7180 7181 7182

        return NS_OK;
    }


7183
    VIR_DEBUG("pThis: %p, vboxCallback QueryInterface didn't find a matching interface", pThis);
7184 7185 7186 7187 7188 7189
    DEBUGUUID("The UUID Callback Interface expects", iid);
    DEBUGUUID("The UUID Callback Interface got", &ivirtualboxCallbackUUID);
    return NS_NOINTERFACE;
}


7190
static IVirtualBoxCallback *vboxAllocCallbackObj(void) {
7191 7192
    IVirtualBoxCallback *vboxCallback = NULL;

7193
    /* Allocate, Initialize and return a valid
7194 7195 7196
     * IVirtualBoxCallback object here
     */
    if ((VIR_ALLOC(vboxCallback) < 0) || (VIR_ALLOC(vboxCallback->vtbl) < 0)) {
7197
        VIR_FREE(vboxCallback);
7198
        virReportOOMError();
7199 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209
        return NULL;
    }

    {
        vboxCallback->vtbl->nsisupports.AddRef          = &vboxCallbackAddRef;
        vboxCallback->vtbl->nsisupports.Release         = &vboxCallbackRelease;
        vboxCallback->vtbl->nsisupports.QueryInterface  = &vboxCallbackQueryInterface;
        vboxCallback->vtbl->OnMachineStateChange        = &vboxCallbackOnMachineStateChange;
        vboxCallback->vtbl->OnMachineDataChange         = &vboxCallbackOnMachineDataChange;
        vboxCallback->vtbl->OnExtraDataCanChange        = &vboxCallbackOnExtraDataCanChange;
        vboxCallback->vtbl->OnExtraDataChange           = &vboxCallbackOnExtraDataChange;
7210
# if VBOX_API_VERSION < 3001
7211
        vboxCallback->vtbl->OnMediaRegistered           = &vboxCallbackOnMediaRegistered;
7212 7213
# else  /* VBOX_API_VERSION >= 3001 */
# endif /* VBOX_API_VERSION >= 3001 */
7214 7215 7216
        vboxCallback->vtbl->OnMachineRegistered         = &vboxCallbackOnMachineRegistered;
        vboxCallback->vtbl->OnSessionStateChange        = &vboxCallbackOnSessionStateChange;
        vboxCallback->vtbl->OnSnapshotTaken             = &vboxCallbackOnSnapshotTaken;
7217
# if VBOX_API_VERSION < 3002
7218
        vboxCallback->vtbl->OnSnapshotDiscarded         = &vboxCallbackOnSnapshotDiscarded;
7219 7220 7221
# else /* VBOX_API_VERSION >= 3002 */
        vboxCallback->vtbl->OnSnapshotDeleted           = &vboxCallbackOnSnapshotDiscarded;
# endif /* VBOX_API_VERSION >= 3002 */
7222 7223 7224 7225 7226 7227 7228 7229 7230 7231 7232 7233 7234 7235 7236 7237 7238 7239 7240 7241 7242 7243 7244 7245 7246
        vboxCallback->vtbl->OnSnapshotChange            = &vboxCallbackOnSnapshotChange;
        vboxCallback->vtbl->OnGuestPropertyChange       = &vboxCallbackOnGuestPropertyChange;
        g_pVBoxGlobalData->vboxCallBackRefCount = 1;

    }

    return vboxCallback;
}

static void vboxReadCallback(int watch ATTRIBUTE_UNUSED,
                             int fd,
                             int events ATTRIBUTE_UNUSED,
                             void *opaque ATTRIBUTE_UNUSED) {
    if (fd >= 0) {
        g_pVBoxGlobalData->vboxQueue->vtbl->ProcessPendingEvents(g_pVBoxGlobalData->vboxQueue);
    } else {
        nsresult rc;
        PLEvent *pEvent = NULL;

        rc = g_pVBoxGlobalData->vboxQueue->vtbl->WaitForEvent(g_pVBoxGlobalData->vboxQueue, &pEvent);
        if (NS_SUCCEEDED(rc))
            g_pVBoxGlobalData->vboxQueue->vtbl->HandleEvent(g_pVBoxGlobalData->vboxQueue, pEvent);
    }
}

7247 7248 7249 7250
static int vboxDomainEventRegister(virConnectPtr conn,
                                   virConnectDomainEventCallback callback,
                                   void *opaque,
                                   virFreeCallback freecb) {
7251
    VBOX_OBJECT_CHECK(conn, int, -1);
7252
    int vboxRet          = -1;
7253
    nsresult rc;
7254 7255 7256 7257 7258 7259

    /* Locking has to be there as callbacks are not
     * really fully thread safe
     */
    vboxDriverLock(data);

7260
    if (data->vboxCallback == NULL) {
7261
        data->vboxCallback = vboxAllocCallbackObj();
7262 7263 7264 7265
        if (data->vboxCallback != NULL) {
            rc = data->vboxObj->vtbl->RegisterCallback(data->vboxObj, data->vboxCallback);
            if (NS_SUCCEEDED(rc)) {
                vboxRet = 0;
7266 7267
            }
        }
7268 7269 7270
    } else {
        vboxRet = 0;
    }
7271

7272 7273 7274 7275 7276 7277 7278
    /* Get the vbox file handle and add a event handle to it
     * so that the events can be passed down to the user
     */
    if (vboxRet == 0) {
        if (data->fdWatch < 0) {
            PRInt32 vboxFileHandle;
            vboxFileHandle = data->vboxQueue->vtbl->GetEventQueueSelectFD(data->vboxQueue);
7279

7280 7281
            data->fdWatch = virEventAddHandle(vboxFileHandle, VIR_EVENT_HANDLE_READABLE, vboxReadCallback, NULL, NULL);
        }
7282

7283 7284 7285 7286 7287
        if (data->fdWatch >= 0) {
            /* Once a callback is registered with virtualbox, use a list
             * to store the callbacks registered with libvirt so that
             * later you can iterate over them
             */
7288

7289 7290
            ret = virDomainEventStateRegister(conn, data->domainEvents,
                                              callback, opaque, freecb);
7291
            VIR_DEBUG("virDomainEventStateRegister (ret = %d) (conn: %p, "
7292
                      "callback: %p, opaque: %p, "
7293
                      "freecb: %p)", ret, conn, callback,
7294
                      opaque, freecb);
7295 7296 7297 7298 7299 7300 7301 7302 7303 7304 7305 7306 7307 7308 7309
        }
    }

    vboxDriverUnlock(data);

    if (ret >= 0) {
        return ret;
    } else {
        if (data->vboxObj && data->vboxCallback) {
            data->vboxObj->vtbl->UnregisterCallback(data->vboxObj, data->vboxCallback);
        }
        return -1;
    }
}

7310 7311
static int vboxDomainEventDeregister(virConnectPtr conn,
                                     virConnectDomainEventCallback callback) {
7312
    VBOX_OBJECT_CHECK(conn, int, -1);
7313
    int cnt;
7314 7315 7316 7317 7318 7319

    /* Locking has to be there as callbacks are not
     * really fully thread safe
     */
    vboxDriverLock(data);

7320 7321
    cnt = virDomainEventStateDeregister(conn, data->domainEvents,
                                        callback);
7322

7323 7324 7325
    if (data->vboxCallback && cnt == 0) {
        data->vboxObj->vtbl->UnregisterCallback(data->vboxObj, data->vboxCallback);
        VBOX_RELEASE(data->vboxCallback);
7326

7327 7328 7329
        /* Remove the Event file handle on which we are listening as well */
        virEventRemoveHandle(data->fdWatch);
        data->fdWatch = -1;
7330 7331 7332 7333 7334 7335 7336
    }

    vboxDriverUnlock(data);

    return ret;
}

7337 7338 7339 7340 7341 7342 7343 7344 7345 7346 7347 7348 7349 7350 7351 7352 7353 7354 7355 7356 7357 7358 7359 7360 7361 7362 7363 7364 7365 7366 7367 7368 7369 7370 7371 7372 7373 7374 7375 7376 7377 7378 7379 7380
static int vboxDomainEventRegisterAny(virConnectPtr conn,
                                      virDomainPtr dom,
                                      int eventID,
                                      virConnectDomainEventGenericCallback callback,
                                      void *opaque,
                                      virFreeCallback freecb) {
    VBOX_OBJECT_CHECK(conn, int, -1);
    int vboxRet          = -1;
    nsresult rc;

    /* Locking has to be there as callbacks are not
     * really fully thread safe
     */
    vboxDriverLock(data);

    if (data->vboxCallback == NULL) {
        data->vboxCallback = vboxAllocCallbackObj();
        if (data->vboxCallback != NULL) {
            rc = data->vboxObj->vtbl->RegisterCallback(data->vboxObj, data->vboxCallback);
            if (NS_SUCCEEDED(rc)) {
                vboxRet = 0;
            }
        }
    } else {
        vboxRet = 0;
    }

    /* Get the vbox file handle and add a event handle to it
     * so that the events can be passed down to the user
     */
    if (vboxRet == 0) {
        if (data->fdWatch < 0) {
            PRInt32 vboxFileHandle;
            vboxFileHandle = data->vboxQueue->vtbl->GetEventQueueSelectFD(data->vboxQueue);

            data->fdWatch = virEventAddHandle(vboxFileHandle, VIR_EVENT_HANDLE_READABLE, vboxReadCallback, NULL, NULL);
        }

        if (data->fdWatch >= 0) {
            /* Once a callback is registered with virtualbox, use a list
             * to store the callbacks registered with libvirt so that
             * later you can iterate over them
             */

7381 7382 7383
            if (virDomainEventStateRegisterID(conn, data->domainEvents,
                                              dom, eventID,
                                              callback, opaque, freecb, &ret) < 0)
7384
                ret = -1;
7385
            VIR_DEBUG("virDomainEventStateRegisterID (ret = %d) (conn: %p, "
7386
                      "callback: %p, opaque: %p, "
7387
                      "freecb: %p)", ret, conn, callback,
7388
                      opaque, freecb);
7389 7390 7391 7392 7393 7394 7395 7396 7397 7398 7399 7400 7401 7402 7403 7404 7405 7406
        }
    }

    vboxDriverUnlock(data);

    if (ret >= 0) {
        return ret;
    } else {
        if (data->vboxObj && data->vboxCallback) {
            data->vboxObj->vtbl->UnregisterCallback(data->vboxObj, data->vboxCallback);
        }
        return -1;
    }
}

static int vboxDomainEventDeregisterAny(virConnectPtr conn,
                                        int callbackID) {
    VBOX_OBJECT_CHECK(conn, int, -1);
7407
    int cnt;
7408 7409 7410 7411 7412 7413

    /* Locking has to be there as callbacks are not
     * really fully thread safe
     */
    vboxDriverLock(data);

7414 7415
    cnt = virDomainEventStateDeregisterID(conn, data->domainEvents,
                                          callbackID);
7416

7417 7418 7419
    if (data->vboxCallback && cnt == 0) {
        data->vboxObj->vtbl->UnregisterCallback(data->vboxObj, data->vboxCallback);
        VBOX_RELEASE(data->vboxCallback);
7420

7421 7422 7423
        /* Remove the Event file handle on which we are listening as well */
        virEventRemoveHandle(data->fdWatch);
        data->fdWatch = -1;
7424 7425 7426 7427 7428 7429 7430
    }

    vboxDriverUnlock(data);

    return ret;
}

7431
#endif /* !(VBOX_API_VERSION == 2002 || VBOX_API_VERSION >= 4000) */
7432

7433 7434 7435 7436 7437
/**
 * The Network Functions here on
 */
static virDrvOpenStatus vboxNetworkOpen(virConnectPtr conn,
                                        virConnectAuthPtr auth ATTRIBUTE_UNUSED,
E
Eric Blake 已提交
7438 7439
                                        unsigned int flags)
{
7440 7441
    vboxGlobalData *data = conn->privateData;

E
Eric Blake 已提交
7442 7443
    virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);

7444 7445 7446 7447 7448 7449 7450 7451
    if (STRNEQ(conn->driver->name, "VBOX"))
        goto cleanup;

    if ((data->pFuncs      == NULL) ||
        (data->vboxObj     == NULL) ||
        (data->vboxSession == NULL))
        goto cleanup;

7452
    VIR_DEBUG("network initialized");
7453 7454 7455 7456 7457 7458 7459 7460
    /* conn->networkPrivateData = some network specific data */
    return VIR_DRV_OPEN_SUCCESS;

cleanup:
    return VIR_DRV_OPEN_DECLINED;
}

static int vboxNetworkClose(virConnectPtr conn) {
7461
    VIR_DEBUG("network uninitialized");
7462 7463 7464 7465 7466
    conn->networkPrivateData = NULL;
    return 0;
}

static int vboxNumOfNetworks(virConnectPtr conn) {
7467
    VBOX_OBJECT_HOST_CHECK(conn, int, 0);
7468
    vboxArray networkInterfaces = VBOX_ARRAY_INITIALIZER;
7469
    int i = 0;
7470

7471
    vboxArrayGet(&networkInterfaces, host, host->vtbl->GetNetworkInterfaces);
7472

7473 7474 7475 7476
    for (i = 0; i < networkInterfaces.count; i++) {
        IHostNetworkInterface *networkInterface = networkInterfaces.items[i];

        if (networkInterface) {
7477
            PRUint32 interfaceType = 0;
7478

7479
            networkInterface->vtbl->GetInterfaceType(networkInterface, &interfaceType);
7480 7481
            if (interfaceType == HostNetworkInterfaceType_HostOnly) {
                PRUint32 status = HostNetworkInterfaceStatus_Unknown;
7482

7483
                networkInterface->vtbl->GetStatus(networkInterface, &status);
7484

7485 7486
                if (status == HostNetworkInterfaceStatus_Up)
                    ret++;
7487 7488 7489 7490
            }
        }
    }

7491 7492
    vboxArrayRelease(&networkInterfaces);

7493 7494
    VBOX_RELEASE(host);

7495
    VIR_DEBUG("numActive: %d", ret);
7496
    return ret;
7497 7498 7499
}

static int vboxListNetworks(virConnectPtr conn, char **const names, int nnames) {
7500
    VBOX_OBJECT_HOST_CHECK(conn, int, 0);
7501
    vboxArray networkInterfaces = VBOX_ARRAY_INITIALIZER;
7502
    int i = 0;
7503

7504 7505 7506 7507
    vboxArrayGet(&networkInterfaces, host, host->vtbl->GetNetworkInterfaces);

    for (i = 0; (ret < nnames) && (i < networkInterfaces.count); i++) {
        IHostNetworkInterface *networkInterface = networkInterfaces.items[i];
7508

7509
        if (networkInterface) {
7510
            PRUint32 interfaceType = 0;
7511

7512
            networkInterface->vtbl->GetInterfaceType(networkInterface, &interfaceType);
7513

7514 7515
            if (interfaceType == HostNetworkInterfaceType_HostOnly) {
                PRUint32 status = HostNetworkInterfaceStatus_Unknown;
7516

7517
                networkInterface->vtbl->GetStatus(networkInterface, &status);
7518

7519 7520 7521
                if (status == HostNetworkInterfaceStatus_Up) {
                    char *nameUtf8       = NULL;
                    PRUnichar *nameUtf16 = NULL;
7522

7523
                    networkInterface->vtbl->GetName(networkInterface, &nameUtf16);
7524
                    VBOX_UTF16_TO_UTF8(nameUtf16, &nameUtf8);
7525

7526
                    VIR_DEBUG("nnames[%d]: %s", ret, nameUtf8);
7527 7528
                    names[ret] = strdup(nameUtf8);
                    if (names[ret] == NULL) {
7529
                        virReportOOMError();
7530 7531
                    } else {
                        ret++;
7532 7533
                    }

7534 7535
                    VBOX_UTF8_FREE(nameUtf8);
                    VBOX_UTF16_FREE(nameUtf16);
7536 7537 7538 7539 7540
                }
            }
        }
    }

7541
    vboxArrayRelease(&networkInterfaces);
7542

7543
    VBOX_RELEASE(host);
7544

7545 7546
    return ret;
}
7547

7548 7549
static int vboxNumOfDefinedNetworks(virConnectPtr conn) {
    VBOX_OBJECT_HOST_CHECK(conn, int, 0);
7550
    vboxArray networkInterfaces = VBOX_ARRAY_INITIALIZER;
7551
    int i = 0;
7552

7553
    vboxArrayGet(&networkInterfaces, host, host->vtbl->GetNetworkInterfaces);
7554

7555 7556 7557 7558
    for (i = 0; i < networkInterfaces.count; i++) {
        IHostNetworkInterface *networkInterface = networkInterfaces.items[i];

        if (networkInterface) {
7559
            PRUint32 interfaceType = 0;
7560

7561
            networkInterface->vtbl->GetInterfaceType(networkInterface, &interfaceType);
7562 7563
            if (interfaceType == HostNetworkInterfaceType_HostOnly) {
                PRUint32 status = HostNetworkInterfaceStatus_Unknown;
7564

7565
                networkInterface->vtbl->GetStatus(networkInterface, &status);
7566

7567 7568
                if (status == HostNetworkInterfaceStatus_Down)
                    ret++;
7569 7570 7571 7572
            }
        }
    }

7573 7574
    vboxArrayRelease(&networkInterfaces);

7575 7576
    VBOX_RELEASE(host);

7577
    VIR_DEBUG("numActive: %d", ret);
7578
    return ret;
7579 7580 7581
}

static int vboxListDefinedNetworks(virConnectPtr conn, char **const names, int nnames) {
7582
    VBOX_OBJECT_HOST_CHECK(conn, int, 0);
7583
    vboxArray networkInterfaces = VBOX_ARRAY_INITIALIZER;
7584
    int i = 0;
7585

7586 7587 7588 7589
    vboxArrayGet(&networkInterfaces, host, host->vtbl->GetNetworkInterfaces);

    for (i = 0; (ret < nnames) && (i < networkInterfaces.count); i++) {
        IHostNetworkInterface *networkInterface = networkInterfaces.items[i];
7590

7591
        if (networkInterface) {
7592
            PRUint32 interfaceType = 0;
7593

7594
            networkInterface->vtbl->GetInterfaceType(networkInterface, &interfaceType);
7595

7596 7597
            if (interfaceType == HostNetworkInterfaceType_HostOnly) {
                PRUint32 status = HostNetworkInterfaceStatus_Unknown;
7598

7599
                networkInterface->vtbl->GetStatus(networkInterface, &status);
7600

7601 7602 7603
                if (status == HostNetworkInterfaceStatus_Down) {
                    char *nameUtf8       = NULL;
                    PRUnichar *nameUtf16 = NULL;
7604

7605
                    networkInterface->vtbl->GetName(networkInterface, &nameUtf16);
7606
                    VBOX_UTF16_TO_UTF8(nameUtf16, &nameUtf8);
7607

7608
                    VIR_DEBUG("nnames[%d]: %s", ret, nameUtf8);
7609 7610
                    names[ret] = strdup(nameUtf8);
                    if (names[ret] == NULL) {
7611
                        virReportOOMError();
7612 7613
                    } else {
                        ret++;
7614 7615
                    }

7616 7617
                    VBOX_UTF8_FREE(nameUtf8);
                    VBOX_UTF16_FREE(nameUtf16);
7618 7619 7620 7621 7622
                }
            }
        }
    }

7623
    vboxArrayRelease(&networkInterfaces);
7624 7625 7626 7627

    VBOX_RELEASE(host);

    return ret;
7628 7629
}

7630 7631 7632
static virNetworkPtr
vboxNetworkLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
{
7633
    VBOX_OBJECT_HOST_CHECK(conn, virNetworkPtr, NULL);
7634
    vboxIID iid = VBOX_IID_INITIALIZER;
7635

7636
    vboxIIDFromUUID(&iid, uuid);
7637

7638 7639 7640
    /* TODO: "internal" networks are just strings and
     * thus can't do much with them
     */
7641
    IHostNetworkInterface *networkInterface = NULL;
7642

7643
    host->vtbl->FindHostNetworkInterfaceById(host, iid.value, &networkInterface);
7644 7645
    if (networkInterface) {
        PRUint32 interfaceType = 0;
7646

7647
        networkInterface->vtbl->GetInterfaceType(networkInterface, &interfaceType);
7648

7649 7650 7651
        if (interfaceType == HostNetworkInterfaceType_HostOnly) {
            char *nameUtf8       = NULL;
            PRUnichar *nameUtf16 = NULL;
7652

7653 7654
            networkInterface->vtbl->GetName(networkInterface, &nameUtf16);
            VBOX_UTF16_TO_UTF8(nameUtf16, &nameUtf8);
7655

7656
            ret = virGetNetwork(conn, nameUtf8, uuid);
7657

7658
            VIR_DEBUG("Network Name: %s", nameUtf8);
7659
            DEBUGIID("Network UUID", iid.value);
7660

7661 7662
            VBOX_UTF8_FREE(nameUtf8);
            VBOX_UTF16_FREE(nameUtf16);
7663
        }
7664 7665

        VBOX_RELEASE(networkInterface);
7666 7667
    }

7668 7669
    VBOX_RELEASE(host);

7670
    vboxIIDUnalloc(&iid);
7671 7672 7673 7674
    return ret;
}

static virNetworkPtr vboxNetworkLookupByName(virConnectPtr conn, const char *name) {
7675 7676 7677
    VBOX_OBJECT_HOST_CHECK(conn, virNetworkPtr, NULL);
    PRUnichar *nameUtf16                    = NULL;
    IHostNetworkInterface *networkInterface = NULL;
7678

7679
    VBOX_UTF8_TO_UTF16(name, &nameUtf16);
7680

7681
    host->vtbl->FindHostNetworkInterfaceByName(host, nameUtf16, &networkInterface);
7682

7683 7684
    if (networkInterface) {
        PRUint32 interfaceType = 0;
7685

7686
        networkInterface->vtbl->GetInterfaceType(networkInterface, &interfaceType);
7687

7688 7689
        if (interfaceType == HostNetworkInterfaceType_HostOnly) {
            unsigned char uuid[VIR_UUID_BUFLEN];
7690
            vboxIID iid = VBOX_IID_INITIALIZER;
7691

7692 7693
            networkInterface->vtbl->GetId(networkInterface, &iid.value);
            vboxIIDToUUID(&iid, uuid);
7694
            ret = virGetNetwork(conn, name, uuid);
7695
            VIR_DEBUG("Network Name: %s", name);
7696

7697 7698
            DEBUGIID("Network UUID", iid.value);
            vboxIIDUnalloc(&iid);
7699
        }
7700 7701

        VBOX_RELEASE(networkInterface);
7702 7703
    }

7704 7705 7706
    VBOX_UTF16_FREE(nameUtf16);
    VBOX_RELEASE(host);

7707 7708 7709
    return ret;
}

7710
static virNetworkPtr vboxNetworkDefineCreateXML(virConnectPtr conn, const char *xml, bool start) {
7711 7712 7713 7714
    VBOX_OBJECT_HOST_CHECK(conn, virNetworkPtr, NULL);
    PRUnichar *networkInterfaceNameUtf16    = NULL;
    char      *networkInterfaceNameUtf8     = NULL;
    IHostNetworkInterface *networkInterface = NULL;
7715
    nsresult rc;
7716

7717
    virNetworkDefPtr def = virNetworkDefParseString(xml);
7718 7719
    virNetworkIpDefPtr ipdef;
    virSocketAddr netmask;
7720

7721
    if ((!def) ||
7722
        (def->forward.type != VIR_NETWORK_FORWARD_NONE) ||
7723
        (def->nips == 0 || !def->ips))
7724 7725 7726 7727 7728 7729 7730 7731 7732 7733 7734
        goto cleanup;

    /* Look for the first IPv4 IP address definition and use that.
     * If there weren't any IPv4 addresses, ignore the network (since it's
     * required below to have an IPv4 address)
    */
    ipdef = virNetworkDefGetIpByIndex(def, AF_INET, 0);
    if (!ipdef)
        goto cleanup;

    if (virNetworkIpDefNetmask(ipdef, &netmask) < 0)
7735
        goto cleanup;
7736

7737 7738 7739 7740 7741 7742
    /* the current limitation of hostonly network is that you can't
     * assign a name to it and it defaults to vboxnet*, for e.g:
     * vboxnet0, vboxnet1, etc. Also the UUID is assigned to it
     * automatically depending on the mac address and thus both
     * these paramters are ignored here for now.
     */
7743

7744
#if VBOX_API_VERSION == 2002
7745
    if (STREQ(def->name, "vboxnet0")) {
7746
        PRUint32 interfaceType = 0;
7747

7748 7749
        VBOX_UTF8_TO_UTF16(def->name, &networkInterfaceNameUtf16);
        host->vtbl->FindHostNetworkInterfaceByName(host, networkInterfaceNameUtf16, &networkInterface);
7750

7751 7752 7753 7754 7755 7756
        networkInterface->vtbl->GetInterfaceType(networkInterface, &interfaceType);
        if (interfaceType != HostNetworkInterfaceType_HostOnly) {
            VBOX_RELEASE(networkInterface);
            networkInterface = NULL;
        }
    }
7757
#else /* VBOX_API_VERSION != 2002 */
7758 7759 7760 7761
    {
        IProgress *progress = NULL;
        host->vtbl->CreateHostOnlyNetworkInterface(host, &networkInterface,
                                                   &progress);
7762

7763 7764 7765 7766
        if (progress) {
            progress->vtbl->WaitForCompletion(progress, -1);
            VBOX_RELEASE(progress);
        }
7767
    }
7768
#endif /* VBOX_API_VERSION != 2002 */
7769

7770 7771 7772 7773
    if (networkInterface) {
        unsigned char uuid[VIR_UUID_BUFLEN];
        char      *networkNameUtf8  = NULL;
        PRUnichar *networkNameUtf16 = NULL;
7774
        vboxIID vboxnetiid = VBOX_IID_INITIALIZER;
7775 7776 7777 7778 7779 7780 7781 7782

        networkInterface->vtbl->GetName(networkInterface, &networkInterfaceNameUtf16);
        if (networkInterfaceNameUtf16) {
            VBOX_UTF16_TO_UTF8(networkInterfaceNameUtf16, &networkInterfaceNameUtf8);

            if (virAsprintf(&networkNameUtf8, "HostInterfaceNetworking-%s", networkInterfaceNameUtf8) < 0) {
                VBOX_RELEASE(host);
                VBOX_RELEASE(networkInterface);
7783
                virReportOOMError();
7784 7785 7786
                goto cleanup;
            }
        }
7787

7788
        VBOX_UTF8_TO_UTF16(networkNameUtf8 , &networkNameUtf16);
7789

7790 7791 7792
        /* Currently support only one dhcp server per network
         * with contigious address space from start to end
         */
7793
        if ((ipdef->nranges >= 1) &&
7794 7795
            VIR_SOCKET_ADDR_VALID(&ipdef->ranges[0].start) &&
            VIR_SOCKET_ADDR_VALID(&ipdef->ranges[0].end)) {
7796 7797 7798 7799 7800 7801 7802 7803 7804 7805
            IDHCPServer *dhcpServer = NULL;

            data->vboxObj->vtbl->FindDHCPServerByNetworkName(data->vboxObj,
                                                             networkNameUtf16,
                                                             &dhcpServer);
            if (!dhcpServer) {
                /* create a dhcp server */
                data->vboxObj->vtbl->CreateDHCPServer(data->vboxObj,
                                                      networkNameUtf16,
                                                      &dhcpServer);
7806
                VIR_DEBUG("couldn't find dhcp server so creating one");
7807 7808 7809 7810 7811 7812 7813 7814
            }
            if (dhcpServer) {
                PRUnichar *ipAddressUtf16     = NULL;
                PRUnichar *networkMaskUtf16   = NULL;
                PRUnichar *fromIPAddressUtf16 = NULL;
                PRUnichar *toIPAddressUtf16   = NULL;
                PRUnichar *trunkTypeUtf16     = NULL;

7815 7816 7817 7818
                ipAddressUtf16 = vboxSocketFormatAddrUtf16(data, &ipdef->address);
                networkMaskUtf16 = vboxSocketFormatAddrUtf16(data, &netmask);
                fromIPAddressUtf16 = vboxSocketFormatAddrUtf16(data, &ipdef->ranges[0].start);
                toIPAddressUtf16 = vboxSocketFormatAddrUtf16(data, &ipdef->ranges[0].end);
7819 7820 7821 7822 7823 7824 7825 7826 7827 7828

                if (ipAddressUtf16 == NULL || networkMaskUtf16 == NULL ||
                    fromIPAddressUtf16 == NULL || toIPAddressUtf16 == NULL) {
                    VBOX_UTF16_FREE(ipAddressUtf16);
                    VBOX_UTF16_FREE(networkMaskUtf16);
                    VBOX_UTF16_FREE(fromIPAddressUtf16);
                    VBOX_UTF16_FREE(toIPAddressUtf16);
                    VBOX_RELEASE(dhcpServer);
                    goto cleanup;
                }
7829 7830 7831 7832 7833 7834 7835 7836 7837 7838 7839 7840 7841 7842 7843 7844 7845 7846 7847 7848 7849 7850 7851 7852 7853

                VBOX_UTF8_TO_UTF16("netflt", &trunkTypeUtf16);

                dhcpServer->vtbl->SetEnabled(dhcpServer, PR_TRUE);

                dhcpServer->vtbl->SetConfiguration(dhcpServer,
                                                   ipAddressUtf16,
                                                   networkMaskUtf16,
                                                   fromIPAddressUtf16,
                                                   toIPAddressUtf16);

                if (start)
                    dhcpServer->vtbl->Start(dhcpServer,
                                            networkNameUtf16,
                                            networkInterfaceNameUtf16,
                                            trunkTypeUtf16);

                VBOX_UTF16_FREE(ipAddressUtf16);
                VBOX_UTF16_FREE(networkMaskUtf16);
                VBOX_UTF16_FREE(fromIPAddressUtf16);
                VBOX_UTF16_FREE(toIPAddressUtf16);
                VBOX_UTF16_FREE(trunkTypeUtf16);
                VBOX_RELEASE(dhcpServer);
            }
        }
7854

7855
        if ((ipdef->nhosts >= 1) &&
7856
            VIR_SOCKET_ADDR_VALID(&ipdef->hosts[0].ip)) {
7857 7858
            PRUnichar *ipAddressUtf16   = NULL;
            PRUnichar *networkMaskUtf16 = NULL;
7859

7860 7861
            ipAddressUtf16 = vboxSocketFormatAddrUtf16(data, &ipdef->hosts[0].ip);
            networkMaskUtf16 = vboxSocketFormatAddrUtf16(data, &netmask);
7862 7863 7864 7865 7866 7867

            if (ipAddressUtf16 == NULL || networkMaskUtf16 == NULL) {
                VBOX_UTF16_FREE(ipAddressUtf16);
                VBOX_UTF16_FREE(networkMaskUtf16);
                goto cleanup;
            }
7868

7869 7870 7871 7872 7873 7874 7875
            /* Current drawback is that since EnableStaticIpConfig() sets
             * IP and enables the interface so even if the dhcpserver is not
             * started the interface is still up and running
             */
            networkInterface->vtbl->EnableStaticIpConfig(networkInterface,
                                                         ipAddressUtf16,
                                                         networkMaskUtf16);
7876

7877 7878 7879 7880 7881 7882
            VBOX_UTF16_FREE(ipAddressUtf16);
            VBOX_UTF16_FREE(networkMaskUtf16);
        } else {
            networkInterface->vtbl->EnableDynamicIpConfig(networkInterface);
            networkInterface->vtbl->DhcpRediscover(networkInterface);
        }
7883

7884 7885 7886 7887 7888
        rc = networkInterface->vtbl->GetId(networkInterface, &vboxnetiid.value);
        if (NS_SUCCEEDED(rc)) {
            vboxIIDToUUID(&vboxnetiid, uuid);
            DEBUGIID("Real Network UUID", vboxnetiid.value);
            vboxIIDUnalloc(&vboxnetiid);
7889
            ret = virGetNetwork(conn, networkInterfaceNameUtf8, uuid);
7890
        }
7891 7892 7893 7894

        VIR_FREE(networkNameUtf8);
        VBOX_UTF16_FREE(networkNameUtf16);
        VBOX_RELEASE(networkInterface);
7895 7896
    }

7897 7898 7899 7900
    VBOX_UTF8_FREE(networkInterfaceNameUtf8);
    VBOX_UTF16_FREE(networkInterfaceNameUtf16);
    VBOX_RELEASE(host);

7901 7902 7903 7904 7905
cleanup:
    virNetworkDefFree(def);
    return ret;
}

7906 7907 7908 7909 7910 7911 7912 7913
static virNetworkPtr vboxNetworkCreateXML(virConnectPtr conn, const char *xml) {
    return vboxNetworkDefineCreateXML(conn, xml, true);
}

static virNetworkPtr vboxNetworkDefineXML(virConnectPtr conn, const char *xml) {
    return vboxNetworkDefineCreateXML(conn, xml, false);
}

7914
static int vboxNetworkUndefineDestroy(virNetworkPtr network, bool removeinterface) {
7915
    VBOX_OBJECT_HOST_CHECK(network->conn, int, -1);
7916
    char *networkNameUtf8 = NULL;
7917 7918
    PRUnichar *networkInterfaceNameUtf16    = NULL;
    IHostNetworkInterface *networkInterface = NULL;
7919 7920 7921 7922 7923 7924 7925 7926 7927 7928

    /* Current limitation of the function for VirtualBox 2.2.* is
     * that you can't delete the default hostonly adaptor namely:
     * vboxnet0 and thus all this functions does is remove the
     * dhcp server configuration, but the network can still be used
     * by giving the machine static IP and also it will still
     * show up in the net-list in virsh
     */

    if (virAsprintf(&networkNameUtf8, "HostInterfaceNetworking-%s", network->name) < 0) {
7929
        virReportOOMError();
7930 7931 7932
        goto cleanup;
    }

7933
    VBOX_UTF8_TO_UTF16(network->name, &networkInterfaceNameUtf16);
7934

7935
    host->vtbl->FindHostNetworkInterfaceByName(host, networkInterfaceNameUtf16, &networkInterface);
7936

7937 7938
    if (networkInterface) {
        PRUint32 interfaceType = 0;
7939

7940
        networkInterface->vtbl->GetInterfaceType(networkInterface, &interfaceType);
7941

7942 7943 7944
        if (interfaceType == HostNetworkInterfaceType_HostOnly) {
            PRUnichar *networkNameUtf16 = NULL;
            IDHCPServer *dhcpServer     = NULL;
7945

7946
#if VBOX_API_VERSION != 2002
7947 7948 7949
            if (removeinterface) {
                PRUnichar *iidUtf16 = NULL;
                IProgress *progress = NULL;
7950

7951
                networkInterface->vtbl->GetId(networkInterface, &iidUtf16);
7952

7953
                if (iidUtf16) {
7954
# if VBOX_API_VERSION == 3000
7955 7956 7957
                    IHostNetworkInterface *netInt = NULL;
                    host->vtbl->RemoveHostOnlyNetworkInterface(host, iidUtf16, &netInt, &progress);
                    VBOX_RELEASE(netInt);
7958
# else  /* VBOX_API_VERSION > 3000 */
7959
                    host->vtbl->RemoveHostOnlyNetworkInterface(host, iidUtf16, &progress);
7960
# endif /* VBOX_API_VERSION > 3000 */
7961 7962
                    VBOX_UTF16_FREE(iidUtf16);
                }
7963

7964 7965 7966 7967 7968
                if (progress) {
                    progress->vtbl->WaitForCompletion(progress, -1);
                    VBOX_RELEASE(progress);
                }
            }
7969 7970
#endif /* VBOX_API_VERSION != 2002 */

7971 7972 7973 7974 7975 7976 7977 7978 7979 7980 7981
            VBOX_UTF8_TO_UTF16(networkNameUtf8 , &networkNameUtf16);

            data->vboxObj->vtbl->FindDHCPServerByNetworkName(data->vboxObj,
                                                             networkNameUtf16,
                                                             &dhcpServer);
            if (dhcpServer) {
                dhcpServer->vtbl->SetEnabled(dhcpServer, PR_FALSE);
                dhcpServer->vtbl->Stop(dhcpServer);
                if (removeinterface)
                    data->vboxObj->vtbl->RemoveDHCPServer(data->vboxObj, dhcpServer);
                VBOX_RELEASE(dhcpServer);
7982 7983
            }

7984 7985
            VBOX_UTF16_FREE(networkNameUtf16);

7986
        }
7987
        VBOX_RELEASE(networkInterface);
7988 7989
    }

7990 7991 7992
    VBOX_UTF16_FREE(networkInterfaceNameUtf16);
    VBOX_RELEASE(host);

7993 7994 7995 7996 7997 7998 7999
    ret = 0;

cleanup:
    VIR_FREE(networkNameUtf8);
    return ret;
}

8000 8001 8002 8003
static int vboxNetworkUndefine(virNetworkPtr network) {
    return vboxNetworkUndefineDestroy(network, true);
}

8004
static int vboxNetworkCreate(virNetworkPtr network) {
8005
    VBOX_OBJECT_HOST_CHECK(network->conn, int, -1);
8006
    char *networkNameUtf8 = NULL;
8007 8008
    PRUnichar *networkInterfaceNameUtf16    = NULL;
    IHostNetworkInterface *networkInterface = NULL;
8009 8010 8011 8012 8013 8014 8015 8016 8017

    /* Current limitation of the function for VirtualBox 2.2.* is
     * that the default hostonly network "vboxnet0" is always active
     * and thus all this functions does is start the dhcp server,
     * but the network can still be used without starting the dhcp
     * server by giving the machine static IP
     */

    if (virAsprintf(&networkNameUtf8, "HostInterfaceNetworking-%s", network->name) < 0) {
8018
        virReportOOMError();
8019 8020 8021
        goto cleanup;
    }

8022
    VBOX_UTF8_TO_UTF16(network->name, &networkInterfaceNameUtf16);
8023

8024
    host->vtbl->FindHostNetworkInterfaceByName(host, networkInterfaceNameUtf16, &networkInterface);
8025

8026 8027
    if (networkInterface) {
        PRUint32 interfaceType = 0;
8028

8029
        networkInterface->vtbl->GetInterfaceType(networkInterface, &interfaceType);
8030

8031 8032 8033
        if (interfaceType == HostNetworkInterfaceType_HostOnly) {
            PRUnichar *networkNameUtf16 = NULL;
            IDHCPServer *dhcpServer     = NULL;
8034 8035


8036
            VBOX_UTF8_TO_UTF16(networkNameUtf8 , &networkNameUtf16);
8037

8038 8039 8040 8041 8042
            data->vboxObj->vtbl->FindDHCPServerByNetworkName(data->vboxObj,
                                                             networkNameUtf16,
                                                             &dhcpServer);
            if (dhcpServer) {
                PRUnichar *trunkTypeUtf16 = NULL;
8043

8044
                dhcpServer->vtbl->SetEnabled(dhcpServer, PR_TRUE);
8045

8046
                VBOX_UTF8_TO_UTF16("netflt", &trunkTypeUtf16);
8047

8048 8049 8050 8051
                dhcpServer->vtbl->Start(dhcpServer,
                                        networkNameUtf16,
                                        networkInterfaceNameUtf16,
                                        trunkTypeUtf16);
8052

8053 8054
                VBOX_UTF16_FREE(trunkTypeUtf16);
                VBOX_RELEASE(dhcpServer);
8055 8056
            }

8057
            VBOX_UTF16_FREE(networkNameUtf16);
8058
        }
8059 8060

        VBOX_RELEASE(networkInterface);
8061 8062
    }

8063 8064 8065
    VBOX_UTF16_FREE(networkInterfaceNameUtf16);
    VBOX_RELEASE(host);

8066 8067 8068 8069 8070 8071 8072 8073
    ret = 0;

cleanup:
    VIR_FREE(networkNameUtf8);
    return ret;
}

static int vboxNetworkDestroy(virNetworkPtr network) {
8074
    return vboxNetworkUndefineDestroy(network, false);
8075 8076
}

8077
static char *vboxNetworkGetXMLDesc(virNetworkPtr network,
E
Eric Blake 已提交
8078 8079
                                   unsigned int flags)
{
8080
    VBOX_OBJECT_HOST_CHECK(network->conn, char *, NULL);
8081
    virNetworkDefPtr def  = NULL;
8082
    virNetworkIpDefPtr ipdef = NULL;
8083
    char *networkNameUtf8 = NULL;
8084 8085
    PRUnichar *networkInterfaceNameUtf16    = NULL;
    IHostNetworkInterface *networkInterface = NULL;
8086

E
Eric Blake 已提交
8087 8088
    virCheckFlags(0, NULL);

8089
    if (VIR_ALLOC(def) < 0) {
8090
        virReportOOMError();
8091 8092
        goto cleanup;
    }
8093 8094 8095 8096 8097 8098
    if (VIR_ALLOC(ipdef) < 0) {
        virReportOOMError();
        goto cleanup;
    }
    def->ips = ipdef;
    def->nips = 1;
8099 8100

    if (virAsprintf(&networkNameUtf8, "HostInterfaceNetworking-%s", network->name) < 0) {
8101
        virReportOOMError();
8102 8103 8104
        goto cleanup;
    }

8105
    VBOX_UTF8_TO_UTF16(network->name, &networkInterfaceNameUtf16);
8106

8107
    host->vtbl->FindHostNetworkInterfaceByName(host, networkInterfaceNameUtf16, &networkInterface);
8108

8109 8110
    if (networkInterface) {
        PRUint32 interfaceType = 0;
8111

8112
        networkInterface->vtbl->GetInterfaceType(networkInterface, &interfaceType);
8113

8114 8115 8116 8117 8118
        if (interfaceType == HostNetworkInterfaceType_HostOnly) {
            def->name = strdup(network->name);
            if (def->name != NULL) {
                PRUnichar *networkNameUtf16 = NULL;
                IDHCPServer *dhcpServer     = NULL;
8119
                vboxIID vboxnet0IID = VBOX_IID_INITIALIZER;
8120

8121 8122
                networkInterface->vtbl->GetId(networkInterface, &vboxnet0IID.value);
                vboxIIDToUUID(&vboxnet0IID, def->uuid);
8123

8124
                VBOX_UTF8_TO_UTF16(networkNameUtf8 , &networkNameUtf16);
8125

8126
                def->forward.type = VIR_NETWORK_FORWARD_NONE;
8127

8128 8129 8130 8131
                data->vboxObj->vtbl->FindDHCPServerByNetworkName(data->vboxObj,
                                                                 networkNameUtf16,
                                                                 &dhcpServer);
                if (dhcpServer) {
8132
                    ipdef->nranges = 1;
8133
                    if (VIR_ALLOC_N(ipdef->ranges, ipdef->nranges) >=0) {
8134 8135 8136 8137
                        PRUnichar *ipAddressUtf16     = NULL;
                        PRUnichar *networkMaskUtf16   = NULL;
                        PRUnichar *fromIPAddressUtf16 = NULL;
                        PRUnichar *toIPAddressUtf16   = NULL;
8138
                        bool errorOccurred = false;
8139

8140 8141 8142 8143 8144 8145 8146
                        dhcpServer->vtbl->GetIPAddress(dhcpServer, &ipAddressUtf16);
                        dhcpServer->vtbl->GetNetworkMask(dhcpServer, &networkMaskUtf16);
                        dhcpServer->vtbl->GetLowerIP(dhcpServer, &fromIPAddressUtf16);
                        dhcpServer->vtbl->GetUpperIP(dhcpServer, &toIPAddressUtf16);
                        /* Currently virtualbox supports only one dhcp server per network
                         * with contigious address space from start to end
                         */
8147
                        if (vboxSocketParseAddrUtf16(data, ipAddressUtf16,
8148
                                                     &ipdef->address) < 0 ||
8149
                            vboxSocketParseAddrUtf16(data, networkMaskUtf16,
8150
                                                     &ipdef->netmask) < 0 ||
8151
                            vboxSocketParseAddrUtf16(data, fromIPAddressUtf16,
8152
                                                     &ipdef->ranges[0].start) < 0 ||
8153
                            vboxSocketParseAddrUtf16(data, toIPAddressUtf16,
8154
                                                     &ipdef->ranges[0].end) < 0) {
8155 8156
                            errorOccurred = true;
                        }
8157 8158 8159 8160 8161

                        VBOX_UTF16_FREE(ipAddressUtf16);
                        VBOX_UTF16_FREE(networkMaskUtf16);
                        VBOX_UTF16_FREE(fromIPAddressUtf16);
                        VBOX_UTF16_FREE(toIPAddressUtf16);
8162 8163 8164 8165

                        if (errorOccurred) {
                            goto cleanup;
                        }
8166
                    } else {
8167
                        ipdef->nranges = 0;
8168
                        virReportOOMError();
8169
                    }
8170

8171
                    ipdef->nhosts = 1;
8172
                    if (VIR_ALLOC_N(ipdef->hosts, ipdef->nhosts) >=0) {
8173 8174 8175 8176
                        ipdef->hosts[0].name = strdup(network->name);
                        if (ipdef->hosts[0].name == NULL) {
                            VIR_FREE(ipdef->hosts);
                            ipdef->nhosts = 0;
8177
                            virReportOOMError();
8178
                        } else {
8179 8180
                            PRUnichar *macAddressUtf16 = NULL;
                            PRUnichar *ipAddressUtf16  = NULL;
8181
                            bool errorOccurred = false;
8182

8183
                            networkInterface->vtbl->GetHardwareAddress(networkInterface, &macAddressUtf16);
8184 8185
                            networkInterface->vtbl->GetIPAddress(networkInterface, &ipAddressUtf16);

8186
                            VBOX_UTF16_TO_UTF8(macAddressUtf16, &ipdef->hosts[0].mac);
8187 8188

                            if (vboxSocketParseAddrUtf16(data, ipAddressUtf16,
8189
                                                         &ipdef->hosts[0].ip) < 0) {
8190 8191
                                errorOccurred = true;
                            }
8192

8193 8194
                            VBOX_UTF16_FREE(macAddressUtf16);
                            VBOX_UTF16_FREE(ipAddressUtf16);
8195 8196 8197 8198

                            if (errorOccurred) {
                                goto cleanup;
                            }
8199 8200
                        }
                    } else {
8201
                        ipdef->nhosts = 0;
8202
                    }
8203 8204 8205 8206 8207

                    VBOX_RELEASE(dhcpServer);
                } else {
                    PRUnichar *networkMaskUtf16 = NULL;
                    PRUnichar *ipAddressUtf16   = NULL;
8208
                    bool errorOccurred = false;
8209 8210 8211 8212

                    networkInterface->vtbl->GetNetworkMask(networkInterface, &networkMaskUtf16);
                    networkInterface->vtbl->GetIPAddress(networkInterface, &ipAddressUtf16);

8213
                    if (vboxSocketParseAddrUtf16(data, networkMaskUtf16,
8214
                                                 &ipdef->netmask) < 0 ||
8215
                        vboxSocketParseAddrUtf16(data, ipAddressUtf16,
8216
                                                 &ipdef->address) < 0) {
8217 8218
                        errorOccurred = true;
                    }
8219 8220 8221

                    VBOX_UTF16_FREE(networkMaskUtf16);
                    VBOX_UTF16_FREE(ipAddressUtf16);
8222 8223 8224 8225

                    if (errorOccurred) {
                        goto cleanup;
                    }
8226 8227
                }

8228 8229
                DEBUGIID("Network UUID", vboxnet0IID.value);
                vboxIIDUnalloc(&vboxnet0IID);
8230 8231
                VBOX_UTF16_FREE(networkNameUtf16);
            } else {
8232
                virReportOOMError();
8233 8234
            }
        }
8235 8236

        VBOX_RELEASE(networkInterface);
8237 8238
    }

8239 8240 8241
    VBOX_UTF16_FREE(networkInterfaceNameUtf16);
    VBOX_RELEASE(host);

8242
    ret = virNetworkDefFormat(def, 0);
8243 8244

cleanup:
8245
    virNetworkDefFree(def);
8246 8247 8248 8249
    VIR_FREE(networkNameUtf8);
    return ret;
}

8250 8251 8252 8253
/**
 * The Storage Functions here on
 */

8254 8255 8256
static virDrvOpenStatus vboxStorageOpen(virConnectPtr conn,
                                        virConnectAuthPtr auth ATTRIBUTE_UNUSED,
                                        unsigned int flags)
E
Eric Blake 已提交
8257
{
8258 8259
    vboxGlobalData *data = conn->privateData;

E
Eric Blake 已提交
8260 8261
    virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);

8262
    if (STRNEQ(conn->driver->name, "VBOX"))
8263
        return VIR_DRV_OPEN_DECLINED;
8264 8265 8266 8267

    if ((data->pFuncs      == NULL) ||
        (data->vboxObj     == NULL) ||
        (data->vboxSession == NULL))
8268
        return VIR_DRV_OPEN_ERROR;
8269

8270
    VIR_DEBUG("vbox storage initialized");
8271 8272 8273 8274
    /* conn->storagePrivateData = some storage specific data */
    return VIR_DRV_OPEN_SUCCESS;
}

8275
static int vboxStorageClose(virConnectPtr conn) {
8276
    VIR_DEBUG("vbox storage uninitialized");
8277 8278 8279 8280 8281 8282 8283 8284 8285 8286 8287 8288 8289
    conn->storagePrivateData = NULL;
    return 0;
}

static int vboxStorageNumOfPools(virConnectPtr conn ATTRIBUTE_UNUSED) {

    /** Currently only one pool supported, the default one
     * given by ISystemProperties::defaultHardDiskFolder()
     */

    return 1;
}

8290 8291
static int vboxStorageListPools(virConnectPtr conn ATTRIBUTE_UNUSED,
                                char **const names, int nnames) {
8292 8293 8294 8295 8296
    int numActive = 0;

    if (nnames == 1) {
        names[numActive] = strdup("default-pool");
        if (names[numActive] == NULL) {
8297
            virReportOOMError();
8298 8299 8300 8301 8302 8303 8304 8305 8306 8307 8308 8309 8310 8311 8312 8313 8314 8315
        } else {
            numActive++;
        }
    }
    return numActive;
}

static virStoragePoolPtr vboxStoragePoolLookupByName(virConnectPtr conn, const char *name) {
    virStoragePoolPtr ret = NULL;

    /** Current limitation of the function: since
     * the default pool doesn't have UUID just assign
     * one till vbox can handle pools
     */
    if (STREQ("default-pool", name)) {
        unsigned char uuid[VIR_UUID_BUFLEN];
        const char *uuidstr = "1deff1ff-1481-464f-967f-a50fe8936cc4";

8316
        ignore_value(virUUIDParse(uuidstr, uuid));
8317

8318
        ret = virGetStoragePool(conn, name, uuid, NULL, NULL);
8319 8320 8321 8322 8323 8324
    }

    return ret;
}

static int vboxStoragePoolNumOfVolumes(virStoragePoolPtr pool) {
8325
    VBOX_OBJECT_CHECK(pool->conn, int, -1);
8326
    vboxArray hardDisks = VBOX_ARRAY_INITIALIZER;
8327 8328 8329 8330
    PRUint32 hardDiskAccessible = 0;
    nsresult rc;
    int i;

8331
    rc = vboxArrayGet(&hardDisks, data->vboxObj, data->vboxObj->vtbl->GetHardDisks);
8332
    if (NS_SUCCEEDED(rc)) {
8333 8334
        for (i = 0; i < hardDisks.count; ++i) {
            IHardDisk *hardDisk = hardDisks.items[i];
8335 8336
            if (hardDisk) {
                PRUint32 hddstate;
8337

8338 8339 8340
                VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetState, &hddstate);
                if (hddstate != MediaState_Inaccessible)
                    hardDiskAccessible++;
8341 8342
            }
        }
8343 8344 8345 8346

        vboxArrayRelease(&hardDisks);

        ret = hardDiskAccessible;
8347
    } else {
8348
        ret = -1;
8349 8350 8351
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not get number of volumes in the pool: %s, rc=%08x"),
                       pool->name, (unsigned)rc);
8352 8353
    }

8354
    return ret;
8355 8356 8357
}

static int vboxStoragePoolListVolumes(virStoragePoolPtr pool, char **const names, int nnames) {
8358
    VBOX_OBJECT_CHECK(pool->conn, int, -1);
8359
    vboxArray hardDisks = VBOX_ARRAY_INITIALIZER;
8360 8361 8362 8363
    PRUint32 numActive     = 0;
    nsresult rc;
    int i;

8364
    rc = vboxArrayGet(&hardDisks, data->vboxObj, data->vboxObj->vtbl->GetHardDisks);
8365
    if (NS_SUCCEEDED(rc)) {
8366 8367
        for (i = 0; i < hardDisks.count && numActive < nnames; ++i) {
            IHardDisk *hardDisk = hardDisks.items[i];
8368

8369 8370 8371 8372
            if (hardDisk) {
                PRUint32 hddstate;
                char      *nameUtf8  = NULL;
                PRUnichar *nameUtf16 = NULL;
8373

8374 8375 8376
                VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetState, &hddstate);
                if (hddstate != MediaState_Inaccessible) {
                    VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetName, &nameUtf16);
8377

8378 8379
                    VBOX_UTF16_TO_UTF8(nameUtf16, &nameUtf8);
                    VBOX_UTF16_FREE(nameUtf16);
8380

8381
                    if (nameUtf8) {
8382
                        VIR_DEBUG("nnames[%d]: %s", numActive, nameUtf8);
8383 8384
                        names[numActive] = strdup(nameUtf8);
                        if (names[numActive] == NULL) {
8385
                            virReportOOMError();
8386 8387
                        } else {
                            numActive++;
8388
                        }
8389 8390

                        VBOX_UTF8_FREE(nameUtf8);
8391 8392 8393 8394
                    }
                }
            }
        }
8395 8396 8397 8398

        vboxArrayRelease(&hardDisks);

        ret = numActive;
8399
    } else {
8400
        ret = -1;
8401 8402 8403
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not get the volume list in the pool: %s, rc=%08x"),
                       pool->name, (unsigned)rc);
8404 8405
    }

8406
    return ret;
8407 8408 8409
}

static virStorageVolPtr vboxStorageVolLookupByName(virStoragePoolPtr pool, const char *name) {
8410
    VBOX_OBJECT_CHECK(pool->conn, virStorageVolPtr, NULL);
8411
    vboxArray hardDisks = VBOX_ARRAY_INITIALIZER;
8412 8413 8414
    nsresult rc;
    int i;

8415
    if (!name)
8416
        return ret;
8417

8418
    rc = vboxArrayGet(&hardDisks, data->vboxObj, data->vboxObj->vtbl->GetHardDisks);
8419
    if (NS_SUCCEEDED(rc)) {
8420 8421
        for (i = 0; i < hardDisks.count; ++i) {
            IHardDisk *hardDisk = hardDisks.items[i];
8422

8423 8424 8425 8426
            if (hardDisk) {
                PRUint32 hddstate;
                char      *nameUtf8  = NULL;
                PRUnichar *nameUtf16 = NULL;
8427

8428 8429 8430
                VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetState, &hddstate);
                if (hddstate != MediaState_Inaccessible) {
                    VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetName, &nameUtf16);
8431

8432 8433 8434 8435
                    if (nameUtf16) {
                        VBOX_UTF16_TO_UTF8(nameUtf16, &nameUtf8);
                        VBOX_UTF16_FREE(nameUtf16);
                    }
8436

8437
                    if (nameUtf8 && STREQ(nameUtf8, name)) {
8438 8439 8440
                        vboxIID hddIID = VBOX_IID_INITIALIZER;
                        unsigned char uuid[VIR_UUID_BUFLEN];
                        char key[VIR_UUID_STRING_BUFLEN] = "";
8441

8442 8443 8444 8445
                        rc = VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetId, &hddIID.value);
                        if (NS_SUCCEEDED(rc)) {
                            vboxIIDToUUID(&hddIID, uuid);
                            virUUIDFormat(uuid, key);
8446

8447 8448
                            ret = virGetStorageVol(pool->conn, pool->name, name, key,
                                                   NULL, NULL);
8449

8450 8451 8452 8453
                            VIR_DEBUG("virStorageVolPtr: %p", ret);
                            VIR_DEBUG("Storage Volume Name: %s", name);
                            VIR_DEBUG("Storage Volume key : %s", key);
                            VIR_DEBUG("Storage Volume Pool: %s", pool->name);
8454 8455
                        }

8456
                        vboxIIDUnalloc(&hddIID);
8457 8458
                        VBOX_UTF8_FREE(nameUtf8);
                        break;
8459
                    }
8460 8461 8462

                    if (nameUtf8)
                        VBOX_UTF8_FREE(nameUtf8);
8463 8464 8465
                }
            }
        }
8466

8467
        vboxArrayRelease(&hardDisks);
8468 8469 8470 8471 8472 8473
    }

    return ret;
}

static virStorageVolPtr vboxStorageVolLookupByKey(virConnectPtr conn, const char *key) {
8474
    VBOX_OBJECT_CHECK(conn, virStorageVolPtr, NULL);
8475 8476
    vboxIID hddIID = VBOX_IID_INITIALIZER;
    unsigned char uuid[VIR_UUID_BUFLEN];
8477 8478 8479
    IHardDisk *hardDisk  = NULL;
    nsresult rc;

8480 8481 8482
    if (!key)
        return ret;

8483
    if (virUUIDParse(key, uuid) < 0) {
8484 8485
        virReportError(VIR_ERR_INVALID_ARG,
                       _("Could not parse UUID from '%s'"), key);
8486
        return NULL;
8487 8488
    }

8489
    vboxIIDFromUUID(&hddIID, uuid);
8490
#if VBOX_API_VERSION < 4000
8491
    rc = data->vboxObj->vtbl->GetHardDisk(data->vboxObj, hddIID.value, &hardDisk);
8492 8493 8494 8495
#else /* VBOX_API_VERSION >= 4000 */
    rc = data->vboxObj->vtbl->FindMedium(data->vboxObj, hddIID.value,
                                         DeviceType_HardDisk, &hardDisk);
#endif /* VBOX_API_VERSION >= 4000 */
8496 8497
    if (NS_SUCCEEDED(rc)) {
        PRUint32 hddstate;
8498

8499 8500 8501 8502
        VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetState, &hddstate);
        if (hddstate != MediaState_Inaccessible) {
            PRUnichar *hddNameUtf16 = NULL;
            char      *hddNameUtf8  = NULL;
8503

8504 8505
            VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetName, &hddNameUtf16);
            VBOX_UTF16_TO_UTF8(hddNameUtf16, &hddNameUtf8);
8506

8507 8508
            if (hddNameUtf8) {
                if (vboxStorageNumOfPools(conn) == 1) {
8509 8510
                    ret = virGetStorageVol(conn, "default-pool", hddNameUtf8, key,
                                           NULL, NULL);
8511
                    VIR_DEBUG("Storage Volume Pool: %s", "default-pool");
8512 8513 8514 8515
                } else {
                    /* TODO: currently only one default pool and thus
                     * nothing here, change it when pools are supported
                     */
8516 8517
                }

8518 8519
                VIR_DEBUG("Storage Volume Name: %s", key);
                VIR_DEBUG("Storage Volume key : %s", hddNameUtf8);
8520 8521 8522

                VBOX_UTF8_FREE(hddNameUtf8);
                VBOX_UTF16_FREE(hddNameUtf16);
8523 8524
            }
        }
8525 8526

        VBOX_MEDIUM_RELEASE(hardDisk);
8527 8528
    }

8529
    vboxIIDUnalloc(&hddIID);
8530 8531 8532 8533
    return ret;
}

static virStorageVolPtr vboxStorageVolLookupByPath(virConnectPtr conn, const char *path) {
8534
    VBOX_OBJECT_CHECK(conn, virStorageVolPtr, NULL);
8535 8536 8537 8538
    PRUnichar *hddPathUtf16 = NULL;
    IHardDisk *hardDisk     = NULL;
    nsresult rc;

8539 8540
    if (!path)
        return ret;
8541

8542
    VBOX_UTF8_TO_UTF16(path, &hddPathUtf16);
8543

8544 8545
    if (!hddPathUtf16)
        return ret;
8546

8547
#if VBOX_API_VERSION < 4000
8548
    rc = data->vboxObj->vtbl->FindHardDisk(data->vboxObj, hddPathUtf16, &hardDisk);
8549 8550 8551 8552
#else /* VBOX_API_VERSION >= 4000 */
    rc = data->vboxObj->vtbl->FindMedium(data->vboxObj, hddPathUtf16,
                                         DeviceType_HardDisk, &hardDisk);
#endif /* VBOX_API_VERSION >= 4000 */
8553 8554
    if (NS_SUCCEEDED(rc)) {
        PRUint32 hddstate;
8555

8556 8557 8558 8559
        VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetState, &hddstate);
        if (hddstate != MediaState_Inaccessible) {
            PRUnichar *hddNameUtf16 = NULL;
            char      *hddNameUtf8  = NULL;
8560

8561
            VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetName, &hddNameUtf16);
8562

8563 8564 8565 8566
            if (hddNameUtf16) {
                VBOX_UTF16_TO_UTF8(hddNameUtf16, &hddNameUtf8);
                VBOX_UTF16_FREE(hddNameUtf16);
            }
8567

8568 8569 8570 8571
            if (hddNameUtf8) {
                vboxIID hddIID = VBOX_IID_INITIALIZER;
                unsigned char uuid[VIR_UUID_BUFLEN];
                char key[VIR_UUID_STRING_BUFLEN] = "";
8572

8573 8574 8575 8576
                rc = VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetId, &hddIID.value);
                if (NS_SUCCEEDED(rc)) {
                    vboxIIDToUUID(&hddIID, uuid);
                    virUUIDFormat(uuid, key);
8577

8578 8579 8580 8581
                    /* TODO: currently only one default pool and thus
                     * the check below, change it when pools are supported
                     */
                    if (vboxStorageNumOfPools(conn) == 1)
8582 8583
                        ret = virGetStorageVol(conn, "default-pool", hddNameUtf8, key,
                                               NULL, NULL);
8584

8585 8586 8587
                    VIR_DEBUG("Storage Volume Pool: %s", "default-pool");
                    VIR_DEBUG("Storage Volume Name: %s", hddNameUtf8);
                    VIR_DEBUG("Storage Volume key : %s", key);
8588
                }
8589

8590
                vboxIIDUnalloc(&hddIID);
8591 8592
            }

8593 8594
            if (hddNameUtf8)
                VBOX_UTF8_FREE(hddNameUtf8);
8595
        }
8596 8597

        VBOX_MEDIUM_RELEASE(hardDisk);
8598 8599
    }

8600 8601
    VBOX_UTF16_FREE(hddPathUtf16);

8602 8603 8604 8605 8606
    return ret;
}

static virStorageVolPtr vboxStorageVolCreateXML(virStoragePoolPtr pool,
                                                const char *xml,
E
Eric Blake 已提交
8607 8608
                                                unsigned int flags)
{
8609
    VBOX_OBJECT_CHECK(pool->conn, virStorageVolPtr, NULL);
8610
    virStorageVolDefPtr  def  = NULL;
8611 8612
    PRUnichar *hddFormatUtf16 = NULL;
    PRUnichar *hddNameUtf16   = NULL;
8613 8614 8615
    virStoragePoolDef poolDef;
    nsresult rc;

E
Eric Blake 已提交
8616 8617
    virCheckFlags(0, NULL);

8618 8619 8620 8621 8622 8623 8624 8625
    /* since there is currently one default pool now
     * and virStorageVolDefFormat() just checks it type
     * so just assign it for now, change the behaviour
     * when vbox supports pools.
     */
    memset(&poolDef, 0, sizeof(poolDef));
    poolDef.type = VIR_STORAGE_POOL_DIR;

8626
    if ((def = virStorageVolDefParseString(&poolDef, xml)) == NULL)
8627 8628
        goto cleanup;

8629 8630
    if (!def->name ||
        (def->type != VIR_STORAGE_VOL_FILE))
8631
        goto cleanup;
8632

8633 8634 8635 8636 8637 8638
    /* TODO: for now only the vmdk, vpc and vdi type harddisk
     * variants can be created, also since there is no vdi
     * type in enum virStorageFileFormat {} the default
     * will be to create vdi if nothing is specified in
     * def->target.format
     */
8639

8640 8641 8642 8643 8644 8645 8646
    if (def->target.format == VIR_STORAGE_FILE_VMDK) {
        VBOX_UTF8_TO_UTF16("VMDK", &hddFormatUtf16);
    } else if (def->target.format == VIR_STORAGE_FILE_VPC) {
        VBOX_UTF8_TO_UTF16("VHD", &hddFormatUtf16);
    } else {
        VBOX_UTF8_TO_UTF16("VDI", &hddFormatUtf16);
    }
8647

8648
    VBOX_UTF8_TO_UTF16(def->name, &hddNameUtf16);
8649

8650 8651
    if (hddFormatUtf16 && hddNameUtf16) {
        IHardDisk *hardDisk = NULL;
8652

8653 8654 8655
        rc = data->vboxObj->vtbl->CreateHardDisk(data->vboxObj, hddFormatUtf16, hddNameUtf16, &hardDisk);
        if (NS_SUCCEEDED(rc)) {
            IProgress *progress    = NULL;
8656
            PRUint64   logicalSize = VIR_DIV_UP(def->capacity, 1024 * 1024);
8657
            PRUint32   variant     = HardDiskVariant_Standard;
8658

8659 8660
            if (def->capacity == def->allocation)
                variant = HardDiskVariant_Fixed;
8661

8662 8663
            rc = hardDisk->vtbl->CreateBaseStorage(hardDisk, logicalSize, variant, &progress);
            if (NS_SUCCEEDED(rc) && progress) {
8664
#if VBOX_API_VERSION == 2002
8665
                nsresult resultCode;
8666
#else
8667
                PRInt32  resultCode;
8668 8669
#endif

8670 8671
                progress->vtbl->WaitForCompletion(progress, -1);
                progress->vtbl->GetResultCode(progress, &resultCode);
8672

8673
                if (NS_SUCCEEDED(resultCode)) {
8674 8675 8676
                    vboxIID hddIID = VBOX_IID_INITIALIZER;
                    unsigned char uuid[VIR_UUID_BUFLEN];
                    char key[VIR_UUID_STRING_BUFLEN] = "";
8677

8678
                    rc = VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetId, &hddIID.value);
8679
                    if (NS_SUCCEEDED(rc)) {
8680 8681
                        vboxIIDToUUID(&hddIID, uuid);
                        virUUIDFormat(uuid, key);
8682

8683 8684
                        ret = virGetStorageVol(pool->conn, pool->name, def->name, key,
                                               NULL, NULL);
8685
                    }
8686 8687

                    vboxIIDUnalloc(&hddIID);
8688 8689
                }

8690
                VBOX_RELEASE(progress);
8691
            }
8692
        }
8693 8694
    }

8695 8696 8697
    VBOX_UTF16_FREE(hddFormatUtf16);
    VBOX_UTF16_FREE(hddNameUtf16);

8698 8699 8700 8701 8702 8703
cleanup:
    virStorageVolDefFree(def);
    return ret;
}

static int vboxStorageVolDelete(virStorageVolPtr vol,
E
Eric Blake 已提交
8704 8705
                                unsigned int flags)
{
8706
    VBOX_OBJECT_CHECK(vol->conn, int, -1);
8707 8708
    vboxIID hddIID = VBOX_IID_INITIALIZER;
    unsigned char uuid[VIR_UUID_BUFLEN];
8709 8710 8711
    IHardDisk *hardDisk  = NULL;
    int deregister = 0;
    nsresult rc;
8712 8713
    int i = 0;
    int j = 0;
8714

E
Eric Blake 已提交
8715 8716
    virCheckFlags(0, -1);

8717
    if (virUUIDParse(vol->key, uuid) < 0) {
8718 8719
        virReportError(VIR_ERR_INVALID_ARG,
                       _("Could not parse UUID from '%s'"), vol->key);
8720 8721
        return -1;
    }
8722

8723
    vboxIIDFromUUID(&hddIID, uuid);
8724
#if VBOX_API_VERSION < 4000
8725
    rc = data->vboxObj->vtbl->GetHardDisk(data->vboxObj, hddIID.value, &hardDisk);
8726 8727 8728 8729
#else /* VBOX_API_VERSION >= 4000 */
    rc = data->vboxObj->vtbl->FindMedium(data->vboxObj, hddIID.value,
                                         DeviceType_HardDisk, &hardDisk);
#endif /* VBOX_API_VERSION >= 4000 */
8730 8731
    if (NS_SUCCEEDED(rc)) {
        PRUint32 hddstate;
8732

8733 8734 8735
        VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetState, &hddstate);
        if (hddstate != MediaState_Inaccessible) {
            PRUint32  machineIdsSize = 0;
8736 8737 8738 8739 8740 8741 8742
            vboxArray machineIds = VBOX_ARRAY_INITIALIZER;

#if VBOX_API_VERSION < 3001
            vboxArrayGet(&machineIds, hardDisk, hardDisk->vtbl->imedium.GetMachineIds);
#else  /* VBOX_API_VERSION >= 3001 */
            vboxArrayGet(&machineIds, hardDisk, hardDisk->vtbl->GetMachineIds);
#endif /* VBOX_API_VERSION >= 3001 */
8743

8744 8745 8746 8747 8748 8749 8750
#if VBOX_API_VERSION == 2002 && defined WIN32
            /* VirtualBox 2.2 on Windows represents IIDs as GUIDs and the
             * machineIds array contains direct instances of the GUID struct
             * instead of pointers to the actual struct instances. But there
             * is no 128bit width simple item type for a SafeArray to fit a
             * GUID in. The largest simple type it 64bit width and VirtualBox
             * uses two of this 64bit items to represents one GUID. Therefore,
J
Ján Tomko 已提交
8751
             * we divide the size of the SafeArray by two, to compensate for
8752 8753 8754 8755
             * this workaround in VirtualBox */
            machineIds.count /= 2;
#endif /* VBOX_API_VERSION >= 2002 */

8756
            machineIdsSize = machineIds.count;
8757

8758
            for (i = 0; i < machineIds.count; i++) {
8759
                IMachine *machine = NULL;
8760 8761 8762
                vboxIID machineId = VBOX_IID_INITIALIZER;

                vboxIIDFromArrayItem(&machineId, &machineIds, i);
8763

8764 8765 8766
#if VBOX_API_VERSION >= 4000
                rc = VBOX_OBJECT_GET_MACHINE(machineId.value, &machine);
                if (NS_FAILED(rc)) {
8767 8768
                    virReportError(VIR_ERR_NO_DOMAIN, "%s",
                                   _("no domain with matching uuid"));
8769 8770 8771 8772 8773 8774
                    break;
                }
#endif

                rc = VBOX_SESSION_OPEN(machineId.value, machine);

8775
                if (NS_SUCCEEDED(rc)) {
8776

8777 8778
                    rc = data->vboxSession->vtbl->GetMachine(data->vboxSession, &machine);
                    if (NS_SUCCEEDED(rc)) {
8779
                        vboxArray hddAttachments = VBOX_ARRAY_INITIALIZER;
8780 8781

#if VBOX_API_VERSION < 3001
8782 8783
                        vboxArrayGet(&hddAttachments, machine,
                                     machine->vtbl->GetHardDiskAttachments);
8784
#else  /* VBOX_API_VERSION >= 3001 */
8785 8786
                        vboxArrayGet(&hddAttachments, machine,
                                     machine->vtbl->GetMediumAttachments);
8787
#endif /* VBOX_API_VERSION >= 3001 */
8788 8789
                        for (j = 0; j < hddAttachments.count; j++) {
                            IHardDiskAttachment *hddAttachment = hddAttachments.items[j];
8790 8791 8792 8793 8794 8795 8796 8797 8798 8799

                            if (hddAttachment) {
                                IHardDisk *hdd = NULL;

#if VBOX_API_VERSION < 3001
                                rc = hddAttachment->vtbl->GetHardDisk(hddAttachment, &hdd);
#else  /* VBOX_API_VERSION >= 3001 */
                                rc = hddAttachment->vtbl->GetMedium(hddAttachment, &hdd);
#endif /* VBOX_API_VERSION >= 3001 */
                                if (NS_SUCCEEDED(rc) && hdd) {
8800
                                    vboxIID iid = VBOX_IID_INITIALIZER;
8801

8802 8803
                                    rc = VBOX_MEDIUM_FUNC_ARG1(hdd, GetId, &iid.value);
                                    if (NS_SUCCEEDED(rc)) {
8804

8805 8806
                                            DEBUGIID("HardDisk (to delete) UUID", hddIID.value);
                                            DEBUGIID("HardDisk (currently processing) UUID", iid.value);
8807

8808
                                        if (vboxIIDIsEqual(&hddIID, &iid)) {
8809 8810 8811 8812
                                            PRUnichar *controller = NULL;
                                            PRInt32    port       = 0;
                                            PRInt32    device     = 0;

8813
                                            DEBUGIID("Found HardDisk to delete, UUID", hddIID.value);
8814 8815 8816 8817 8818 8819 8820 8821 8822 8823 8824 8825

                                            hddAttachment->vtbl->GetController(hddAttachment, &controller);
                                            hddAttachment->vtbl->GetPort(hddAttachment, &port);
                                            hddAttachment->vtbl->GetDevice(hddAttachment, &device);

#if VBOX_API_VERSION < 3001
                                            rc = machine->vtbl->DetachHardDisk(machine, controller, port, device);
#else  /* VBOX_API_VERSION >= 3001 */
                                            rc = machine->vtbl->DetachDevice(machine, controller, port, device);
#endif /* VBOX_API_VERSION >= 3001 */
                                            if (NS_SUCCEEDED(rc)) {
                                                rc = machine->vtbl->SaveSettings(machine);
8826
                                                VIR_DEBUG("saving machine settings");
8827
                                            }
8828

8829 8830
                                            if (NS_SUCCEEDED(rc)) {
                                                deregister++;
8831
                                                VIR_DEBUG("deregistering hdd:%d", deregister);
8832
                                            }
8833 8834 8835

                                            if (controller)
                                                VBOX_UTF16_FREE(controller);
8836
                                        }
8837
                                        vboxIIDUnalloc(&iid);
8838
                                    }
8839
                                    VBOX_MEDIUM_RELEASE(hdd);
8840 8841 8842
                                }
                            }
                        }
8843
                        vboxArrayRelease(&hddAttachments);
8844
                        VBOX_RELEASE(machine);
8845
                    }
8846
                    VBOX_SESSION_CLOSE();
8847
                }
8848 8849

                vboxIIDUnalloc(&machineId);
8850
            }
8851

8852
            vboxArrayUnalloc(&machineIds);
8853

8854 8855
            if (machineIdsSize == 0 || machineIdsSize == deregister) {
                IProgress *progress = NULL;
8856

8857
                rc = hardDisk->vtbl->DeleteStorage(hardDisk, &progress);
8858

8859 8860 8861
                if (NS_SUCCEEDED(rc) && progress) {
                    progress->vtbl->WaitForCompletion(progress, -1);
                    VBOX_RELEASE(progress);
8862
                    DEBUGIID("HardDisk deleted, UUID", hddIID.value);
8863
                    ret = 0;
8864 8865 8866
                }
            }
        }
8867 8868

        VBOX_MEDIUM_RELEASE(hardDisk);
8869 8870
    }

8871
    vboxIIDUnalloc(&hddIID);
8872

8873 8874 8875 8876
    return ret;
}

static int vboxStorageVolGetInfo(virStorageVolPtr vol, virStorageVolInfoPtr info) {
8877
    VBOX_OBJECT_CHECK(vol->conn, int, -1);
8878
    IHardDisk *hardDisk  = NULL;
8879 8880
    unsigned char uuid[VIR_UUID_BUFLEN];
    vboxIID hddIID = VBOX_IID_INITIALIZER;
8881 8882
    nsresult rc;

8883
    if (!info)
8884
        return ret;
8885

8886
    if (virUUIDParse(vol->key, uuid) < 0) {
8887 8888
        virReportError(VIR_ERR_INVALID_ARG,
                       _("Could not parse UUID from '%s'"), vol->key);
8889
        return ret;
8890
    }
8891

8892
    vboxIIDFromUUID(&hddIID, uuid);
8893
#if VBOX_API_VERSION < 4000
8894
    rc = data->vboxObj->vtbl->GetHardDisk(data->vboxObj, hddIID.value, &hardDisk);
8895 8896 8897 8898
#else /* VBOX_API_VERSION >= 4000 */
    rc = data->vboxObj->vtbl->FindMedium(data->vboxObj, hddIID.value,
                                         DeviceType_HardDisk, &hardDisk);
#endif /* VBOX_API_VERSION >= 4000 */
8899 8900
    if (NS_SUCCEEDED(rc)) {
        PRUint32 hddstate;
8901

8902 8903
        VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetState, &hddstate);
        if (hddstate != MediaState_Inaccessible) {
8904
#if VBOX_API_VERSION < 4000
8905 8906
            PRUint64 hddLogicalSize;
            PRUint64 hddActualSize;
8907 8908 8909 8910
#else /* VBOX_API_VERSION >= 4000 */
            PRInt64 hddLogicalSize;
            PRInt64 hddActualSize;
#endif /* VBOX_API_VERSION >= 4000 */
8911

8912
            info->type = VIR_STORAGE_VOL_FILE;
8913

8914
            hardDisk->vtbl->GetLogicalSize(hardDisk, &hddLogicalSize);
8915
#if VBOX_API_VERSION < 4000
8916
            info->capacity = hddLogicalSize * 1024 * 1024; /* MB => Bytes */
8917 8918 8919
#else /* VBOX_API_VERSION >= 4000 */
            info->capacity = hddLogicalSize;
#endif /* VBOX_API_VERSION >= 4000 */
8920

8921 8922
            VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetSize, &hddActualSize);
            info->allocation = hddActualSize;
8923

8924
            ret = 0;
8925

8926 8927 8928 8929
            VIR_DEBUG("Storage Volume Name: %s", vol->name);
            VIR_DEBUG("Storage Volume Type: %s", info->type == VIR_STORAGE_VOL_BLOCK ? "Block" : "File");
            VIR_DEBUG("Storage Volume Capacity: %llu", info->capacity);
            VIR_DEBUG("Storage Volume Allocation: %llu", info->allocation);
8930
        }
8931 8932

        VBOX_MEDIUM_RELEASE(hardDisk);
8933 8934
    }

8935
    vboxIIDUnalloc(&hddIID);
8936

8937 8938 8939
    return ret;
}

E
Eric Blake 已提交
8940 8941
static char *vboxStorageVolGetXMLDesc(virStorageVolPtr vol, unsigned int flags)
{
8942
    VBOX_OBJECT_CHECK(vol->conn, char *, NULL);
8943
    IHardDisk *hardDisk  = NULL;
8944 8945
    unsigned char uuid[VIR_UUID_BUFLEN];
    vboxIID hddIID = VBOX_IID_INITIALIZER;
8946 8947 8948 8949 8950
    virStoragePoolDef pool;
    virStorageVolDef def;
    int defOk = 0;
    nsresult rc;

E
Eric Blake 已提交
8951 8952
    virCheckFlags(0, NULL);

8953 8954 8955
    memset(&pool, 0, sizeof(pool));
    memset(&def, 0, sizeof(def));

8956
    if (virUUIDParse(vol->key, uuid) < 0) {
8957 8958
        virReportError(VIR_ERR_INVALID_ARG,
                       _("Could not parse UUID from '%s'"), vol->key);
8959
        return ret;
8960
    }
8961

8962
    vboxIIDFromUUID(&hddIID, uuid);
8963
#if VBOX_API_VERSION < 4000
8964
    rc = data->vboxObj->vtbl->GetHardDisk(data->vboxObj, hddIID.value, &hardDisk);
8965 8966 8967 8968
#else /* VBOX_API_VERSION >= 4000 */
    rc = data->vboxObj->vtbl->FindMedium(data->vboxObj, hddIID.value,
                                         DeviceType_HardDisk, &hardDisk);
#endif /* VBOX_API_VERSION >= 4000 */
8969 8970 8971 8972 8973 8974
    if (NS_SUCCEEDED(rc)) {
        PRUint32 hddstate;

        VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetState, &hddstate);
        if (NS_SUCCEEDED(rc) && hddstate != MediaState_Inaccessible) {
            PRUnichar *hddFormatUtf16 = NULL;
8975
#if VBOX_API_VERSION < 4000
8976 8977
            PRUint64 hddLogicalSize;
            PRUint64 hddActualSize;
8978 8979 8980 8981
#else /* VBOX_API_VERSION >= 4000 */
            PRInt64 hddLogicalSize;
            PRInt64 hddActualSize;
#endif /* VBOX_API_VERSION >= 4000 */
8982 8983 8984 8985 8986 8987 8988 8989 8990 8991 8992

            /* since there is currently one default pool now
             * and virStorageVolDefFormat() just checks it type
             * so just assign it for now, change the behaviour
             * when vbox supports pools.
             */
            pool.type = VIR_STORAGE_POOL_DIR;
            def.type = VIR_STORAGE_VOL_FILE;
            defOk = 1;

            rc = hardDisk->vtbl->GetLogicalSize(hardDisk, &hddLogicalSize);
8993 8994
            if (NS_SUCCEEDED(rc) && defOk) {
#if VBOX_API_VERSION < 4000
8995
                def.capacity = hddLogicalSize * 1024 * 1024; /* MB => Bytes */
8996 8997 8998 8999
#else /* VBOX_API_VERSION >= 4000 */
                def.capacity = hddLogicalSize;
#endif /* VBOX_API_VERSION >= 4000 */
            } else
9000 9001 9002 9003 9004 9005 9006 9007 9008 9009 9010 9011 9012 9013 9014 9015 9016 9017 9018 9019 9020 9021 9022
                defOk = 0;

            rc = VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetSize, &hddActualSize);
            if (NS_SUCCEEDED(rc) && defOk)
                def.allocation = hddActualSize;
            else
                defOk = 0;

            def.name = strdup(vol->name);
            if (!(def.name && defOk))
                defOk = 0;

            def.key = strdup(vol->key);
            if (!(def.key && defOk))
                defOk = 0;

            rc = hardDisk->vtbl->GetFormat(hardDisk, &hddFormatUtf16);
            if (NS_SUCCEEDED(rc) && defOk) {
                char *hddFormatUtf8 = NULL;

                VBOX_UTF16_TO_UTF8(hddFormatUtf16, &hddFormatUtf8);
                if (hddFormatUtf8) {

9023
                    VIR_DEBUG("Storage Volume Format: %s", hddFormatUtf8);
9024 9025 9026 9027 9028

                    if (STRCASEEQ("vmdk", hddFormatUtf8))
                        def.target.format = VIR_STORAGE_FILE_VMDK;
                    else if (STRCASEEQ("vhd", hddFormatUtf8))
                        def.target.format = VIR_STORAGE_FILE_VPC;
9029
                    else
9030
                        def.target.format = VIR_STORAGE_FILE_RAW;
9031

9032 9033 9034
                    /* TODO: need to add vdi to enum virStorageFileFormat {}
                     * and then add it here
                     */
9035

9036
                    VBOX_UTF8_FREE(hddFormatUtf8);
9037 9038
                }

9039 9040 9041
                VBOX_UTF16_FREE(hddFormatUtf16);
            } else {
                defOk = 0;
9042 9043
            }
        }
9044 9045

        VBOX_MEDIUM_RELEASE(hardDisk);
9046 9047
    }

9048
    vboxIIDUnalloc(&hddIID);
9049

9050
    if (defOk)
9051
        ret = virStorageVolDefFormat(&pool, &def);
9052 9053 9054 9055 9056

    return ret;
}

static char *vboxStorageVolGetPath(virStorageVolPtr vol) {
9057
    VBOX_OBJECT_CHECK(vol->conn, char *, NULL);
9058
    IHardDisk *hardDisk  = NULL;
9059 9060
    unsigned char uuid[VIR_UUID_BUFLEN];
    vboxIID hddIID = VBOX_IID_INITIALIZER;
9061 9062
    nsresult rc;

9063
    if (virUUIDParse(vol->key, uuid) < 0) {
9064 9065
        virReportError(VIR_ERR_INVALID_ARG,
                       _("Could not parse UUID from '%s'"), vol->key);
9066
        return ret;
9067
    }
9068

9069
    vboxIIDFromUUID(&hddIID, uuid);
9070
#if VBOX_API_VERSION < 4000
9071
    rc = data->vboxObj->vtbl->GetHardDisk(data->vboxObj, hddIID.value, &hardDisk);
9072 9073 9074 9075
#else /* VBOX_API_VERSION >= 4000 */
    rc = data->vboxObj->vtbl->FindMedium(data->vboxObj, hddIID.value,
                                         DeviceType_HardDisk, &hardDisk);
#endif /* VBOX_API_VERSION >= 4000 */
9076 9077
    if (NS_SUCCEEDED(rc)) {
        PRUint32 hddstate;
9078

9079 9080 9081 9082
        VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetState, &hddstate);
        if (hddstate != MediaState_Inaccessible) {
            PRUnichar *hddLocationUtf16 = NULL;
            char      *hddLocationUtf8  = NULL;
9083

9084
            VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetLocation, &hddLocationUtf16);
9085

9086 9087
            VBOX_UTF16_TO_UTF8(hddLocationUtf16, &hddLocationUtf8);
            if (hddLocationUtf8) {
9088

9089 9090
                ret = strdup(hddLocationUtf8);
                if (!ret)
9091
                    virReportOOMError();
9092

9093 9094 9095
                VIR_DEBUG("Storage Volume Name: %s", vol->name);
                VIR_DEBUG("Storage Volume Path: %s", hddLocationUtf8);
                VIR_DEBUG("Storage Volume Pool: %s", vol->pool);
9096

9097
                VBOX_UTF8_FREE(hddLocationUtf8);
9098 9099
            }

9100
            VBOX_UTF16_FREE(hddLocationUtf16);
9101
        }
9102 9103

        VBOX_MEDIUM_RELEASE(hardDisk);
9104 9105
    }

9106
    vboxIIDUnalloc(&hddIID);
9107

9108 9109
    return ret;
}
9110

9111
#if VBOX_API_VERSION >= 4000
9112 9113 9114 9115
static char *
vboxDomainScreenshot(virDomainPtr dom,
                     virStreamPtr st,
                     unsigned int screen,
E
Eric Blake 已提交
9116
                     unsigned int flags)
9117 9118 9119 9120 9121 9122 9123 9124 9125 9126
{
    VBOX_OBJECT_CHECK(dom->conn, char *, NULL);
    IConsole *console = NULL;
    vboxIID iid = VBOX_IID_INITIALIZER;
    IMachine *machine = NULL;
    nsresult rc;
    char *tmp;
    int tmp_fd = -1;
    unsigned int max_screen;

E
Eric Blake 已提交
9127 9128
    virCheckFlags(0, NULL);

9129 9130 9131
    vboxIIDFromUUID(&iid, dom->uuid);
    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
    if (NS_FAILED(rc)) {
9132 9133
        virReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching uuid"));
9134 9135 9136 9137 9138
        return NULL;
    }

    rc = machine->vtbl->GetMonitorCount(machine, &max_screen);
    if (NS_FAILED(rc)) {
9139 9140
        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                       _("unable to get monitor count"));
9141 9142 9143 9144 9145
        VBOX_RELEASE(machine);
        return NULL;
    }

    if (screen >= max_screen) {
9146 9147 9148
        virReportError(VIR_ERR_INVALID_ARG,
                       _("screen ID higher than monitor "
                         "count (%d)"), max_screen);
9149 9150 9151 9152 9153 9154 9155 9156 9157 9158
        VBOX_RELEASE(machine);
        return NULL;
    }

    if (virAsprintf(&tmp, "%s/cache/libvirt/vbox.screendump.XXXXXX", LOCALSTATEDIR) < 0) {
        virReportOOMError();
        VBOX_RELEASE(machine);
        return NULL;
    }

9159 9160
    if ((tmp_fd = mkostemp(tmp, O_CLOEXEC)) == -1) {
        virReportSystemError(errno, _("mkostemp(\"%s\") failed"), tmp);
9161 9162 9163 9164 9165 9166 9167 9168 9169 9170 9171 9172 9173 9174 9175 9176 9177 9178 9179 9180 9181 9182 9183 9184
        VIR_FREE(tmp);
        VBOX_RELEASE(machine);
        return NULL;
    }


    rc = VBOX_SESSION_OPEN_EXISTING(iid.value, machine);
    if (NS_SUCCEEDED(rc)) {
        rc = data->vboxSession->vtbl->GetConsole(data->vboxSession, &console);
        if (NS_SUCCEEDED(rc) && console) {
            IDisplay *display = NULL;

            console->vtbl->GetDisplay(console, &display);

            if (display) {
                PRUint32 width, height, bitsPerPixel;
                PRUint32 screenDataSize;
                PRUint8 *screenData;

                rc = display->vtbl->GetScreenResolution(display, screen,
                                                        &width, &height,
                                                        &bitsPerPixel);

                if (NS_FAILED(rc) || !width || !height) {
9185 9186
                    virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                                   _("unable to get screen resolution"));
9187 9188 9189 9190 9191 9192 9193 9194
                    goto endjob;
                }

                rc = display->vtbl->TakeScreenShotPNGToArray(display, screen,
                                                             width, height,
                                                             &screenDataSize,
                                                             &screenData);
                if (NS_FAILED(rc)) {
9195 9196
                    virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                                   _("failed to take screenshot"));
9197 9198 9199 9200 9201 9202 9203 9204 9205 9206 9207 9208 9209 9210 9211
                    goto endjob;
                }

                if (safewrite(tmp_fd, (char *) screenData,
                              screenDataSize) < 0) {
                    virReportSystemError(errno, _("unable to write data "
                                                  "to '%s'"), tmp);
                    goto endjob;
                }

                if (VIR_CLOSE(tmp_fd) < 0) {
                    virReportSystemError(errno, _("unable to close %s"), tmp);
                    goto endjob;
                }

E
Eric Blake 已提交
9212
                if (virFDStreamOpenFile(st, tmp, 0, 0, O_RDONLY) < 0) {
9213 9214
                    virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                                   _("unable to open stream"));
9215 9216 9217 9218 9219 9220 9221 9222 9223 9224 9225 9226 9227 9228 9229
                    goto endjob;
                }

                ret = strdup("image/png");

endjob:
                VIR_FREE(screenData);
                VBOX_RELEASE(display);
            }
            VBOX_RELEASE(console);
        }
        VBOX_SESSION_CLOSE();
    }

    VIR_FORCE_CLOSE(tmp_fd);
E
Eric Blake 已提交
9230
    unlink(tmp);
9231 9232 9233 9234 9235
    VIR_FREE(tmp);
    VBOX_RELEASE(machine);
    vboxIIDUnalloc(&iid);
    return ret;
}
9236
#endif /* VBOX_API_VERSION >= 4000 */
9237

9238 9239 9240 9241 9242 9243 9244 9245 9246 9247 9248 9249 9250 9251 9252 9253 9254 9255 9256 9257 9258 9259

#define MATCH(FLAG) (flags & (FLAG))
static int
vboxListAllDomains(virConnectPtr conn,
                   virDomainPtr **domains,
                   unsigned int flags)
{
    VBOX_OBJECT_CHECK(conn, int, -1);
    vboxArray machines = VBOX_ARRAY_INITIALIZER;
    char      *machineNameUtf8  = NULL;
    PRUnichar *machineNameUtf16 = NULL;
    unsigned char uuid[VIR_UUID_BUFLEN];
    vboxIID iid = VBOX_IID_INITIALIZER;
    PRUint32 state;
    nsresult rc;
    int i;
    virDomainPtr dom;
    virDomainPtr *doms = NULL;
    int count = 0;
    bool active;
    PRUint32 snapshotCount;

O
Osier Yang 已提交
9260
    virCheckFlags(VIR_CONNECT_LIST_DOMAINS_FILTERS_ALL, -1);
9261 9262 9263 9264 9265 9266 9267 9268 9269 9270 9271 9272 9273 9274 9275 9276 9277 9278 9279 9280 9281 9282

    /* filter out flag options that will produce 0 results in vbox driver:
     * - managed save: vbox guests don't have managed save images
     * - autostart: vbox doesn't support autostarting guests
     * - persistance: vbox doesn't support transient guests
     */
    if ((MATCH(VIR_CONNECT_LIST_DOMAINS_TRANSIENT) &&
         !MATCH(VIR_CONNECT_LIST_DOMAINS_PERSISTENT)) ||
        (MATCH(VIR_CONNECT_LIST_DOMAINS_AUTOSTART) &&
         !MATCH(VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART)) ||
        (MATCH(VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE) &&
         !MATCH(VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE))) {
        if (domains &&
            VIR_ALLOC_N(*domains, 1) < 0)
            goto no_memory;

        ret = 0;
        goto cleanup;
    }

    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
    if (NS_FAILED(rc)) {
9283 9284
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Could not get list of domains, rc=%08x"), (unsigned)rc);
9285 9286 9287 9288 9289 9290 9291 9292 9293 9294 9295 9296 9297 9298 9299 9300 9301 9302 9303 9304 9305 9306 9307
        goto cleanup;
    }

    if (domains &&
        VIR_ALLOC_N(doms, machines.count + 1) < 0)
        goto no_memory;

    for (i = 0; i < machines.count; i++) {
        IMachine *machine = machines.items[i];

        if (machine) {
            PRBool isAccessible = PR_FALSE;
            machine->vtbl->GetAccessible(machine, &isAccessible);
            if (isAccessible) {
                machine->vtbl->GetState(machine, &state);

                if (state >= MachineState_FirstOnline &&
                    state <= MachineState_LastOnline)
                    active = true;
                else
                    active = false;

                /* filter by active state */
O
Osier Yang 已提交
9308
                if (MATCH(VIR_CONNECT_LIST_DOMAINS_FILTERS_ACTIVE) &&
9309 9310 9311 9312 9313
                    !((MATCH(VIR_CONNECT_LIST_DOMAINS_ACTIVE) && active) ||
                      (MATCH(VIR_CONNECT_LIST_DOMAINS_INACTIVE) && !active)))
                    continue;

                /* filter by snapshot existence */
O
Osier Yang 已提交
9314
                if (MATCH(VIR_CONNECT_LIST_DOMAINS_FILTERS_SNAPSHOT)) {
9315 9316
                    rc = machine->vtbl->GetSnapshotCount(machine, &snapshotCount);
                    if (NS_FAILED(rc)) {
9317
                        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
9318
                                       _("could not get snapshot count for listed domains"));
9319 9320 9321 9322 9323 9324 9325 9326 9327 9328
                        goto cleanup;
                    }
                    if (!((MATCH(VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT) &&
                           snapshotCount > 0) ||
                          (MATCH(VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT) &&
                           snapshotCount == 0)))
                        continue;
                }

                /* filter by machine state */
O
Osier Yang 已提交
9329
                if (MATCH(VIR_CONNECT_LIST_DOMAINS_FILTERS_STATE) &&
9330 9331 9332 9333 9334 9335 9336 9337 9338 9339 9340 9341 9342 9343 9344 9345 9346 9347 9348 9349 9350 9351 9352 9353 9354 9355 9356 9357 9358 9359 9360 9361 9362 9363 9364 9365 9366 9367 9368 9369 9370 9371 9372 9373 9374 9375 9376 9377 9378 9379 9380 9381 9382 9383 9384 9385 9386 9387 9388 9389 9390 9391 9392 9393 9394 9395 9396 9397 9398 9399
                    !((MATCH(VIR_CONNECT_LIST_DOMAINS_RUNNING) &&
                       state == MachineState_Running) ||
                      (MATCH(VIR_CONNECT_LIST_DOMAINS_PAUSED) &&
                       state == MachineState_Paused) ||
                      (MATCH(VIR_CONNECT_LIST_DOMAINS_SHUTOFF) &&
                       state == MachineState_PoweredOff) ||
                      (MATCH(VIR_CONNECT_LIST_DOMAINS_OTHER) &&
                       (state != MachineState_Running &&
                        state != MachineState_Paused &&
                        state != MachineState_PoweredOff))))
                    continue;

                /* just count the machines */
                if (!doms) {
                    count++;
                    continue;
                }

                machine->vtbl->GetName(machine, &machineNameUtf16);
                VBOX_UTF16_TO_UTF8(machineNameUtf16, &machineNameUtf8);
                machine->vtbl->GetId(machine, &iid.value);
                vboxIIDToUUID(&iid, uuid);
                vboxIIDUnalloc(&iid);

                dom = virGetDomain(conn, machineNameUtf8, uuid);

                VBOX_UTF8_FREE(machineNameUtf8);
                VBOX_UTF16_FREE(machineNameUtf16);

                if (!dom)
                    goto cleanup;

                if (active)
                    dom->id = i + 1;

                doms[count++] = dom;
            }
        }
    }

    if (doms) {
        /* safe to ignore, new size will be equal or less than
         * previous allocation*/
        ignore_value(VIR_REALLOC_N(doms, count + 1));
        *domains = doms;
        doms = NULL;
    }

    ret = count;

cleanup:
    if (doms) {
        for (i = 0; i < count; i++) {
            if (doms[i])
                virDomainFree(doms[i]);
        }
    }
    VIR_FREE(doms);

    vboxArrayRelease(&machines);
    return ret;

no_memory:
    virReportOOMError();
    goto cleanup;
}
#undef MATCH



9400 9401 9402 9403
/**
 * Function Tables
 */

9404
virDriver NAME(Driver) = {
9405 9406
    .no = VIR_DRV_VBOX,
    .name = "VBOX",
9407 9408 9409 9410 9411 9412 9413 9414 9415
    .open = vboxOpen, /* 0.6.3 */
    .close = vboxClose, /* 0.6.3 */
    .version = vboxGetVersion, /* 0.6.3 */
    .getHostname = virGetHostname, /* 0.6.3 */
    .getMaxVcpus = vboxGetMaxVcpus, /* 0.6.3 */
    .nodeGetInfo = nodeGetInfo, /* 0.6.3 */
    .getCapabilities = vboxGetCapabilities, /* 0.6.3 */
    .listDomains = vboxListDomains, /* 0.6.3 */
    .numOfDomains = vboxNumOfDomains, /* 0.6.3 */
9416
    .listAllDomains = vboxListAllDomains, /* 0.9.13 */
9417 9418 9419 9420 9421 9422 9423
    .domainCreateXML = vboxDomainCreateXML, /* 0.6.3 */
    .domainLookupByID = vboxDomainLookupByID, /* 0.6.3 */
    .domainLookupByUUID = vboxDomainLookupByUUID, /* 0.6.3 */
    .domainLookupByName = vboxDomainLookupByName, /* 0.6.3 */
    .domainSuspend = vboxDomainSuspend, /* 0.6.3 */
    .domainResume = vboxDomainResume, /* 0.6.3 */
    .domainShutdown = vboxDomainShutdown, /* 0.6.3 */
9424
    .domainShutdownFlags = vboxDomainShutdownFlags, /* 0.9.10 */
9425 9426
    .domainReboot = vboxDomainReboot, /* 0.6.3 */
    .domainDestroy = vboxDomainDestroy, /* 0.6.3 */
9427
    .domainDestroyFlags = vboxDomainDestroyFlags, /* 0.9.4 */
9428 9429 9430 9431 9432 9433 9434 9435 9436 9437 9438 9439 9440 9441 9442 9443
    .domainGetOSType = vboxDomainGetOSType, /* 0.6.3 */
    .domainSetMemory = vboxDomainSetMemory, /* 0.6.3 */
    .domainGetInfo = vboxDomainGetInfo, /* 0.6.3 */
    .domainGetState = vboxDomainGetState, /* 0.9.2 */
    .domainSave = vboxDomainSave, /* 0.6.3 */
    .domainSetVcpus = vboxDomainSetVcpus, /* 0.7.1 */
    .domainSetVcpusFlags = vboxDomainSetVcpusFlags, /* 0.8.5 */
    .domainGetVcpusFlags = vboxDomainGetVcpusFlags, /* 0.8.5 */
    .domainGetMaxVcpus = vboxDomainGetMaxVcpus, /* 0.7.1 */
    .domainGetXMLDesc = vboxDomainGetXMLDesc, /* 0.6.3 */
    .listDefinedDomains = vboxListDefinedDomains, /* 0.6.3 */
    .numOfDefinedDomains = vboxNumOfDefinedDomains, /* 0.6.3 */
    .domainCreate = vboxDomainCreate, /* 0.6.3 */
    .domainCreateWithFlags = vboxDomainCreateWithFlags, /* 0.8.2 */
    .domainDefineXML = vboxDomainDefineXML, /* 0.6.3 */
    .domainUndefine = vboxDomainUndefine, /* 0.6.3 */
9444
    .domainUndefineFlags = vboxDomainUndefineFlags, /* 0.9.5 */
9445 9446 9447 9448 9449 9450 9451
    .domainAttachDevice = vboxDomainAttachDevice, /* 0.6.3 */
    .domainAttachDeviceFlags = vboxDomainAttachDeviceFlags, /* 0.7.7 */
    .domainDetachDevice = vboxDomainDetachDevice, /* 0.6.3 */
    .domainDetachDeviceFlags = vboxDomainDetachDeviceFlags, /* 0.7.7 */
    .domainUpdateDeviceFlags = vboxDomainUpdateDeviceFlags, /* 0.8.0 */
    .nodeGetCellsFreeMemory = nodeGetCellsFreeMemory, /* 0.6.5 */
    .nodeGetFreeMemory = nodeGetFreeMemory, /* 0.6.5 */
9452
#if VBOX_API_VERSION >= 4000
9453
    .domainScreenshot = vboxDomainScreenshot, /* 0.9.2 */
9454
#endif
9455
#if VBOX_API_VERSION > 2002 && VBOX_API_VERSION < 4000
9456 9457
    .domainEventRegister = vboxDomainEventRegister, /* 0.7.0 */
    .domainEventDeregister = vboxDomainEventDeregister, /* 0.7.0 */
9458
#endif
9459 9460 9461 9462 9463
    .isEncrypted = vboxIsEncrypted, /* 0.7.3 */
    .isSecure = vboxIsSecure, /* 0.7.3 */
    .domainIsActive = vboxDomainIsActive, /* 0.7.3 */
    .domainIsPersistent = vboxDomainIsPersistent, /* 0.7.3 */
    .domainIsUpdated = vboxDomainIsUpdated, /* 0.8.6 */
9464
#if VBOX_API_VERSION > 2002 && VBOX_API_VERSION < 4000
9465 9466
    .domainEventRegisterAny = vboxDomainEventRegisterAny, /* 0.8.0 */
    .domainEventDeregisterAny = vboxDomainEventDeregisterAny, /* 0.8.0 */
9467
#endif
9468 9469 9470 9471 9472 9473
    .domainSnapshotCreateXML = vboxDomainSnapshotCreateXML, /* 0.8.0 */
    .domainSnapshotGetXMLDesc = vboxDomainSnapshotGetXMLDesc, /* 0.8.0 */
    .domainSnapshotNum = vboxDomainSnapshotNum, /* 0.8.0 */
    .domainSnapshotListNames = vboxDomainSnapshotListNames, /* 0.8.0 */
    .domainSnapshotLookupByName = vboxDomainSnapshotLookupByName, /* 0.8.0 */
    .domainHasCurrentSnapshot = vboxDomainHasCurrentSnapshot, /* 0.8.0 */
9474
    .domainSnapshotGetParent = vboxDomainSnapshotGetParent, /* 0.9.7 */
9475
    .domainSnapshotCurrent = vboxDomainSnapshotCurrent, /* 0.8.0 */
9476 9477
    .domainSnapshotIsCurrent = vboxDomainSnapshotIsCurrent, /* 0.9.13 */
    .domainSnapshotHasMetadata = vboxDomainSnapshotHasMetadata, /* 0.9.13 */
9478 9479
    .domainRevertToSnapshot = vboxDomainRevertToSnapshot, /* 0.8.0 */
    .domainSnapshotDelete = vboxDomainSnapshotDelete, /* 0.8.0 */
9480
    .isAlive = vboxIsAlive, /* 0.9.8 */
9481
};
9482 9483 9484

virNetworkDriver NAME(NetworkDriver) = {
    "VBOX",
9485 9486 9487 9488 9489 9490 9491 9492 9493 9494 9495 9496 9497 9498
    .open                   = vboxNetworkOpen, /* 0.6.4 */
    .close                  = vboxNetworkClose, /* 0.6.4 */
    .numOfNetworks          = vboxNumOfNetworks, /* 0.6.4 */
    .listNetworks           = vboxListNetworks, /* 0.6.4 */
    .numOfDefinedNetworks   = vboxNumOfDefinedNetworks, /* 0.6.4 */
    .listDefinedNetworks    = vboxListDefinedNetworks, /* 0.6.4 */
    .networkLookupByUUID    = vboxNetworkLookupByUUID, /* 0.6.4 */
    .networkLookupByName    = vboxNetworkLookupByName, /* 0.6.4 */
    .networkCreateXML       = vboxNetworkCreateXML, /* 0.6.4 */
    .networkDefineXML       = vboxNetworkDefineXML, /* 0.6.4 */
    .networkUndefine        = vboxNetworkUndefine, /* 0.6.4 */
    .networkCreate          = vboxNetworkCreate, /* 0.6.4 */
    .networkDestroy         = vboxNetworkDestroy, /* 0.6.4 */
    .networkGetXMLDesc      = vboxNetworkGetXMLDesc, /* 0.6.4 */
9499
};
9500 9501 9502

virStorageDriver NAME(StorageDriver) = {
    .name               = "VBOX",
9503 9504 9505 9506 9507 9508 9509 9510 9511 9512 9513 9514 9515 9516 9517 9518
    .open               = vboxStorageOpen, /* 0.7.1 */
    .close              = vboxStorageClose, /* 0.7.1 */
    .numOfPools         = vboxStorageNumOfPools, /* 0.7.1 */
    .listPools          = vboxStorageListPools, /* 0.7.1 */
    .poolLookupByName   = vboxStoragePoolLookupByName, /* 0.7.1 */
    .poolNumOfVolumes   = vboxStoragePoolNumOfVolumes, /* 0.7.1 */
    .poolListVolumes    = vboxStoragePoolListVolumes, /* 0.7.1 */

    .volLookupByName    = vboxStorageVolLookupByName, /* 0.7.1 */
    .volLookupByKey     = vboxStorageVolLookupByKey, /* 0.7.1 */
    .volLookupByPath    = vboxStorageVolLookupByPath, /* 0.7.1 */
    .volCreateXML       = vboxStorageVolCreateXML, /* 0.7.1 */
    .volDelete          = vboxStorageVolDelete, /* 0.7.1 */
    .volGetInfo         = vboxStorageVolGetInfo, /* 0.7.1 */
    .volGetXMLDesc      = vboxStorageVolGetXMLDesc, /* 0.7.1 */
    .volGetPath         = vboxStorageVolGetPath /* 0.7.1 */
9519
};