remote.c 169.2 KB
Newer Older
1
/*
2
 * remote.c: handlers for RPC method calls
3
 *
E
Eric Blake 已提交
4
 * Copyright (C) 2007-2013 Red Hat, Inc.
5 6 7 8 9 10 11 12 13 14 15 16
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library.  If not, see
O
Osier Yang 已提交
18
 * <http://www.gnu.org/licenses/>.
19 20 21 22 23 24
 *
 * Author: Richard W.M. Jones <rjones@redhat.com>
 */

#include <config.h>

25
#include "virerror.h"
26

27
#if WITH_POLKIT0
28 29
# include <polkit/polkit.h>
# include <polkit-dbus/polkit-dbus.h>
30 31
#endif

32
#include "remote.h"
33
#include "libvirtd.h"
34 35
#include "libvirt_internal.h"
#include "datatypes.h"
36
#include "viralloc.h"
37
#include "virlog.h"
C
Chris Lalancette 已提交
38
#include "stream.h"
39
#include "viruuid.h"
40
#include "vircommand.h"
41
#include "intprops.h"
42
#include "virnetserverservice.h"
J
Jim Fehlig 已提交
43
#include "virnetserver.h"
44
#include "virfile.h"
45
#include "virtypedparam.h"
46
#include "virdbus.h"
47
#include "virprocess.h"
48 49
#include "remote_protocol.h"
#include "qemu_protocol.h"
50
#include "lxc_protocol.h"
51
#include "virstring.h"
52 53

#define VIR_FROM_THIS VIR_FROM_RPC
54

55
#if SIZEOF_LONG < 8
E
Eric Blake 已提交
56 57 58
# define HYPER_TO_TYPE(_type, _to, _from)                               \
    do {                                                                \
        if ((_from) != (_type)(_from)) {                                \
59 60 61
            virReportError(VIR_ERR_OVERFLOW,                            \
                           _("conversion from hyper to %s overflowed"), \
                           #_type);                                     \
E
Eric Blake 已提交
62 63 64
            goto cleanup;                                               \
        }                                                               \
        (_to) = (_from);                                                \
65 66 67 68 69 70 71 72 73
    } while (0)

# define HYPER_TO_LONG(_to, _from) HYPER_TO_TYPE(long, _to, _from)
# define HYPER_TO_ULONG(_to, _from) HYPER_TO_TYPE(unsigned long, _to, _from)
#else
# define HYPER_TO_LONG(_to, _from) (_to) = (_from)
# define HYPER_TO_ULONG(_to, _from) (_to) = (_from)
#endif

74 75 76 77 78 79 80
static virDomainPtr get_nonnull_domain(virConnectPtr conn, remote_nonnull_domain domain);
static virNetworkPtr get_nonnull_network(virConnectPtr conn, remote_nonnull_network network);
static virInterfacePtr get_nonnull_interface(virConnectPtr conn, remote_nonnull_interface iface);
static virStoragePoolPtr get_nonnull_storage_pool(virConnectPtr conn, remote_nonnull_storage_pool pool);
static virStorageVolPtr get_nonnull_storage_vol(virConnectPtr conn, remote_nonnull_storage_vol vol);
static virSecretPtr get_nonnull_secret(virConnectPtr conn, remote_nonnull_secret secret);
static virNWFilterPtr get_nonnull_nwfilter(virConnectPtr conn, remote_nonnull_nwfilter nwfilter);
81
static virDomainSnapshotPtr get_nonnull_domain_snapshot(virDomainPtr dom, remote_nonnull_domain_snapshot snapshot);
82 83 84 85 86 87 88 89 90
static void make_nonnull_domain(remote_nonnull_domain *dom_dst, virDomainPtr dom_src);
static void make_nonnull_network(remote_nonnull_network *net_dst, virNetworkPtr net_src);
static void make_nonnull_interface(remote_nonnull_interface *interface_dst, virInterfacePtr interface_src);
static void make_nonnull_storage_pool(remote_nonnull_storage_pool *pool_dst, virStoragePoolPtr pool_src);
static void make_nonnull_storage_vol(remote_nonnull_storage_vol *vol_dst, virStorageVolPtr vol_src);
static void make_nonnull_node_device(remote_nonnull_node_device *dev_dst, virNodeDevicePtr dev_src);
static void make_nonnull_secret(remote_nonnull_secret *secret_dst, virSecretPtr secret_src);
static void make_nonnull_nwfilter(remote_nonnull_nwfilter *net_dst, virNWFilterPtr nwfilter_src);
static void make_nonnull_domain_snapshot(remote_nonnull_domain_snapshot *snapshot_dst, virDomainSnapshotPtr snapshot_src);
91

92 93 94 95 96
static virTypedParameterPtr
remoteDeserializeTypedParameters(remote_typed_param *args_params_val,
                                 u_int args_params_len,
                                 int limit,
                                 int *nparams);
97

98 99 100 101 102 103
static int
remoteSerializeDomainDiskErrors(virDomainDiskErrorPtr errors,
                                int nerrors,
                                remote_domain_disk_error **ret_errors_val,
                                u_int *ret_errors_len);

104 105
#include "remote_dispatch.h"
#include "qemu_dispatch.h"
106
#include "lxc_dispatch.h"
C
Chris Lalancette 已提交
107 108


109 110
/* Prototypes */
static void
111 112
remoteDispatchDomainEventSend(virNetServerClientPtr client,
                              virNetServerProgramPtr program,
113 114 115
                              int procnr,
                              xdrproc_t proc,
                              void *data);
116

117 118 119 120 121
static int remoteRelayDomainEventLifecycle(virConnectPtr conn ATTRIBUTE_UNUSED,
                                           virDomainPtr dom,
                                           int event,
                                           int detail,
                                           void *opaque)
122
{
123
    virNetServerClientPtr client = opaque;
124
    remote_domain_event_lifecycle_msg data;
125

126 127 128
    if (!client)
        return -1;

129
    VIR_DEBUG("Relaying domain lifecycle event %d %d", event, detail);
130

131
    /* build return data */
132
    memset(&data, 0, sizeof(data));
133
    make_nonnull_domain(&data.dom, dom);
134 135
    data.event = event;
    data.detail = detail;
136

137
    remoteDispatchDomainEventSend(client, remoteProgram,
138 139
                                  REMOTE_PROC_DOMAIN_EVENT_LIFECYCLE,
                                  (xdrproc_t)xdr_remote_domain_event_lifecycle_msg, &data);
140

141 142
    return 0;
}
143

144 145 146 147
static int remoteRelayDomainEventReboot(virConnectPtr conn ATTRIBUTE_UNUSED,
                                        virDomainPtr dom,
                                        void *opaque)
{
148
    virNetServerClientPtr client = opaque;
149 150 151 152 153
    remote_domain_event_reboot_msg data;

    if (!client)
        return -1;

154
    VIR_DEBUG("Relaying domain reboot event %s %d", dom->name, dom->id);
155 156

    /* build return data */
157
    memset(&data, 0, sizeof(data));
158
    make_nonnull_domain(&data.dom, dom);
159

160
    remoteDispatchDomainEventSend(client, remoteProgram,
161 162
                                  REMOTE_PROC_DOMAIN_EVENT_REBOOT,
                                  (xdrproc_t)xdr_remote_domain_event_reboot_msg, &data);
163 164 165 166

    return 0;
}

167

168 169 170 171 172
static int remoteRelayDomainEventRTCChange(virConnectPtr conn ATTRIBUTE_UNUSED,
                                           virDomainPtr dom,
                                           long long offset,
                                           void *opaque)
{
173
    virNetServerClientPtr client = opaque;
174 175 176 177 178
    remote_domain_event_rtc_change_msg data;

    if (!client)
        return -1;

179
    VIR_DEBUG("Relaying domain rtc change event %s %d %lld", dom->name, dom->id, offset);
180 181

    /* build return data */
182
    memset(&data, 0, sizeof(data));
183
    make_nonnull_domain(&data.dom, dom);
184 185
    data.offset = offset;

186
    remoteDispatchDomainEventSend(client, remoteProgram,
187 188
                                  REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE,
                                  (xdrproc_t)xdr_remote_domain_event_rtc_change_msg, &data);
189 190 191 192 193

    return 0;
}


194 195 196 197 198
static int remoteRelayDomainEventWatchdog(virConnectPtr conn ATTRIBUTE_UNUSED,
                                          virDomainPtr dom,
                                          int action,
                                          void *opaque)
{
199
    virNetServerClientPtr client = opaque;
200 201 202 203 204
    remote_domain_event_watchdog_msg data;

    if (!client)
        return -1;

205
    VIR_DEBUG("Relaying domain watchdog event %s %d %d", dom->name, dom->id, action);
206 207

    /* build return data */
208
    memset(&data, 0, sizeof(data));
209
    make_nonnull_domain(&data.dom, dom);
210 211
    data.action = action;

212
    remoteDispatchDomainEventSend(client, remoteProgram,
213 214
                                  REMOTE_PROC_DOMAIN_EVENT_WATCHDOG,
                                  (xdrproc_t)xdr_remote_domain_event_watchdog_msg, &data);
215 216 217 218 219

    return 0;
}


220 221 222 223 224 225 226
static int remoteRelayDomainEventIOError(virConnectPtr conn ATTRIBUTE_UNUSED,
                                         virDomainPtr dom,
                                         const char *srcPath,
                                         const char *devAlias,
                                         int action,
                                         void *opaque)
{
227
    virNetServerClientPtr client = opaque;
228 229 230 231 232
    remote_domain_event_io_error_msg data;

    if (!client)
        return -1;

233
    VIR_DEBUG("Relaying domain io error %s %d %s %s %d", dom->name, dom->id, srcPath, devAlias, action);
234 235

    /* build return data */
236
    memset(&data, 0, sizeof(data));
237 238 239
    if (VIR_STRDUP(data.srcPath, srcPath) < 0 ||
        VIR_STRDUP(data.devAlias, devAlias) < 0)
        goto error;
240
    make_nonnull_domain(&data.dom, dom);
241 242
    data.action = action;

243
    remoteDispatchDomainEventSend(client, remoteProgram,
244 245
                                  REMOTE_PROC_DOMAIN_EVENT_IO_ERROR,
                                  (xdrproc_t)xdr_remote_domain_event_io_error_msg, &data);
246 247

    return 0;
248
error:
E
Eric Blake 已提交
249 250
    VIR_FREE(data.srcPath);
    VIR_FREE(data.devAlias);
251
    return -1;
252 253 254
}


255 256 257 258 259 260 261 262
static int remoteRelayDomainEventIOErrorReason(virConnectPtr conn ATTRIBUTE_UNUSED,
                                               virDomainPtr dom,
                                               const char *srcPath,
                                               const char *devAlias,
                                               int action,
                                               const char *reason,
                                               void *opaque)
{
263
    virNetServerClientPtr client = opaque;
264 265 266 267 268
    remote_domain_event_io_error_reason_msg data;

    if (!client)
        return -1;

269 270
    VIR_DEBUG("Relaying domain io error %s %d %s %s %d %s",
              dom->name, dom->id, srcPath, devAlias, action, reason);
271 272

    /* build return data */
273
    memset(&data, 0, sizeof(data));
274 275 276 277
    if (VIR_STRDUP(data.srcPath, srcPath) < 0 ||
        VIR_STRDUP(data.devAlias, devAlias) < 0 ||
        VIR_STRDUP(data.reason, reason) < 0)
        goto error;
278
    data.action = action;
279 280

    make_nonnull_domain(&data.dom, dom);
281

282
    remoteDispatchDomainEventSend(client, remoteProgram,
283 284
                                  REMOTE_PROC_DOMAIN_EVENT_IO_ERROR_REASON,
                                  (xdrproc_t)xdr_remote_domain_event_io_error_reason_msg, &data);
285 286

    return 0;
287

288
error:
E
Eric Blake 已提交
289 290 291
    VIR_FREE(data.srcPath);
    VIR_FREE(data.devAlias);
    VIR_FREE(data.reason);
292
    return -1;
293 294 295
}


296 297 298 299 300 301 302 303 304
static int remoteRelayDomainEventGraphics(virConnectPtr conn ATTRIBUTE_UNUSED,
                                          virDomainPtr dom,
                                          int phase,
                                          virDomainEventGraphicsAddressPtr local,
                                          virDomainEventGraphicsAddressPtr remote,
                                          const char *authScheme,
                                          virDomainEventGraphicsSubjectPtr subject,
                                          void *opaque)
{
305
    virNetServerClientPtr client = opaque;
306
    remote_domain_event_graphics_msg data;
307
    size_t i;
308 309 310 311

    if (!client)
        return -1;

312 313 314 315
    VIR_DEBUG("Relaying domain graphics event %s %d %d - %d %s %s  - %d %s %s - %s", dom->name, dom->id, phase,
              local->family, local->service, local->node,
              remote->family, remote->service, remote->node,
              authScheme);
316

317
    VIR_DEBUG("Subject %d", subject->nidentity);
318
    for (i = 0; i < subject->nidentity; i++) {
319
        VIR_DEBUG("  %s=%s", subject->identities[i].type, subject->identities[i].name);
320 321 322
    }

    /* build return data */
323
    memset(&data, 0, sizeof(data));
324 325 326
    data.phase = phase;
    data.local.family = local->family;
    data.remote.family = remote->family;
327 328 329 330 331 332
    if (VIR_STRDUP(data.authScheme, authScheme) < 0 ||
        VIR_STRDUP(data.local.node, local->node) < 0 ||
        VIR_STRDUP(data.local.service, local->service) < 0 ||
        VIR_STRDUP(data.remote.node, remote->node) < 0 ||
        VIR_STRDUP(data.remote.service, remote->service) < 0)
        goto error;
333 334

    data.subject.subject_len = subject->nidentity;
335
    if (VIR_ALLOC_N(data.subject.subject_val, data.subject.subject_len) < 0)
336
        goto error;
337

338
    for (i = 0; i < data.subject.subject_len; i++) {
339 340 341
        if (VIR_STRDUP(data.subject.subject_val[i].type, subject->identities[i].type) < 0 ||
            VIR_STRDUP(data.subject.subject_val[i].name, subject->identities[i].name) < 0)
            goto error;
342
    }
343
    make_nonnull_domain(&data.dom, dom);
344

345
    remoteDispatchDomainEventSend(client, remoteProgram,
346 347
                                  REMOTE_PROC_DOMAIN_EVENT_GRAPHICS,
                                  (xdrproc_t)xdr_remote_domain_event_graphics_msg, &data);
348 349

    return 0;
350

351
error:
E
Eric Blake 已提交
352 353 354 355 356
    VIR_FREE(data.authScheme);
    VIR_FREE(data.local.node);
    VIR_FREE(data.local.service);
    VIR_FREE(data.remote.node);
    VIR_FREE(data.remote.service);
357
    if (data.subject.subject_val != NULL) {
358
        for (i = 0; i < data.subject.subject_len; i++) {
E
Eric Blake 已提交
359 360
            VIR_FREE(data.subject.subject_val[i].type);
            VIR_FREE(data.subject.subject_val[i].name);
361
        }
E
Eric Blake 已提交
362
        VIR_FREE(data.subject.subject_val);
363 364
    }
    return -1;
365 366
}

367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
static int remoteRelayDomainEventBlockJob(virConnectPtr conn ATTRIBUTE_UNUSED,
                                          virDomainPtr dom,
                                          const char *path,
                                          int type,
                                          int status,
                                          void *opaque)
{
    virNetServerClientPtr client = opaque;
    remote_domain_event_block_job_msg data;

    if (!client)
        return -1;

    VIR_DEBUG("Relaying domain block job event %s %d %s %i, %i",
              dom->name, dom->id, path, type, status);

    /* build return data */
384
    memset(&data, 0, sizeof(data));
385 386
    if (VIR_STRDUP(data.path, path) < 0)
        goto error;
387 388
    data.type = type;
    data.status = status;
389
    make_nonnull_domain(&data.dom, dom);
390 391 392 393 394 395

    remoteDispatchDomainEventSend(client, remoteProgram,
                                  REMOTE_PROC_DOMAIN_EVENT_BLOCK_JOB,
                                  (xdrproc_t)xdr_remote_domain_event_block_job_msg, &data);

    return 0;
396
error:
E
Eric Blake 已提交
397
    VIR_FREE(data.path);
398
    return -1;
399 400
}

401

402 403 404 405
static int remoteRelayDomainEventControlError(virConnectPtr conn ATTRIBUTE_UNUSED,
                                              virDomainPtr dom,
                                              void *opaque)
{
406
    virNetServerClientPtr client = opaque;
407 408 409 410 411 412 413 414
    remote_domain_event_control_error_msg data;

    if (!client)
        return -1;

    VIR_DEBUG("Relaying domain control error %s %d", dom->name, dom->id);

    /* build return data */
415
    memset(&data, 0, sizeof(data));
416 417
    make_nonnull_domain(&data.dom, dom);

418
    remoteDispatchDomainEventSend(client, remoteProgram,
419 420 421 422 423 424 425
                                  REMOTE_PROC_DOMAIN_EVENT_CONTROL_ERROR,
                                  (xdrproc_t)xdr_remote_domain_event_control_error_msg, &data);

    return 0;
}


426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444
static int remoteRelayDomainEventDiskChange(virConnectPtr conn ATTRIBUTE_UNUSED,
                                            virDomainPtr dom,
                                            const char *oldSrcPath,
                                            const char *newSrcPath,
                                            const char *devAlias,
                                            int reason,
                                            void *opaque)
{
    virNetServerClientPtr client = opaque;
    remote_domain_event_disk_change_msg data;
    char **oldSrcPath_p = NULL, **newSrcPath_p = NULL;

    if (!client)
        return -1;

    VIR_DEBUG("Relaying domain %s %d disk change %s %s %s %d",
              dom->name, dom->id, oldSrcPath, newSrcPath, devAlias, reason);

    /* build return data */
445
    memset(&data, 0, sizeof(data));
446 447
    if (oldSrcPath &&
        ((VIR_ALLOC(oldSrcPath_p) < 0) ||
448
         VIR_STRDUP(*oldSrcPath_p, oldSrcPath) < 0))
449
        goto error;
450 451 452

    if (newSrcPath &&
        ((VIR_ALLOC(newSrcPath_p) < 0) ||
453
         VIR_STRDUP(*newSrcPath_p, newSrcPath) < 0))
454
        goto error;
455 456 457

    data.oldSrcPath = oldSrcPath_p;
    data.newSrcPath = newSrcPath_p;
458 459
    if (VIR_STRDUP(data.devAlias, devAlias) < 0)
        goto error;
460 461 462 463 464 465 466 467 468 469
    data.reason = reason;

    make_nonnull_domain(&data.dom, dom);

    remoteDispatchDomainEventSend(client, remoteProgram,
                                  REMOTE_PROC_DOMAIN_EVENT_DISK_CHANGE,
                                  (xdrproc_t)xdr_remote_domain_event_disk_change_msg, &data);

    return 0;

470
error:
M
Michal Privoznik 已提交
471 472
    VIR_FREE(oldSrcPath_p);
    VIR_FREE(newSrcPath_p);
473 474 475 476
    return -1;
}


477 478 479 480 481 482 483 484 485 486 487 488 489 490 491
static int remoteRelayDomainEventTrayChange(virConnectPtr conn ATTRIBUTE_UNUSED,
                                            virDomainPtr dom,
                                            const char *devAlias,
                                            int reason,
                                            void *opaque) {
    virNetServerClientPtr client = opaque;
    remote_domain_event_tray_change_msg data;

    if (!client)
        return -1;

    VIR_DEBUG("Relaying domain %s %d tray change devAlias: %s reason: %d",
              dom->name, dom->id, devAlias, reason);

    /* build return data */
492
    memset(&data, 0, sizeof(data));
493

494
    if (VIR_STRDUP(data.devAlias, devAlias) < 0)
495 496 497 498 499 500 501 502 503 504 505 506
        return -1;
    data.reason = reason;

    make_nonnull_domain(&data.dom, dom);

    remoteDispatchDomainEventSend(client, remoteProgram,
                                  REMOTE_PROC_DOMAIN_EVENT_TRAY_CHANGE,
                                  (xdrproc_t)xdr_remote_domain_event_tray_change_msg, &data);

    return 0;
}

O
Osier Yang 已提交
507 508
static int remoteRelayDomainEventPMWakeup(virConnectPtr conn ATTRIBUTE_UNUSED,
                                          virDomainPtr dom,
509
                                          int reason ATTRIBUTE_UNUSED,
O
Osier Yang 已提交
510 511 512 513 514 515 516 517 518 519
                                          void *opaque) {
    virNetServerClientPtr client = opaque;
    remote_domain_event_pmwakeup_msg data;

    if (!client)
        return -1;

    VIR_DEBUG("Relaying domain %s %d system pmwakeup", dom->name, dom->id);

    /* build return data */
520
    memset(&data, 0, sizeof(data));
O
Osier Yang 已提交
521 522 523 524 525 526 527 528 529
    make_nonnull_domain(&data.dom, dom);

    remoteDispatchDomainEventSend(client, remoteProgram,
                                  REMOTE_PROC_DOMAIN_EVENT_PMWAKEUP,
                                  (xdrproc_t)xdr_remote_domain_event_pmwakeup_msg, &data);

    return 0;
}

O
Osier Yang 已提交
530 531
static int remoteRelayDomainEventPMSuspend(virConnectPtr conn ATTRIBUTE_UNUSED,
                                           virDomainPtr dom,
532
                                           int reason ATTRIBUTE_UNUSED,
O
Osier Yang 已提交
533 534 535 536 537 538 539 540 541 542
                                           void *opaque) {
    virNetServerClientPtr client = opaque;
    remote_domain_event_pmsuspend_msg data;

    if (!client)
        return -1;

    VIR_DEBUG("Relaying domain %s %d system pmsuspend", dom->name, dom->id);

    /* build return data */
543
    memset(&data, 0, sizeof(data));
O
Osier Yang 已提交
544 545 546 547 548 549 550 551 552
    make_nonnull_domain(&data.dom, dom);

    remoteDispatchDomainEventSend(client, remoteProgram,
                                  REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND,
                                  (xdrproc_t)xdr_remote_domain_event_pmsuspend_msg, &data);

    return 0;
}

553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579
static int
remoteRelayDomainEventBalloonChange(virConnectPtr conn ATTRIBUTE_UNUSED,
                                    virDomainPtr dom,
                                    unsigned long long actual,
                                    void *opaque)
{
    virNetServerClientPtr client = opaque;
    remote_domain_event_balloon_change_msg data;

    if (!client)
        return -1;

    VIR_DEBUG("Relaying domain balloon change event %s %d %lld", dom->name, dom->id, actual);

    /* build return data */
    memset(&data, 0, sizeof(data));
    make_nonnull_domain(&data.dom, dom);
    data.actual = actual;

    remoteDispatchDomainEventSend(client, remoteProgram,
                                  REMOTE_PROC_DOMAIN_EVENT_BALLOON_CHANGE,
                                  (xdrproc_t)xdr_remote_domain_event_balloon_change_msg, &data);

    return 0;
}


580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602
static int remoteRelayDomainEventPMSuspendDisk(virConnectPtr conn ATTRIBUTE_UNUSED,
                                               virDomainPtr dom,
                                               int reason ATTRIBUTE_UNUSED,
                                               void *opaque) {
    virNetServerClientPtr client = opaque;
    remote_domain_event_pmsuspend_disk_msg data;

    if (!client)
        return -1;

    VIR_DEBUG("Relaying domain %s %d system pmsuspend-disk", dom->name, dom->id);

    /* build return data */
    memset(&data, 0, sizeof(data));
    make_nonnull_domain(&data.dom, dom);

    remoteDispatchDomainEventSend(client, remoteProgram,
                                  REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND_DISK,
                                  (xdrproc_t)xdr_remote_domain_event_pmsuspend_disk_msg, &data);

    return 0;
}

603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633
static int
remoteRelayDomainEventDeviceRemoved(virConnectPtr conn ATTRIBUTE_UNUSED,
                                    virDomainPtr dom,
                                    const char *devAlias,
                                    void *opaque)
{
    virNetServerClientPtr client = opaque;
    remote_domain_event_device_removed_msg data;

    if (!client)
        return -1;

    VIR_DEBUG("Relaying domain device removed event %s %d %s",
              dom->name, dom->id, devAlias);

    /* build return data */
    memset(&data, 0, sizeof(data));

    if (VIR_STRDUP(data.devAlias, devAlias) < 0)
        return -1;

    make_nonnull_domain(&data.dom, dom);

    remoteDispatchDomainEventSend(client, remoteProgram,
                                  REMOTE_PROC_DOMAIN_EVENT_DEVICE_REMOVED,
                                  (xdrproc_t)xdr_remote_domain_event_device_removed_msg,
                                  &data);

    return 0;
}

634

635
static virConnectDomainEventGenericCallback domainEventCallbacks[] = {
636
    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventLifecycle),
637
    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventReboot),
638
    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventRTCChange),
639
    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventWatchdog),
640
    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventIOError),
641
    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventGraphics),
642
    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventIOErrorReason),
643
    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventControlError),
644
    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventBlockJob),
645
    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventDiskChange),
646
    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventTrayChange),
O
Osier Yang 已提交
647
    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventPMWakeup),
O
Osier Yang 已提交
648
    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventPMSuspend),
649
    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventBalloonChange),
650
    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventPMSuspendDisk),
651
    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventDeviceRemoved),
652 653 654 655
};

verify(ARRAY_CARDINALITY(domainEventCallbacks) == VIR_DOMAIN_EVENT_ID_LAST);

656 657 658 659 660 661 662
/*
 * You must hold lock for at least the client
 * We don't free stuff here, merely disconnect the client's
 * network socket & resources.
 * We keep the libvirt connection open until any async
 * jobs have finished, then clean it up elsewhere
 */
663
void remoteClientFreeFunc(void *data)
664 665 666 667 668
{
    struct daemonClientPrivate *priv = data;

    /* Deregister event delivery callback */
    if (priv->conn) {
669
        size_t i;
670

671
        for (i = 0; i < VIR_DOMAIN_EVENT_ID_LAST; i++) {
672
            if (priv->domainEventCallbackID[i] != -1) {
673
                VIR_DEBUG("Deregistering to relay remote events %zu", i);
674 675 676 677 678 679 680 681 682 683 684 685 686
                virConnectDomainEventDeregisterAny(priv->conn,
                                                   priv->domainEventCallbackID[i]);
            }
            priv->domainEventCallbackID[i] = -1;
        }

        virConnectClose(priv->conn);
    }

    VIR_FREE(priv);
}


687 688 689 690 691 692 693
static void remoteClientCloseFunc(virNetServerClientPtr client)
{
    struct daemonClientPrivate *priv = virNetServerClientGetPrivateData(client);

    daemonRemoveAllClientStreams(priv->streams);
}

694

695 696
void *remoteClientInitHook(virNetServerClientPtr client,
                           void *opaque ATTRIBUTE_UNUSED)
697 698
{
    struct daemonClientPrivate *priv;
699
    size_t i;
700

701
    if (VIR_ALLOC(priv) < 0)
702
        return NULL;
703 704 705

    if (virMutexInit(&priv->lock) < 0) {
        VIR_FREE(priv);
706
        virReportSystemError(errno, "%s", _("unable to init mutex"));
707
        return NULL;
708 709
    }

710
    for (i = 0; i < VIR_DOMAIN_EVENT_ID_LAST; i++)
711 712
        priv->domainEventCallbackID[i] = -1;

713
    virNetServerClientSetCloseHook(client, remoteClientCloseFunc);
714
    return priv;
715 716
}

717 718 719
/*----- Functions. -----*/

static int
720 721 722 723 724
remoteDispatchConnectOpen(virNetServerPtr server,
                          virNetServerClientPtr client,
                          virNetMessagePtr msg ATTRIBUTE_UNUSED,
                          virNetMessageErrorPtr rerr,
                          struct remote_connect_open_args *args)
725 726
{
    const char *name;
727
    unsigned int flags;
728
    struct daemonClientPrivate *priv = virNetServerClientGetPrivateData(client);
729
    int rv = -1;
730

731 732 733 734
    VIR_DEBUG("priv=%p conn=%p", priv, priv->conn);
    virMutexLock(&priv->lock);
    /* Already opened? */
    if (priv->conn) {
735
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection already open"));
736 737 738
        goto cleanup;
    }

739
    if (virNetServerKeepAliveRequired(server) && !priv->keepalive_supported) {
740 741
        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                       _("keepalive support is required to connect"));
742 743 744
        goto cleanup;
    }

745 746 747 748 749 750
    name = args->name ? *args->name : NULL;

    /* If this connection arrived on a readonly socket, force
     * the connection to be readonly.
     */
    flags = args->flags;
751 752
    if (virNetServerClientGetReadonly(client))
        flags |= VIR_CONNECT_RO;
753

754
    priv->conn =
755
        flags & VIR_CONNECT_RO
756 757
        ? virConnectOpenReadOnly(name)
        : virConnectOpen(name);
758

759
    if (priv->conn == NULL)
760 761 762
        goto cleanup;

    rv = 0;
763

764 765
cleanup:
    if (rv < 0)
766 767
        virNetMessageSaveError(rerr);
    virMutexUnlock(&priv->lock);
768
    return rv;
769 770 771 772
}


static int
773 774 775 776
remoteDispatchConnectClose(virNetServerPtr server ATTRIBUTE_UNUSED,
                           virNetServerClientPtr client ATTRIBUTE_UNUSED,
                           virNetMessagePtr msg ATTRIBUTE_UNUSED,
                           virNetMessageErrorPtr rerr ATTRIBUTE_UNUSED)
777
{
778
    virNetServerClientDelayedClose(client);
779
    return 0;
780 781
}

782

783
static int
784 785
remoteDispatchDomainGetSchedulerType(virNetServerPtr server ATTRIBUTE_UNUSED,
                                     virNetServerClientPtr client ATTRIBUTE_UNUSED,
786
                                     virNetMessagePtr msg ATTRIBUTE_UNUSED,
787
                                     virNetMessageErrorPtr rerr,
788 789
                                     remote_domain_get_scheduler_type_args *args,
                                     remote_domain_get_scheduler_type_ret *ret)
790
{
791
    virDomainPtr dom = NULL;
792 793
    char *type;
    int nparams;
794
    int rv = -1;
795 796
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
797

798
    if (!priv->conn) {
799
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
800
        goto cleanup;
801 802
    }

803
    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
804
        goto cleanup;
805

806
    if (!(type = virDomainGetSchedulerType(dom, &nparams)))
807
        goto cleanup;
808 809 810

    ret->type = type;
    ret->nparams = nparams;
811 812 813 814
    rv = 0;

cleanup:
    if (rv < 0)
815
        virNetMessageSaveError(rerr);
816 817 818
    if (dom)
        virDomainFree(dom);
    return rv;
819 820
}

821 822
/* Helper to serialize typed parameters. This also filters out any string
 * parameters that must not be returned to older clients.  */
823 824 825
static int
remoteSerializeTypedParameters(virTypedParameterPtr params,
                               int nparams,
826
                               remote_typed_param **ret_params_val,
827 828
                               u_int *ret_params_len,
                               unsigned int flags)
829
{
830 831
    size_t i;
    size_t j;
832 833 834 835
    int rv = -1;
    remote_typed_param *val;

    *ret_params_len = nparams;
836
    if (VIR_ALLOC_N(val, nparams) < 0)
837 838
        goto cleanup;

839
    for (i = 0, j = 0; i < nparams; ++i) {
840 841 842 843 844
        /* virDomainGetCPUStats can return a sparse array; also, we
         * can't pass back strings to older clients.  */
        if (!params[i].type ||
            (!(flags & VIR_TYPED_PARAM_STRING_OKAY) &&
             params[i].type == VIR_TYPED_PARAM_STRING)) {
845 846 847 848
            --*ret_params_len;
            continue;
        }

849
        /* remoteDispatchClientRequest will free this: */
850
        if (VIR_STRDUP(val[j].field, params[i].field) < 0)
851
            goto cleanup;
852
        val[j].value.type = params[i].type;
853
        switch (params[i].type) {
854
        case VIR_TYPED_PARAM_INT:
855
            val[j].value.remote_typed_param_value_u.i = params[i].value.i;
856 857
            break;
        case VIR_TYPED_PARAM_UINT:
858
            val[j].value.remote_typed_param_value_u.ui = params[i].value.ui;
859 860
            break;
        case VIR_TYPED_PARAM_LLONG:
861
            val[j].value.remote_typed_param_value_u.l = params[i].value.l;
862 863
            break;
        case VIR_TYPED_PARAM_ULLONG:
864
            val[j].value.remote_typed_param_value_u.ul = params[i].value.ul;
865 866
            break;
        case VIR_TYPED_PARAM_DOUBLE:
867
            val[j].value.remote_typed_param_value_u.d = params[i].value.d;
868 869
            break;
        case VIR_TYPED_PARAM_BOOLEAN:
870 871 872
            val[j].value.remote_typed_param_value_u.b = params[i].value.b;
            break;
        case VIR_TYPED_PARAM_STRING:
873
            if (VIR_STRDUP(val[j].value.remote_typed_param_value_u.s, params[i].value.s) < 0)
874
                goto cleanup;
875 876
            break;
        default:
877 878
            virReportError(VIR_ERR_RPC, _("unknown parameter type: %d"),
                           params[i].type);
879 880
            goto cleanup;
        }
881
        j++;
882 883 884 885 886 887 888 889
    }

    *ret_params_val = val;
    val = NULL;
    rv = 0;

cleanup:
    if (val) {
890
        for (i = 0; i < nparams; i++) {
891
            VIR_FREE(val[i].field);
892
            if (val[i].value.type == VIR_TYPED_PARAM_STRING)
893 894
                VIR_FREE(val[i].value.remote_typed_param_value_u.s);
        }
895 896 897 898 899 900 901
        VIR_FREE(val);
    }
    return rv;
}

/* Helper to deserialize typed parameters. */
static virTypedParameterPtr
902 903
remoteDeserializeTypedParameters(remote_typed_param *args_params_val,
                                 u_int args_params_len,
904 905 906
                                 int limit,
                                 int *nparams)
{
907
    size_t i = 0;
908 909 910 911
    int rv = -1;
    virTypedParameterPtr params = NULL;

    /* Check the length of the returned list carefully. */
912
    if (limit && args_params_len > limit) {
913
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("nparams too large"));
914 915
        goto cleanup;
    }
916
    if (VIR_ALLOC_N(params, args_params_len) < 0)
917 918 919 920 921 922 923 924
        goto cleanup;

    *nparams = args_params_len;

    /* Deserialise the result. */
    for (i = 0; i < args_params_len; ++i) {
        if (virStrcpyStatic(params[i].field,
                            args_params_val[i].field) == NULL) {
925 926 927
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Parameter %s too big for destination"),
                           args_params_val[i].field);
928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955
            goto cleanup;
        }
        params[i].type = args_params_val[i].value.type;
        switch (params[i].type) {
        case VIR_TYPED_PARAM_INT:
            params[i].value.i =
                args_params_val[i].value.remote_typed_param_value_u.i;
            break;
        case VIR_TYPED_PARAM_UINT:
            params[i].value.ui =
                args_params_val[i].value.remote_typed_param_value_u.ui;
            break;
        case VIR_TYPED_PARAM_LLONG:
            params[i].value.l =
                args_params_val[i].value.remote_typed_param_value_u.l;
            break;
        case VIR_TYPED_PARAM_ULLONG:
            params[i].value.ul =
                args_params_val[i].value.remote_typed_param_value_u.ul;
            break;
        case VIR_TYPED_PARAM_DOUBLE:
            params[i].value.d =
                args_params_val[i].value.remote_typed_param_value_u.d;
            break;
        case VIR_TYPED_PARAM_BOOLEAN:
            params[i].value.b =
                args_params_val[i].value.remote_typed_param_value_u.b;
            break;
956
        case VIR_TYPED_PARAM_STRING:
957 958
            if (VIR_STRDUP(params[i].value.s,
                           args_params_val[i].value.remote_typed_param_value_u.s) < 0)
959 960
                goto cleanup;
            break;
961
        default:
962 963
            virReportError(VIR_ERR_INTERNAL_ERROR, _("unknown parameter type: %d"),
                           params[i].type);
964 965 966 967 968 969 970
            goto cleanup;
        }
    }

    rv = 0;

cleanup:
971
    if (rv < 0) {
972 973
        virTypedParamsFree(params, i);
        params = NULL;
974
    }
975 976 977
    return params;
}

978
static int
979 980
remoteDispatchDomainGetSchedulerParameters(virNetServerPtr server ATTRIBUTE_UNUSED,
                                           virNetServerClientPtr client ATTRIBUTE_UNUSED,
981
                                           virNetMessagePtr msg ATTRIBUTE_UNUSED,
982
                                           virNetMessageErrorPtr rerr,
983 984
                                           remote_domain_get_scheduler_parameters_args *args,
                                           remote_domain_get_scheduler_parameters_ret *ret)
985
{
986
    virDomainPtr dom = NULL;
987
    virTypedParameterPtr params = NULL;
988
    int nparams = 0;
989
    int rv = -1;
990 991
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
992

993
    if (!priv->conn) {
994
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
995
        goto cleanup;
996 997
    }

998
    if (args->nparams > REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX) {
999
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("nparams too large"));
1000
        goto cleanup;
1001
    }
1002
    if (args->nparams && VIR_ALLOC_N(params, args->nparams) < 0)
1003
        goto cleanup;
1004
    nparams = args->nparams;
1005

1006
    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
1007
        goto cleanup;
1008

1009
    if (virDomainGetSchedulerParameters(dom, params, &nparams) < 0)
1010
        goto cleanup;
1011

1012
    if (remoteSerializeTypedParameters(params, nparams,
1013
                                       &ret->params.params_val,
1014 1015
                                       &ret->params.params_len,
                                       0) < 0)
1016 1017 1018 1019 1020 1021
        goto cleanup;

    rv = 0;

cleanup:
    if (rv < 0)
1022
        virNetMessageSaveError(rerr);
1023
    virTypedParamsFree(params, nparams);
1024 1025 1026 1027 1028
    if (dom)
        virDomainFree(dom);
    return rv;
}

1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
static int
remoteDispatchConnectListAllDomains(virNetServerPtr server ATTRIBUTE_UNUSED,
                                    virNetServerClientPtr client,
                                    virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                    virNetMessageErrorPtr rerr,
                                    remote_connect_list_all_domains_args *args,
                                    remote_connect_list_all_domains_ret *ret)
{
    virDomainPtr *doms = NULL;
    int ndomains = 0;
1039
    size_t i;
1040 1041 1042 1043
    int rv = -1;
    struct daemonClientPrivate *priv = virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
1044
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
1045 1046 1047 1048 1049 1050 1051 1052
        goto cleanup;
    }

    if ((ndomains = virConnectListAllDomains(priv->conn,
                                             args->need_results ? &doms : NULL,
                                             args->flags)) < 0)
        goto cleanup;

1053 1054 1055 1056 1057 1058 1059
    if (ndomains > REMOTE_DOMAIN_LIST_MAX) {
        virReportError(VIR_ERR_RPC,
                       _("Too many domains '%d' for limit '%d'"),
                       ndomains, REMOTE_DOMAIN_LIST_MAX);
        goto cleanup;
    }

1060
    if (doms && ndomains) {
1061
        if (VIR_ALLOC_N(ret->domains.domains_val, ndomains) < 0)
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087
            goto cleanup;

        ret->domains.domains_len = ndomains;

        for (i = 0; i < ndomains; i++)
            make_nonnull_domain(ret->domains.domains_val + i, doms[i]);
    } else {
        ret->domains.domains_len = 0;
        ret->domains.domains_val = NULL;
    }

    ret->ret = ndomains;

    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (doms) {
        for (i = 0; i < ndomains; i++)
            virDomainFree(doms[i]);
        VIR_FREE(doms);
    }
    return rv;
}

1088
static int
1089 1090
remoteDispatchDomainGetSchedulerParametersFlags(virNetServerPtr server ATTRIBUTE_UNUSED,
                                                virNetServerClientPtr client ATTRIBUTE_UNUSED,
1091
                                                virNetMessagePtr msg ATTRIBUTE_UNUSED,
1092
                                                virNetMessageErrorPtr rerr,
1093 1094 1095 1096 1097
                                                remote_domain_get_scheduler_parameters_flags_args *args,
                                                remote_domain_get_scheduler_parameters_flags_ret *ret)
{
    virDomainPtr dom = NULL;
    virTypedParameterPtr params = NULL;
1098
    int nparams = 0;
1099
    int rv = -1;
1100 1101
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
1102

1103
    if (!priv->conn) {
1104
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
1105 1106 1107
        goto cleanup;
    }

1108
    if (args->nparams > REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX) {
1109
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("nparams too large"));
1110 1111
        goto cleanup;
    }
1112
    if (args->nparams && VIR_ALLOC_N(params, args->nparams) < 0)
1113
        goto cleanup;
1114
    nparams = args->nparams;
1115

1116
    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
1117 1118 1119 1120 1121 1122 1123
        goto cleanup;

    if (virDomainGetSchedulerParametersFlags(dom, params, &nparams,
                                             args->flags) < 0)
        goto cleanup;

    if (remoteSerializeTypedParameters(params, nparams,
1124
                                       &ret->params.params_val,
1125 1126
                                       &ret->params.params_len,
                                       args->flags) < 0)
1127
        goto cleanup;
1128

1129
    rv = 0;
1130 1131

cleanup:
1132
    if (rv < 0)
1133
        virNetMessageSaveError(rerr);
1134
    virTypedParamsFree(params, nparams);
1135 1136 1137
    if (dom)
        virDomainFree(dom);
    return rv;
1138 1139
}

1140
static int
1141 1142
remoteDispatchDomainMemoryStats(virNetServerPtr server ATTRIBUTE_UNUSED,
                                virNetServerClientPtr client ATTRIBUTE_UNUSED,
1143
                                virNetMessagePtr msg ATTRIBUTE_UNUSED,
1144
                                virNetMessageErrorPtr rerr,
1145 1146
                                remote_domain_memory_stats_args *args,
                                remote_domain_memory_stats_ret *ret)
1147
{
1148
    virDomainPtr dom = NULL;
1149
    struct _virDomainMemoryStat *stats;
1150 1151
    int nr_stats;
    size_t i;
1152
    int rv = -1;
1153 1154
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
1155

1156
    if (!priv->conn) {
1157
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
1158
        goto cleanup;
1159 1160
    }

1161
    if (args->maxStats > REMOTE_DOMAIN_MEMORY_STATS_MAX) {
1162 1163
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("maxStats > REMOTE_DOMAIN_MEMORY_STATS_MAX"));
1164
        goto cleanup;
1165 1166
    }

1167
    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
1168
        goto cleanup;
1169 1170

    /* Allocate stats array for making dispatch call */
1171
    if (VIR_ALLOC_N(stats, args->maxStats) < 0)
1172
        goto cleanup;
1173

1174
    nr_stats = virDomainMemoryStats(dom, stats, args->maxStats, args->flags);
1175
    if (nr_stats < 0)
1176
        goto cleanup;
1177 1178

    /* Allocate return buffer */
1179
    if (VIR_ALLOC_N(ret->stats.stats_val, args->maxStats) < 0)
1180
        goto cleanup;
1181 1182 1183 1184 1185 1186 1187

    /* Copy the stats into the xdr return structure */
    for (i = 0; i < nr_stats; i++) {
        ret->stats.stats_val[i].tag = stats[i].tag;
        ret->stats.stats_val[i].val = stats[i].val;
    }
    ret->stats.stats_len = nr_stats;
1188 1189 1190 1191
    rv = 0;

cleanup:
    if (rv < 0)
1192
        virNetMessageSaveError(rerr);
1193 1194
    if (dom)
        virDomainFree(dom);
1195
    VIR_FREE(stats);
1196
    return rv;
1197 1198
}

1199
static int
1200 1201
remoteDispatchDomainBlockPeek(virNetServerPtr server ATTRIBUTE_UNUSED,
                              virNetServerClientPtr client ATTRIBUTE_UNUSED,
1202
                              virNetMessagePtr msg ATTRIBUTE_UNUSED,
1203
                              virNetMessageErrorPtr rerr,
1204 1205
                              remote_domain_block_peek_args *args,
                              remote_domain_block_peek_ret *ret)
1206
{
1207
    virDomainPtr dom = NULL;
1208 1209 1210 1211
    char *path;
    unsigned long long offset;
    size_t size;
    unsigned int flags;
1212
    int rv = -1;
1213 1214
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
1215

1216
    if (!priv->conn) {
1217
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
1218
        goto cleanup;
1219 1220
    }

1221
    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
1222
        goto cleanup;
1223 1224 1225 1226 1227 1228
    path = args->path;
    offset = args->offset;
    size = args->size;
    flags = args->flags;

    if (size > REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX) {
1229 1230
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("size > maximum buffer size"));
1231
        goto cleanup;
1232 1233 1234
    }

    ret->buffer.buffer_len = size;
1235
    if (VIR_ALLOC_N(ret->buffer.buffer_val, size) < 0)
1236
        goto cleanup;
1237

1238
    if (virDomainBlockPeek(dom, path, offset, size,
1239
                           ret->buffer.buffer_val, flags) < 0)
1240
        goto cleanup;
1241

1242 1243 1244 1245
    rv = 0;

cleanup:
    if (rv < 0) {
1246
        virNetMessageSaveError(rerr);
1247 1248 1249 1250 1251
        VIR_FREE(ret->buffer.buffer_val);
    }
    if (dom)
        virDomainFree(dom);
    return rv;
1252 1253
}

1254 1255 1256
static int
remoteDispatchDomainBlockStatsFlags(virNetServerPtr server ATTRIBUTE_UNUSED,
                                    virNetServerClientPtr client ATTRIBUTE_UNUSED,
1257
                                    virNetMessagePtr msg ATTRIBUTE_UNUSED,
1258 1259 1260 1261 1262 1263 1264
                                    virNetMessageErrorPtr rerr,
                                    remote_domain_block_stats_flags_args *args,
                                    remote_domain_block_stats_flags_ret *ret)
{
    virTypedParameterPtr params = NULL;
    virDomainPtr dom = NULL;
    const char *path = args->path;
1265
    int nparams = 0;
1266 1267 1268 1269 1270 1271
    unsigned int flags;
    int rv = -1;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
1272
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
1273 1274 1275 1276 1277 1278 1279
        goto cleanup;
    }

    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
        goto cleanup;
    flags = args->flags;

1280
    if (args->nparams > REMOTE_DOMAIN_BLOCK_STATS_PARAMETERS_MAX) {
1281
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("nparams too large"));
1282 1283
        goto cleanup;
    }
1284
    if (args->nparams && VIR_ALLOC_N(params, args->nparams) < 0)
1285
        goto cleanup;
1286
    nparams = args->nparams;
1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301

    if (virDomainBlockStatsFlags(dom, path, params, &nparams, flags) < 0)
        goto cleanup;

    /* In this case, we need to send back the number of parameters
     * supported
     */
    if (args->nparams == 0) {
        ret->nparams = nparams;
        goto success;
    }

    /* Serialise the block stats. */
    if (remoteSerializeTypedParameters(params, nparams,
                                       &ret->params.params_val,
1302 1303
                                       &ret->params.params_len,
                                       args->flags) < 0)
1304 1305 1306 1307 1308 1309
        goto cleanup;

success:
    rv = 0;

cleanup:
1310
    if (rv < 0)
1311
        virNetMessageSaveError(rerr);
1312
    virTypedParamsFree(params, nparams);
A
ajia@redhat.com 已提交
1313 1314
    if (dom)
        virDomainFree(dom);
1315 1316 1317
    return rv;
}

R
Richard W.M. Jones 已提交
1318
static int
1319 1320
remoteDispatchDomainMemoryPeek(virNetServerPtr server ATTRIBUTE_UNUSED,
                               virNetServerClientPtr client ATTRIBUTE_UNUSED,
1321
                               virNetMessagePtr msg ATTRIBUTE_UNUSED,
1322
                               virNetMessageErrorPtr rerr,
1323 1324
                               remote_domain_memory_peek_args *args,
                               remote_domain_memory_peek_ret *ret)
R
Richard W.M. Jones 已提交
1325
{
1326
    virDomainPtr dom = NULL;
R
Richard W.M. Jones 已提交
1327 1328 1329
    unsigned long long offset;
    size_t size;
    unsigned int flags;
1330
    int rv = -1;
1331 1332
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
R
Richard W.M. Jones 已提交
1333

1334
    if (!priv->conn) {
1335
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
1336
        goto cleanup;
1337 1338
    }

1339
    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
1340
        goto cleanup;
R
Richard W.M. Jones 已提交
1341 1342 1343 1344 1345
    offset = args->offset;
    size = args->size;
    flags = args->flags;

    if (size > REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX) {
1346 1347
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("size > maximum buffer size"));
1348
        goto cleanup;
R
Richard W.M. Jones 已提交
1349 1350 1351
    }

    ret->buffer.buffer_len = size;
1352
    if (VIR_ALLOC_N(ret->buffer.buffer_val, size) < 0)
1353
        goto cleanup;
R
Richard W.M. Jones 已提交
1354

1355
    if (virDomainMemoryPeek(dom, offset, size,
1356
                            ret->buffer.buffer_val, flags) < 0)
1357
        goto cleanup;
R
Richard W.M. Jones 已提交
1358

1359 1360 1361 1362
    rv = 0;

cleanup:
    if (rv < 0) {
1363
        virNetMessageSaveError(rerr);
1364 1365 1366 1367 1368
        VIR_FREE(ret->buffer.buffer_val);
    }
    if (dom)
        virDomainFree(dom);
    return rv;
R
Richard W.M. Jones 已提交
1369 1370
}

1371
static int
1372 1373
remoteDispatchDomainGetSecurityLabel(virNetServerPtr server ATTRIBUTE_UNUSED,
                                     virNetServerClientPtr client ATTRIBUTE_UNUSED,
1374
                                     virNetMessagePtr msg ATTRIBUTE_UNUSED,
1375
                                     virNetMessageErrorPtr rerr,
1376 1377
                                     remote_domain_get_security_label_args *args,
                                     remote_domain_get_security_label_ret *ret)
1378
{
1379 1380
    virDomainPtr dom = NULL;
    virSecurityLabelPtr seclabel = NULL;
1381
    int rv = -1;
1382 1383
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
1384

1385
    if (!priv->conn) {
1386
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
1387
        goto cleanup;
1388 1389
    }

1390
    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
1391 1392
        goto cleanup;

1393
    if (VIR_ALLOC(seclabel) < 0)
1394 1395 1396 1397 1398 1399
        goto cleanup;

    if (virDomainGetSecurityLabel(dom, seclabel) < 0)
        goto cleanup;

    ret->label.label_len = strlen(seclabel->label) + 1;
1400
    if (VIR_ALLOC_N(ret->label.label_val, ret->label.label_len) < 0)
1401
        goto cleanup;
1402 1403
    strcpy(ret->label.label_val, seclabel->label);
    ret->enforcing = seclabel->enforcing;
1404

1405 1406 1407 1408
    rv = 0;

cleanup:
    if (rv < 0)
1409
        virNetMessageSaveError(rerr);
1410 1411 1412
    if (dom)
        virDomainFree(dom);
    VIR_FREE(seclabel);
1413
    return rv;
1414 1415
}

M
Marcelo Cerri 已提交
1416 1417 1418 1419 1420 1421 1422 1423 1424 1425
static int
remoteDispatchDomainGetSecurityLabelList(virNetServerPtr server ATTRIBUTE_UNUSED,
                                         virNetServerClientPtr client ATTRIBUTE_UNUSED,
                                         virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                         virNetMessageErrorPtr rerr,
                                         remote_domain_get_security_label_list_args *args,
                                         remote_domain_get_security_label_list_ret *ret)
{
    virDomainPtr dom = NULL;
    virSecurityLabelPtr seclabels = NULL;
1426 1427
    int len, rv = -1;
    size_t i;
M
Marcelo Cerri 已提交
1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
        goto cleanup;

    if ((len = virDomainGetSecurityLabelList(dom, &seclabels)) < 0) {
        ret->ret = len;
        ret->labels.labels_len = 0;
        ret->labels.labels_val = NULL;
        goto done;
    }

1446
    if (VIR_ALLOC_N(ret->labels.labels_val, len) < 0)
M
Marcelo Cerri 已提交
1447 1448 1449 1450 1451
        goto cleanup;

    for (i = 0; i < len; i++) {
        size_t label_len = strlen(seclabels[i].label) + 1;
        remote_domain_get_security_label_ret *cur = &ret->labels.labels_val[i];
1452
        if (VIR_ALLOC_N(cur->label.label_val, label_len) < 0)
M
Marcelo Cerri 已提交
1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475
            goto cleanup;
        if (virStrcpy(cur->label.label_val, seclabels[i].label, label_len) == NULL) {
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("failed to copy security label"));
            goto cleanup;
        }
        cur->label.label_len = label_len;
        cur->enforcing = seclabels[i].enforcing;
    }
    ret->labels.labels_len = ret->ret = len;

done:
    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (dom)
        virDomainFree(dom);
    VIR_FREE(seclabels);
    return rv;
}

1476
static int
1477 1478
remoteDispatchNodeGetSecurityModel(virNetServerPtr server ATTRIBUTE_UNUSED,
                                   virNetServerClientPtr client ATTRIBUTE_UNUSED,
1479
                                   virNetMessagePtr msg ATTRIBUTE_UNUSED,
1480
                                   virNetMessageErrorPtr rerr,
1481
                                   remote_node_get_security_model_ret *ret)
1482
{
1483
    virSecurityModel secmodel;
1484
    int rv = -1;
1485 1486
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
1487

1488
    if (!priv->conn) {
1489
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
1490
        goto cleanup;
1491 1492
    }

1493
    memset(&secmodel, 0, sizeof(secmodel));
1494
    if (virNodeGetSecurityModel(priv->conn, &secmodel) < 0)
1495 1496 1497
        goto cleanup;

    ret->model.model_len = strlen(secmodel.model) + 1;
1498
    if (VIR_ALLOC_N(ret->model.model_val, ret->model.model_len) < 0)
1499 1500 1501 1502
        goto cleanup;
    strcpy(ret->model.model_val, secmodel.model);

    ret->doi.doi_len = strlen(secmodel.doi) + 1;
1503
    if (VIR_ALLOC_N(ret->doi.doi_val, ret->doi.doi_len) < 0)
1504
        goto cleanup;
1505
    strcpy(ret->doi.doi_val, secmodel.doi);
1506

1507 1508 1509 1510
    rv = 0;

cleanup:
    if (rv < 0)
1511
        virNetMessageSaveError(rerr);
1512
    return rv;
1513 1514
}

1515
static int
1516 1517
remoteDispatchDomainGetVcpuPinInfo(virNetServerPtr server ATTRIBUTE_UNUSED,
                                   virNetServerClientPtr client ATTRIBUTE_UNUSED,
1518
                                   virNetMessagePtr msg ATTRIBUTE_UNUSED,
1519
                                   virNetMessageErrorPtr rerr,
E
Eric Blake 已提交
1520 1521
                                   remote_domain_get_vcpu_pin_info_args *args,
                                   remote_domain_get_vcpu_pin_info_ret *ret)
1522 1523 1524 1525 1526
{
    virDomainPtr dom = NULL;
    unsigned char *cpumaps = NULL;
    int num;
    int rv = -1;
1527 1528
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
1529

1530
    if (!priv->conn) {
1531
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
1532 1533 1534
        goto cleanup;
    }

1535
    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
1536 1537 1538
        goto cleanup;

    if (args->ncpumaps > REMOTE_VCPUINFO_MAX) {
1539
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("ncpumaps > REMOTE_VCPUINFO_MAX"));
1540 1541 1542 1543 1544
        goto cleanup;
    }

    if (INT_MULTIPLY_OVERFLOW(args->ncpumaps, args->maplen) ||
        args->ncpumaps * args->maplen > REMOTE_CPUMAPS_MAX) {
1545
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("maxinfo * maplen > REMOTE_CPUMAPS_MAX"));
1546 1547 1548 1549 1550 1551
        goto cleanup;
    }

    /* Allocate buffers to take the results. */
    if (args->maplen > 0 &&
        VIR_ALLOC_N(cpumaps, args->ncpumaps * args->maplen) < 0)
1552
        goto cleanup;
1553

E
Eric Blake 已提交
1554
    if ((num = virDomainGetVcpuPinInfo(dom,
1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567
                                       args->ncpumaps,
                                       cpumaps,
                                       args->maplen,
                                       args->flags)) < 0)
        goto cleanup;

    ret->num = num;
    /* Don't need to allocate/copy the cpumaps if we make the reasonable
     * assumption that unsigned char and char are the same size.
     * Note that remoteDispatchClientRequest will free.
     */
    ret->cpumaps.cpumaps_len = args->ncpumaps * args->maplen;
    ret->cpumaps.cpumaps_val = (char *) cpumaps;
1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643
    cpumaps = NULL;

    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
    VIR_FREE(cpumaps);
    if (dom)
        virDomainFree(dom);
    return rv;
}

static int
remoteDispatchDomainPinEmulator(virNetServerPtr server ATTRIBUTE_UNUSED,
                                virNetServerClientPtr client,
                                virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                virNetMessageErrorPtr rerr,
                                remote_domain_pin_emulator_args *args)
{
    int rv = -1;
    virDomainPtr dom = NULL;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
        goto cleanup;

    if (virDomainPinEmulator(dom,
                             (unsigned char *) args->cpumap.cpumap_val,
                             args->cpumap.cpumap_len,
                             args->flags) < 0)
        goto cleanup;

    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (dom)
        virDomainFree(dom);
    return rv;
}


static int
remoteDispatchDomainGetEmulatorPinInfo(virNetServerPtr server ATTRIBUTE_UNUSED,
                                       virNetServerClientPtr client ATTRIBUTE_UNUSED,
                                       virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                       virNetMessageErrorPtr rerr,
                                       remote_domain_get_emulator_pin_info_args *args,
                                       remote_domain_get_emulator_pin_info_ret *ret)
{
    virDomainPtr dom = NULL;
    unsigned char *cpumaps = NULL;
    int r;
    int rv = -1;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
        goto cleanup;

    /* Allocate buffers to take the results */
    if (args->maplen > 0 &&
        VIR_ALLOC_N(cpumaps, args->maplen) < 0)
1644
        goto cleanup;
1645 1646 1647 1648 1649 1650 1651 1652 1653 1654

    if ((r = virDomainGetEmulatorPinInfo(dom,
                                         cpumaps,
                                         args->maplen,
                                         args->flags)) < 0)
        goto cleanup;

    ret->ret = r;
    ret->cpumaps.cpumaps_len = args->maplen;
    ret->cpumaps.cpumaps_val = (char *) cpumaps;
1655 1656 1657 1658 1659 1660
    cpumaps = NULL;

    rv = 0;

cleanup:
    if (rv < 0)
1661
        virNetMessageSaveError(rerr);
1662 1663 1664 1665 1666 1667
    VIR_FREE(cpumaps);
    if (dom)
        virDomainFree(dom);
    return rv;
}

1668
static int
1669 1670
remoteDispatchDomainGetVcpus(virNetServerPtr server ATTRIBUTE_UNUSED,
                             virNetServerClientPtr client ATTRIBUTE_UNUSED,
1671
                             virNetMessagePtr msg ATTRIBUTE_UNUSED,
1672
                             virNetMessageErrorPtr rerr,
1673 1674
                             remote_domain_get_vcpus_args *args,
                             remote_domain_get_vcpus_ret *ret)
1675
{
1676
    virDomainPtr dom = NULL;
1677 1678
    virVcpuInfoPtr info = NULL;
    unsigned char *cpumaps = NULL;
1679 1680
    int info_len;
    size_t i;
1681
    int rv = -1;
1682 1683
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
1684

1685
    if (!priv->conn) {
1686
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
1687
        goto cleanup;
1688 1689
    }

1690
    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
1691
        goto cleanup;
1692

1693
    if (args->maxinfo > REMOTE_VCPUINFO_MAX) {
1694
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("maxinfo > REMOTE_VCPUINFO_MAX"));
1695
        goto cleanup;
1696
    }
1697

1698 1699
    if (INT_MULTIPLY_OVERFLOW(args->maxinfo, args->maplen) ||
        args->maxinfo * args->maplen > REMOTE_CPUMAPS_MAX) {
1700
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("maxinfo * maplen > REMOTE_CPUMAPS_MAX"));
1701 1702 1703 1704 1705
        goto cleanup;
    }

    /* Allocate buffers to take the results. */
    if (VIR_ALLOC_N(info, args->maxinfo) < 0)
1706
        goto cleanup;
1707 1708
    if (args->maplen > 0 &&
        VIR_ALLOC_N(cpumaps, args->maxinfo * args->maplen) < 0)
1709
        goto cleanup;
1710 1711 1712 1713 1714 1715 1716 1717 1718

    if ((info_len = virDomainGetVcpus(dom,
                                      info, args->maxinfo,
                                      cpumaps, args->maplen)) < 0)
        goto cleanup;

    /* Allocate the return buffer for info. */
    ret->info.info_len = info_len;
    if (VIR_ALLOC_N(ret->info.info_val, info_len) < 0)
1719
        goto cleanup;
1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736

    for (i = 0; i < info_len; ++i) {
        ret->info.info_val[i].number = info[i].number;
        ret->info.info_val[i].state = info[i].state;
        ret->info.info_val[i].cpu_time = info[i].cpuTime;
        ret->info.info_val[i].cpu = info[i].cpu;
    }

    /* Don't need to allocate/copy the cpumaps if we make the reasonable
     * assumption that unsigned char and char are the same size.
     * Note that remoteDispatchClientRequest will free.
     */
    ret->cpumaps.cpumaps_len = args->maxinfo * args->maplen;
    ret->cpumaps.cpumaps_val = (char *) cpumaps;
    cpumaps = NULL;

    rv = 0;
1737 1738

cleanup:
1739
    if (rv < 0) {
1740
        virNetMessageSaveError(rerr);
1741 1742 1743 1744
        VIR_FREE(ret->info.info_val);
    }
    VIR_FREE(cpumaps);
    VIR_FREE(info);
1745 1746 1747
    if (dom)
        virDomainFree(dom);
    return rv;
1748 1749 1750
}

static int
1751 1752
remoteDispatchDomainMigratePrepare(virNetServerPtr server ATTRIBUTE_UNUSED,
                                   virNetServerClientPtr client ATTRIBUTE_UNUSED,
1753
                                   virNetMessagePtr msg ATTRIBUTE_UNUSED,
1754
                                   virNetMessageErrorPtr rerr,
1755 1756
                                   remote_domain_migrate_prepare_args *args,
                                   remote_domain_migrate_prepare_ret *ret)
1757
{
1758 1759 1760 1761 1762
    char *cookie = NULL;
    int cookielen = 0;
    char *uri_in;
    char **uri_out;
    char *dname;
1763
    int rv = -1;
1764 1765
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
1766

1767
    if (!priv->conn) {
1768
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
1769
        goto cleanup;
1770 1771
    }

1772 1773 1774 1775
    uri_in = args->uri_in == NULL ? NULL : *args->uri_in;
    dname = args->dname == NULL ? NULL : *args->dname;

    /* Wacky world of XDR ... */
1776
    if (VIR_ALLOC(uri_out) < 0)
1777
        goto cleanup;
1778

1779
    if (virDomainMigratePrepare(priv->conn, &cookie, &cookielen,
1780 1781
                                uri_in, uri_out,
                                args->flags, dname, args->resource) < 0)
1782
        goto cleanup;
1783

1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794
    /* remoteDispatchClientRequest will free cookie, uri_out and
     * the string if there is one.
     */
    ret->cookie.cookie_len = cookielen;
    ret->cookie.cookie_val = cookie;
    if (*uri_out == NULL) {
        ret->uri_out = NULL;
    } else {
        ret->uri_out = uri_out;
        uri_out = NULL;
    }
1795

1796
    rv = 0;
1797

1798 1799
cleanup:
    if (rv < 0)
1800
        virNetMessageSaveError(rerr);
1801
    VIR_FREE(uri_out);
1802
    return rv;
1803 1804
}

1805
static int
1806 1807
remoteDispatchDomainMigratePrepare2(virNetServerPtr server ATTRIBUTE_UNUSED,
                                    virNetServerClientPtr client ATTRIBUTE_UNUSED,
1808
                                    virNetMessagePtr msg ATTRIBUTE_UNUSED,
1809
                                    virNetMessageErrorPtr rerr,
1810 1811
                                    remote_domain_migrate_prepare2_args *args,
                                    remote_domain_migrate_prepare2_ret *ret)
1812
{
1813 1814 1815 1816 1817
    char *cookie = NULL;
    int cookielen = 0;
    char *uri_in;
    char **uri_out;
    char *dname;
1818
    int rv = -1;
1819 1820
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
1821

1822
    if (!priv->conn) {
1823
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
1824
        goto cleanup;
1825 1826
    }

1827 1828
    uri_in = args->uri_in == NULL ? NULL : *args->uri_in;
    dname = args->dname == NULL ? NULL : *args->dname;
1829

1830
    /* Wacky world of XDR ... */
1831
    if (VIR_ALLOC(uri_out) < 0)
1832
        goto cleanup;
1833

1834
    if (virDomainMigratePrepare2(priv->conn, &cookie, &cookielen,
1835 1836 1837
                                 uri_in, uri_out,
                                 args->flags, dname, args->resource,
                                 args->dom_xml) < 0)
1838
        goto cleanup;
1839

1840 1841 1842 1843 1844 1845
    /* remoteDispatchClientRequest will free cookie, uri_out and
     * the string if there is one.
     */
    ret->cookie.cookie_len = cookielen;
    ret->cookie.cookie_val = cookie;
    ret->uri_out = *uri_out == NULL ? NULL : uri_out;
1846

1847 1848 1849 1850
    rv = 0;

cleanup:
    if (rv < 0)
1851
        virNetMessageSaveError(rerr);
1852
    return rv;
1853 1854
}

C
Chris Lalancette 已提交
1855
static int
1856 1857
remoteDispatchDomainGetMemoryParameters(virNetServerPtr server ATTRIBUTE_UNUSED,
                                        virNetServerClientPtr client ATTRIBUTE_UNUSED,
1858
                                        virNetMessagePtr msg ATTRIBUTE_UNUSED,
1859 1860 1861
                                        virNetMessageErrorPtr rerr,
                                        remote_domain_get_memory_parameters_args *args,
                                        remote_domain_get_memory_parameters_ret *ret)
C
Chris Lalancette 已提交
1862
{
1863
    virDomainPtr dom = NULL;
1864
    virTypedParameterPtr params = NULL;
1865
    int nparams = 0;
1866
    unsigned int flags;
1867
    int rv = -1;
1868 1869
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
1870

1871
    if (!priv->conn) {
1872
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
1873
        goto cleanup;
1874
    }
C
Chris Lalancette 已提交
1875

1876
    flags = args->flags;
C
Chris Lalancette 已提交
1877

1878
    if (args->nparams > REMOTE_DOMAIN_MEMORY_PARAMETERS_MAX) {
1879
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("nparams too large"));
1880 1881
        goto cleanup;
    }
1882
    if (args->nparams && VIR_ALLOC_N(params, args->nparams) < 0)
1883
        goto cleanup;
1884
    nparams = args->nparams;
C
Chris Lalancette 已提交
1885

1886
    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
1887
        goto cleanup;
C
Chris Lalancette 已提交
1888

1889
    if (virDomainGetMemoryParameters(dom, params, &nparams, flags) < 0)
1890
        goto cleanup;
C
Chris Lalancette 已提交
1891

1892 1893 1894 1895 1896 1897
    /* In this case, we need to send back the number of parameters
     * supported
     */
    if (args->nparams == 0) {
        ret->nparams = nparams;
        goto success;
1898 1899
    }

1900
    if (remoteSerializeTypedParameters(params, nparams,
1901
                                       &ret->params.params_val,
1902 1903
                                       &ret->params.params_len,
                                       args->flags) < 0)
1904
        goto cleanup;
1905

1906
success:
1907 1908 1909
    rv = 0;

cleanup:
1910
    if (rv < 0)
1911
        virNetMessageSaveError(rerr);
1912
    virTypedParamsFree(params, nparams);
1913 1914 1915
    if (dom)
        virDomainFree(dom);
    return rv;
1916 1917
}

1918 1919 1920 1921 1922 1923 1924 1925 1926 1927
static int
remoteDispatchDomainGetNumaParameters(virNetServerPtr server ATTRIBUTE_UNUSED,
                                      virNetServerClientPtr client ATTRIBUTE_UNUSED,
                                      virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                      virNetMessageErrorPtr rerr,
                                      remote_domain_get_numa_parameters_args *args,
                                      remote_domain_get_numa_parameters_ret *ret)
{
    virDomainPtr dom = NULL;
    virTypedParameterPtr params = NULL;
1928
    int nparams = 0;
1929 1930 1931 1932 1933 1934
    unsigned int flags;
    int rv = -1;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
1935
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
1936 1937 1938 1939 1940
        goto cleanup;
    }

    flags = args->flags;

1941
    if (args->nparams > REMOTE_DOMAIN_NUMA_PARAMETERS_MAX) {
1942
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("nparams too large"));
1943 1944
        goto cleanup;
    }
1945
    if (args->nparams && VIR_ALLOC_N(params, args->nparams) < 0)
1946
        goto cleanup;
1947
    nparams = args->nparams;
1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974

    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
        goto cleanup;

    if (virDomainGetNumaParameters(dom, params, &nparams, flags) < 0)
        goto cleanup;

    /* In this case, we need to send back the number of parameters
     * supported
     */
    if (args->nparams == 0) {
        ret->nparams = nparams;
        goto success;
    }

    if (remoteSerializeTypedParameters(params, nparams,
                                       &ret->params.params_val,
                                       &ret->params.params_len,
                                       flags) < 0)
        goto cleanup;

success:
    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
1975
    virTypedParamsFree(params, nparams);
1976 1977 1978 1979 1980
    if (dom)
        virDomainFree(dom);
    return rv;
}

1981
static int
1982 1983
remoteDispatchDomainGetBlkioParameters(virNetServerPtr server ATTRIBUTE_UNUSED,
                                       virNetServerClientPtr client ATTRIBUTE_UNUSED,
1984
                                       virNetMessagePtr msg ATTRIBUTE_UNUSED,
1985 1986 1987
                                       virNetMessageErrorPtr rerr,
                                       remote_domain_get_blkio_parameters_args *args,
                                       remote_domain_get_blkio_parameters_ret *ret)
1988
{
1989
    virDomainPtr dom = NULL;
1990
    virTypedParameterPtr params = NULL;
1991
    int nparams = 0;
1992
    unsigned int flags;
1993
    int rv = -1;
1994 1995
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
1996

1997
    if (!priv->conn) {
1998
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
1999
        goto cleanup;
2000 2001
    }

2002 2003
    flags = args->flags;

2004
    if (args->nparams > REMOTE_DOMAIN_BLKIO_PARAMETERS_MAX) {
2005
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("nparams too large"));
2006
        goto cleanup;
2007
    }
2008
    if (args->nparams && VIR_ALLOC_N(params, args->nparams) < 0)
2009
        goto cleanup;
2010
    nparams = args->nparams;
2011

2012
    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
2013
        goto cleanup;
2014

2015
    if (virDomainGetBlkioParameters(dom, params, &nparams, flags) < 0)
2016
        goto cleanup;
2017

2018 2019 2020 2021 2022 2023 2024 2025
    /* In this case, we need to send back the number of parameters
     * supported
     */
    if (args->nparams == 0) {
        ret->nparams = nparams;
        goto success;
    }

2026
    if (remoteSerializeTypedParameters(params, nparams,
2027
                                       &ret->params.params_val,
2028 2029
                                       &ret->params.params_len,
                                       args->flags) < 0)
2030
        goto cleanup;
2031

2032 2033
success:
    rv = 0;
2034

2035
cleanup:
2036
    if (rv < 0)
2037
        virNetMessageSaveError(rerr);
2038
    virTypedParamsFree(params, nparams);
2039 2040 2041
    if (dom)
        virDomainFree(dom);
    return rv;
2042 2043
}

2044
static int
2045 2046
remoteDispatchNodeGetCPUStats(virNetServerPtr server ATTRIBUTE_UNUSED,
                              virNetServerClientPtr client ATTRIBUTE_UNUSED,
2047
                              virNetMessagePtr msg ATTRIBUTE_UNUSED,
2048 2049 2050
                              virNetMessageErrorPtr rerr,
                              remote_node_get_cpu_stats_args *args,
                              remote_node_get_cpu_stats_ret *ret)
2051
{
2052
    virNodeCPUStatsPtr params = NULL;
2053
    size_t i;
2054
    int cpuNum = args->cpuNum;
2055
    int nparams = 0;
2056 2057
    unsigned int flags;
    int rv = -1;
2058 2059
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
2060

2061
    if (!priv->conn) {
2062
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
2063 2064 2065 2066 2067
        goto cleanup;
    }

    flags = args->flags;

2068
    if (args->nparams > REMOTE_NODE_CPU_STATS_MAX) {
2069
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("nparams too large"));
2070 2071
        goto cleanup;
    }
2072
    if (args->nparams && VIR_ALLOC_N(params, args->nparams) < 0)
2073
        goto cleanup;
2074
    nparams = args->nparams;
2075

2076
    if (virNodeGetCPUStats(priv->conn, cpuNum, params, &nparams, flags) < 0)
2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089
        goto cleanup;

    /* In this case, we need to send back the number of stats
     * supported
     */
    if (args->nparams == 0) {
        ret->nparams = nparams;
        goto success;
    }

    /* Serialise the memory parameters. */
    ret->params.params_len = nparams;
    if (VIR_ALLOC_N(ret->params.params_val, nparams) < 0)
2090
        goto cleanup;
2091 2092 2093

    for (i = 0; i < nparams; ++i) {
        /* remoteDispatchClientRequest will free this: */
2094 2095
        if (VIR_STRDUP(ret->params.params_val[i].field, params[i].field) < 0)
            goto cleanup;
2096 2097 2098 2099 2100 2101 2102

        ret->params.params_val[i].value = params[i].value;
    }

success:
    rv = 0;

2103 2104
cleanup:
    if (rv < 0) {
2105
        virNetMessageSaveError(rerr);
2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116
        if (ret->params.params_val) {
            for (i = 0; i < nparams; i++)
                VIR_FREE(ret->params.params_val[i].field);
            VIR_FREE(ret->params.params_val);
        }
    }
    VIR_FREE(params);
    return rv;
}

static int
2117 2118
remoteDispatchNodeGetMemoryStats(virNetServerPtr server ATTRIBUTE_UNUSED,
                                 virNetServerClientPtr client ATTRIBUTE_UNUSED,
2119
                                 virNetMessagePtr msg ATTRIBUTE_UNUSED,
2120 2121 2122
                                 virNetMessageErrorPtr rerr,
                                 remote_node_get_memory_stats_args *args,
                                 remote_node_get_memory_stats_ret *ret)
2123
{
2124
    virNodeMemoryStatsPtr params = NULL;
2125
    size_t i;
2126
    int cellNum = args->cellNum;
2127
    int nparams = 0;
2128 2129
    unsigned int flags;
    int rv = -1;
2130 2131
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
2132

2133
    if (!priv->conn) {
2134
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
2135 2136 2137 2138 2139
        goto cleanup;
    }

    flags = args->flags;

2140
    if (args->nparams > REMOTE_NODE_MEMORY_STATS_MAX) {
2141
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("nparams too large"));
2142 2143
        goto cleanup;
    }
2144
    if (args->nparams && VIR_ALLOC_N(params, args->nparams) < 0)
2145
        goto cleanup;
2146
    nparams = args->nparams;
2147

2148
    if (virNodeGetMemoryStats(priv->conn, cellNum, params, &nparams, flags) < 0)
2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161
        goto cleanup;

    /* In this case, we need to send back the number of parameters
     * supported
     */
    if (args->nparams == 0) {
        ret->nparams = nparams;
        goto success;
    }

    /* Serialise the memory parameters. */
    ret->params.params_len = nparams;
    if (VIR_ALLOC_N(ret->params.params_val, nparams) < 0)
2162
        goto cleanup;
2163 2164 2165

    for (i = 0; i < nparams; ++i) {
        /* remoteDispatchClientRequest will free this: */
2166 2167
        if (VIR_STRDUP(ret->params.params_val[i].field, params[i].field) < 0)
            goto cleanup;
2168 2169 2170 2171 2172 2173 2174

        ret->params.params_val[i].value = params[i].value;
    }

success:
    rv = 0;

2175 2176
cleanup:
    if (rv < 0) {
2177
        virNetMessageSaveError(rerr);
2178 2179 2180 2181 2182 2183 2184 2185 2186 2187
        if (ret->params.params_val) {
            for (i = 0; i < nparams; i++)
                VIR_FREE(ret->params.params_val[i].field);
            VIR_FREE(ret->params.params_val);
        }
    }
    VIR_FREE(params);
    return rv;
}

2188 2189 2190
static int
remoteDispatchDomainGetBlockJobInfo(virNetServerPtr server ATTRIBUTE_UNUSED,
                                    virNetServerClientPtr client ATTRIBUTE_UNUSED,
2191
                                    virNetMessagePtr msg ATTRIBUTE_UNUSED,
2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202
                                    virNetMessageErrorPtr rerr,
                                    remote_domain_get_block_job_info_args *args,
                                    remote_domain_get_block_job_info_ret *ret)
{
    virDomainPtr dom = NULL;
    virDomainBlockJobInfo tmp;
    int rv = -1;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
2203
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228
        goto cleanup;
    }

    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
        goto cleanup;

    rv = virDomainGetBlockJobInfo(dom, args->path, &tmp, args->flags);
    if (rv <= 0)
        goto cleanup;

    ret->type = tmp.type;
    ret->bandwidth = tmp.bandwidth;
    ret->cur = tmp.cur;
    ret->end = tmp.end;
    ret->found = 1;
    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (dom)
        virDomainFree(dom);
    return rv;
}

2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239
static int
remoteDispatchDomainGetBlockIoTune(virNetServerPtr server ATTRIBUTE_UNUSED,
                                   virNetServerClientPtr client ATTRIBUTE_UNUSED,
                                   virNetMessagePtr hdr ATTRIBUTE_UNUSED,
                                   virNetMessageErrorPtr rerr,
                                   remote_domain_get_block_io_tune_args *args,
                                   remote_domain_get_block_io_tune_ret *ret)
{
    virDomainPtr dom = NULL;
    int rv = -1;
    virTypedParameterPtr params = NULL;
2240
    int nparams = 0;
2241 2242 2243 2244
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
2245
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
2246 2247 2248
        goto cleanup;
    }

2249
    if (args->nparams > REMOTE_DOMAIN_BLOCK_IO_TUNE_PARAMETERS_MAX) {
2250
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("nparams too large"));
2251 2252 2253
        goto cleanup;
    }

2254
    if (args->nparams && VIR_ALLOC_N(params, args->nparams) < 0)
2255
        goto cleanup;
2256
    nparams = args->nparams;
2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285

    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
        goto cleanup;

    if (virDomainGetBlockIoTune(dom, args->disk ? *args->disk : NULL,
                                params, &nparams, args->flags) < 0)
        goto cleanup;

    /* In this case, we need to send back the number of parameters
     * supported
     */
    if (args->nparams == 0) {
        ret->nparams = nparams;
        goto success;
    }

    /* Serialise the block I/O tuning parameters. */
    if (remoteSerializeTypedParameters(params, nparams,
                                       &ret->params.params_val,
                                       &ret->params.params_len,
                                       args->flags) < 0)
        goto cleanup;

success:
    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
2286
    virTypedParamsFree(params, nparams);
2287 2288 2289 2290
    if (dom)
        virDomainFree(dom);
    return rv;
}
2291

D
Daniel Veillard 已提交
2292 2293
/*-------------------------------------------------------------*/

2294
static int
2295 2296
remoteDispatchAuthList(virNetServerPtr server ATTRIBUTE_UNUSED,
                       virNetServerClientPtr client,
2297
                       virNetMessagePtr msg ATTRIBUTE_UNUSED,
2298
                       virNetMessageErrorPtr rerr,
2299
                       remote_auth_list_ret *ret)
2300
{
2301
    int rv = -1;
2302 2303
    int auth = virNetServerClientGetAuth(client);
    uid_t callerUid;
2304
    gid_t callerGid;
2305
    pid_t callerPid;
2306
    unsigned long long timestamp;
2307 2308 2309 2310 2311 2312

    /* If the client is root then we want to bypass the
     * policykit auth to avoid root being denied if
     * some piece of polkit isn't present/running
     */
    if (auth == VIR_NET_SERVER_SERVICE_AUTH_POLKIT) {
2313
        if (virNetServerClientGetUNIXIdentity(client, &callerUid, &callerGid,
2314
                                              &callerPid, &timestamp) < 0) {
2315 2316 2317 2318
            /* Don't do anything on error - it'll be validated at next
             * phase of auth anyway */
            virResetLastError();
        } else if (callerUid == 0) {
2319 2320
            char *ident;
            if (virAsprintf(&ident, "pid:%lld,uid:%d",
2321
                            (long long) callerPid, (int) callerUid) < 0)
J
Jim Fehlig 已提交
2322 2323
                goto cleanup;
            VIR_INFO("Bypass polkit auth for privileged client %s", ident);
2324 2325
            virNetServerClientSetAuth(client, 0);
            auth = VIR_NET_SERVER_SERVICE_AUTH_NONE;
J
Jim Fehlig 已提交
2326
            VIR_FREE(ident);
2327 2328
        }
    }
2329

2330
    ret->types.types_len = 1;
2331
    if (VIR_ALLOC_N(ret->types.types_val, ret->types.types_len) < 0)
2332
        goto cleanup;
2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346

    switch (auth) {
    case VIR_NET_SERVER_SERVICE_AUTH_NONE:
        ret->types.types_val[0] = REMOTE_AUTH_NONE;
        break;
    case VIR_NET_SERVER_SERVICE_AUTH_POLKIT:
        ret->types.types_val[0] = REMOTE_AUTH_POLKIT;
        break;
    case VIR_NET_SERVER_SERVICE_AUTH_SASL:
        ret->types.types_val[0] = REMOTE_AUTH_SASL;
        break;
    default:
        ret->types.types_val[0] = REMOTE_AUTH_NONE;
    }
2347

2348 2349 2350 2351
    rv = 0;

cleanup:
    if (rv < 0)
2352
        virNetMessageSaveError(rerr);
2353
    return rv;
2354 2355 2356
}


2357
#ifdef WITH_SASL
2358 2359
/*
 * Initializes the SASL session in prepare for authentication
2360
 * and gives the client a list of allowed mechanisms to choose
2361 2362
 */
static int
2363 2364
remoteDispatchAuthSaslInit(virNetServerPtr server ATTRIBUTE_UNUSED,
                           virNetServerClientPtr client,
2365
                           virNetMessagePtr msg ATTRIBUTE_UNUSED,
2366
                           virNetMessageErrorPtr rerr,
2367
                           remote_auth_sasl_init_ret *ret)
2368
{
2369 2370 2371
    virNetSASLSessionPtr sasl = NULL;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
2372

2373
    virMutexLock(&priv->lock);
2374

2375 2376 2377
    VIR_DEBUG("Initialize SASL auth %d", virNetServerClientGetFD(client));
    if (virNetServerClientGetAuth(client) != VIR_NET_SERVER_SERVICE_AUTH_SASL ||
        priv->sasl != NULL) {
2378
        VIR_ERROR(_("client tried invalid SASL init request"));
2379
        goto authfail;
2380 2381
    }

2382 2383 2384 2385 2386
    sasl = virNetSASLSessionNewServer(saslCtxt,
                                      "libvirt",
                                      virNetServerClientLocalAddrString(client),
                                      virNetServerClientRemoteAddrString(client));
    if (!sasl)
2387
        goto authfail;
2388

2389
# if WITH_GNUTLS
2390
    /* Inform SASL that we've got an external SSF layer from TLS */
2391 2392 2393 2394
    if (virNetServerClientHasTLSSession(client)) {
        int ssf;

        if ((ssf = virNetServerClientGetTLSKeySize(client)) < 0)
2395
            goto authfail;
2396 2397 2398 2399 2400

        ssf *= 8; /* key size is bytes, sasl wants bits */

        VIR_DEBUG("Setting external SSF %d", ssf);
        if (virNetSASLSessionExtKeySize(sasl, ssf) < 0)
2401
            goto authfail;
2402
    }
2403
# endif
2404

2405
    if (virNetServerClientIsSecure(client))
2406
        /* If we've got TLS or UNIX domain sock, we don't care about SSF */
2407 2408
        virNetSASLSessionSecProps(sasl, 0, 0, true);
    else
2409
        /* Plain TCP, better get an SSF layer */
2410 2411 2412 2413
        virNetSASLSessionSecProps(sasl,
                                  56,  /* Good enough to require kerberos */
                                  100000,  /* Arbitrary big number */
                                  false); /* No anonymous */
2414

2415
    if (!(ret->mechlist = virNetSASLSessionListMechanisms(sasl)))
2416
        goto authfail;
2417
    VIR_DEBUG("Available mechanisms for client: '%s'", ret->mechlist);
2418

2419 2420
    priv->sasl = sasl;
    virMutexUnlock(&priv->lock);
2421
    return 0;
2422 2423

authfail:
2424
    virResetLastError();
2425 2426
    virReportError(VIR_ERR_AUTH_FAILED, "%s",
                   _("authentication failed"));
2427
    virNetMessageSaveError(rerr);
2428 2429 2430
    PROBE(RPC_SERVER_CLIENT_AUTH_FAIL,
          "client=%p auth=%d",
          client, REMOTE_AUTH_SASL);
2431
    virObjectUnref(sasl);
2432
    virMutexUnlock(&priv->lock);
2433
    return -1;
2434 2435
}

2436
/*
2437 2438
 * Returns 0 if ok, -1 on error, -2 if rejected
 */
2439
static int
2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455
remoteSASLFinish(virNetServerClientPtr client)
{
    const char *identity;
    struct daemonClientPrivate *priv = virNetServerClientGetPrivateData(client);
    int ssf;

    /* TLS or UNIX domain sockets trivially OK */
    if (!virNetServerClientIsSecure(client)) {
        if ((ssf = virNetSASLSessionGetKeySize(priv->sasl)) < 0)
            goto error;

        VIR_DEBUG("negotiated an SSF of %d", ssf);
        if (ssf < 56) { /* 56 is good for Kerberos */
            VIR_ERROR(_("negotiated SSF %d was not strong enough"), ssf);
            return -2;
        }
2456
    }
2457 2458

    if (!(identity = virNetSASLSessionGetIdentity(priv->sasl)))
2459
        return -2;
2460

2461 2462
    if (!virNetSASLContextCheckIdentity(saslCtxt, identity))
        return -2;
2463

2464
    virNetServerClientSetAuth(client, 0);
2465
    virNetServerClientSetSASLSession(client, priv->sasl);
2466

2467
    VIR_DEBUG("Authentication successful %d", virNetServerClientGetFD(client));
2468

2469 2470 2471
    PROBE(RPC_SERVER_CLIENT_AUTH_ALLOW,
          "client=%p auth=%d identity=%s",
          client, REMOTE_AUTH_SASL, identity);
2472

2473
    virObjectUnref(priv->sasl);
2474
    priv->sasl = NULL;
2475

2476
    return 0;
2477

2478 2479 2480
error:
    return -1;
}
2481

2482 2483 2484 2485
/*
 * This starts the SASL authentication negotiation.
 */
static int
2486 2487
remoteDispatchAuthSaslStart(virNetServerPtr server ATTRIBUTE_UNUSED,
                            virNetServerClientPtr client,
2488
                            virNetMessagePtr msg ATTRIBUTE_UNUSED,
2489
                            virNetMessageErrorPtr rerr,
2490 2491
                            remote_auth_sasl_start_args *args,
                            remote_auth_sasl_start_ret *ret)
2492 2493
{
    const char *serverout;
2494
    size_t serveroutlen;
2495
    int err;
2496 2497 2498
    int rv = -1;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
2499
    const char *identity;
2500

2501
    virMutexLock(&priv->lock);
2502

2503 2504 2505
    VIR_DEBUG("Start SASL auth %d", virNetServerClientGetFD(client));
    if (virNetServerClientGetAuth(client) != VIR_NET_SERVER_SERVICE_AUTH_SASL ||
        priv->sasl == NULL) {
2506
        VIR_ERROR(_("client tried invalid SASL start request"));
2507
        goto authfail;
2508 2509
    }

2510 2511
    VIR_DEBUG("Using SASL mechanism %s. Data %d bytes, nil: %d",
              args->mech, args->data.data_len, args->nil);
2512 2513 2514 2515 2516 2517 2518 2519 2520
    err = virNetSASLSessionServerStart(priv->sasl,
                                       args->mech,
                                       /* NB, distinction of NULL vs "" is *critical* in SASL */
                                       args->nil ? NULL : args->data.data_val,
                                       args->data.data_len,
                                       &serverout,
                                       &serveroutlen);
    if (err != VIR_NET_SASL_COMPLETE &&
        err != VIR_NET_SASL_CONTINUE)
2521
        goto authfail;
2522

2523
    if (serveroutlen > REMOTE_AUTH_SASL_DATA_MAX) {
2524
        VIR_ERROR(_("sasl start reply data too long %d"), (int)serveroutlen);
2525
        goto authfail;
2526 2527 2528 2529
    }

    /* NB, distinction of NULL vs "" is *critical* in SASL */
    if (serverout) {
2530 2531
        if (VIR_ALLOC_N(ret->data.data_val, serveroutlen) < 0)
            goto authfail;
2532 2533 2534 2535 2536 2537 2538
        memcpy(ret->data.data_val, serverout, serveroutlen);
    } else {
        ret->data.data_val = NULL;
    }
    ret->nil = serverout ? 0 : 1;
    ret->data.data_len = serveroutlen;

2539
    VIR_DEBUG("SASL return data %d bytes, nil; %d", ret->data.data_len, ret->nil);
2540
    if (err == VIR_NET_SASL_CONTINUE) {
2541 2542
        ret->complete = 0;
    } else {
2543
        /* Check username whitelist ACL */
2544
        if ((err = remoteSASLFinish(client)) < 0) {
2545 2546 2547 2548 2549
            if (err == -2)
                goto authdeny;
            else
                goto authfail;
        }
2550

2551 2552 2553
        ret->complete = 1;
    }

2554
    virMutexUnlock(&priv->lock);
2555
    return 0;
2556 2557

authfail:
2558 2559 2560
    PROBE(RPC_SERVER_CLIENT_AUTH_FAIL,
          "client=%p auth=%d",
          client, REMOTE_AUTH_SASL);
2561 2562 2563
    goto error;

authdeny:
2564
    identity = virNetSASLSessionGetIdentity(priv->sasl);
2565 2566 2567
    PROBE(RPC_SERVER_CLIENT_AUTH_DENY,
          "client=%p auth=%d identity=%s",
          client, REMOTE_AUTH_SASL, identity);
2568 2569
    goto error;

2570
error:
2571
    virObjectUnref(priv->sasl);
2572 2573
    priv->sasl = NULL;
    virResetLastError();
2574 2575
    virReportError(VIR_ERR_AUTH_FAILED, "%s",
                   _("authentication failed"));
2576 2577 2578
    if (rv < 0)
        virNetMessageSaveError(rerr);
    virMutexUnlock(&priv->lock);
2579
    return -1;
2580 2581 2582 2583
}


static int
2584 2585
remoteDispatchAuthSaslStep(virNetServerPtr server ATTRIBUTE_UNUSED,
                           virNetServerClientPtr client,
2586
                           virNetMessagePtr msg ATTRIBUTE_UNUSED,
2587
                           virNetMessageErrorPtr rerr,
2588 2589
                           remote_auth_sasl_step_args *args,
                           remote_auth_sasl_step_ret *ret)
2590 2591
{
    const char *serverout;
2592
    size_t serveroutlen;
2593
    int err;
2594 2595 2596
    int rv = -1;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
2597
    const char *identity;
2598

2599 2600 2601 2602 2603
    virMutexLock(&priv->lock);

    VIR_DEBUG("Step SASL auth %d", virNetServerClientGetFD(client));
    if (virNetServerClientGetAuth(client) != VIR_NET_SERVER_SERVICE_AUTH_SASL ||
        priv->sasl == NULL) {
2604
        VIR_ERROR(_("client tried invalid SASL start request"));
2605
        goto authfail;
2606 2607
    }

2608
    VIR_DEBUG("Step using SASL Data %d bytes, nil: %d",
2609
              args->data.data_len, args->nil);
2610 2611 2612 2613 2614 2615 2616 2617
    err = virNetSASLSessionServerStep(priv->sasl,
                                      /* NB, distinction of NULL vs "" is *critical* in SASL */
                                      args->nil ? NULL : args->data.data_val,
                                      args->data.data_len,
                                      &serverout,
                                      &serveroutlen);
    if (err != VIR_NET_SASL_COMPLETE &&
        err != VIR_NET_SASL_CONTINUE)
2618
        goto authfail;
2619 2620

    if (serveroutlen > REMOTE_AUTH_SASL_DATA_MAX) {
2621
        VIR_ERROR(_("sasl step reply data too long %d"),
2622
                  (int)serveroutlen);
2623
        goto authfail;
2624 2625 2626 2627
    }

    /* NB, distinction of NULL vs "" is *critical* in SASL */
    if (serverout) {
2628 2629
        if (VIR_ALLOC_N(ret->data.data_val, serveroutlen) < 0)
            goto authfail;
2630 2631 2632 2633 2634 2635 2636
        memcpy(ret->data.data_val, serverout, serveroutlen);
    } else {
        ret->data.data_val = NULL;
    }
    ret->nil = serverout ? 0 : 1;
    ret->data.data_len = serveroutlen;

2637
    VIR_DEBUG("SASL return data %d bytes, nil; %d", ret->data.data_len, ret->nil);
2638
    if (err == VIR_NET_SASL_CONTINUE) {
2639 2640
        ret->complete = 0;
    } else {
2641
        /* Check username whitelist ACL */
2642
        if ((err = remoteSASLFinish(client)) < 0) {
2643 2644 2645 2646 2647
            if (err == -2)
                goto authdeny;
            else
                goto authfail;
        }
2648

2649 2650 2651
        ret->complete = 1;
    }

2652
    virMutexUnlock(&priv->lock);
2653
    return 0;
2654 2655

authfail:
2656 2657 2658
    PROBE(RPC_SERVER_CLIENT_AUTH_FAIL,
          "client=%p auth=%d",
          client, REMOTE_AUTH_SASL);
2659 2660 2661
    goto error;

authdeny:
2662
    identity = virNetSASLSessionGetIdentity(priv->sasl);
2663 2664 2665
    PROBE(RPC_SERVER_CLIENT_AUTH_DENY,
          "client=%p auth=%d identity=%s",
          client, REMOTE_AUTH_SASL, identity);
2666 2667
    goto error;

2668
error:
2669
    virObjectUnref(priv->sasl);
2670 2671
    priv->sasl = NULL;
    virResetLastError();
2672 2673
    virReportError(VIR_ERR_AUTH_FAILED, "%s",
                   _("authentication failed"));
2674 2675 2676
    if (rv < 0)
        virNetMessageSaveError(rerr);
    virMutexUnlock(&priv->lock);
2677 2678
    return -1;
}
2679 2680 2681 2682
#else
static int
remoteDispatchAuthSaslInit(virNetServerPtr server ATTRIBUTE_UNUSED,
                           virNetServerClientPtr client ATTRIBUTE_UNUSED,
2683
                           virNetMessagePtr msg ATTRIBUTE_UNUSED,
2684 2685 2686 2687
                           virNetMessageErrorPtr rerr,
                           remote_auth_sasl_init_ret *ret ATTRIBUTE_UNUSED)
{
    VIR_WARN("Client tried unsupported SASL auth");
2688 2689
    virReportError(VIR_ERR_AUTH_FAILED, "%s",
                   _("authentication failed"));
2690 2691 2692 2693 2694 2695
    virNetMessageSaveError(rerr);
    return -1;
}
static int
remoteDispatchAuthSaslStart(virNetServerPtr server ATTRIBUTE_UNUSED,
                            virNetServerClientPtr client ATTRIBUTE_UNUSED,
2696
                            virNetMessagePtr msg ATTRIBUTE_UNUSED,
2697 2698 2699 2700 2701
                            virNetMessageErrorPtr rerr,
                            remote_auth_sasl_start_args *args ATTRIBUTE_UNUSED,
                            remote_auth_sasl_start_ret *ret ATTRIBUTE_UNUSED)
{
    VIR_WARN("Client tried unsupported SASL auth");
2702 2703
    virReportError(VIR_ERR_AUTH_FAILED, "%s",
                   _("authentication failed"));
2704 2705 2706 2707 2708 2709
    virNetMessageSaveError(rerr);
    return -1;
}
static int
remoteDispatchAuthSaslStep(virNetServerPtr server ATTRIBUTE_UNUSED,
                           virNetServerClientPtr client ATTRIBUTE_UNUSED,
2710
                           virNetMessagePtr msg ATTRIBUTE_UNUSED,
2711 2712 2713 2714 2715
                           virNetMessageErrorPtr rerr,
                           remote_auth_sasl_step_args *args ATTRIBUTE_UNUSED,
                           remote_auth_sasl_step_ret *ret ATTRIBUTE_UNUSED)
{
    VIR_WARN("Client tried unsupported SASL auth");
2716 2717
    virReportError(VIR_ERR_AUTH_FAILED, "%s",
                   _("authentication failed"));
2718 2719 2720 2721
    virNetMessageSaveError(rerr);
    return -1;
}
#endif
2722 2723 2724



2725
#if WITH_POLKIT1
2726
static int
2727 2728
remoteDispatchAuthPolkit(virNetServerPtr server ATTRIBUTE_UNUSED,
                         virNetServerClientPtr client,
2729
                         virNetMessagePtr msg ATTRIBUTE_UNUSED,
2730
                         virNetMessageErrorPtr rerr,
2731
                         remote_auth_polkit_ret *ret)
2732
{
2733
    pid_t callerPid = -1;
2734
    gid_t callerGid = -1;
2735
    uid_t callerUid = -1;
2736
    unsigned long long timestamp;
2737 2738
    const char *action;
    int status = -1;
2739
    char *ident = NULL;
2740
    bool authdismissed = 0;
2741
    bool supportsuid = false;
2742
    char *pkout = NULL;
2743 2744
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
2745
    virCommandPtr cmd = NULL;
2746
    static bool polkitInsecureWarned;
2747

2748 2749
    virMutexLock(&priv->lock);
    action = virNetServerClientGetReadonly(client) ?
2750 2751 2752
        "org.libvirt.unix.monitor" :
        "org.libvirt.unix.manage";

2753
    cmd = virCommandNewArgList(PKCHECK_PATH, "--action-id", action, NULL);
2754
    virCommandSetOutputBuffer(cmd, &pkout);
2755
    virCommandSetErrorBuffer(cmd, &pkout);
2756

2757 2758
    VIR_DEBUG("Start PolicyKit auth %d", virNetServerClientGetFD(client));
    if (virNetServerClientGetAuth(client) != VIR_NET_SERVER_SERVICE_AUTH_POLKIT) {
2759
        VIR_ERROR(_("client tried invalid PolicyKit init request"));
2760 2761 2762
        goto authfail;
    }

2763
    if (virNetServerClientGetUNIXIdentity(client, &callerUid, &callerGid,
2764
                                          &callerPid, &timestamp) < 0) {
2765 2766 2767
        goto authfail;
    }

2768 2769 2770 2771 2772 2773
    if (timestamp == 0) {
        VIR_WARN("Failing polkit auth due to missing client (pid=%lld) start time",
                 (long long)callerPid);
        goto authfail;
    }

2774 2775
    VIR_INFO("Checking PID %lld running as %d",
             (long long) callerPid, callerUid);
2776

2777
    virCommandAddArg(cmd, "--process");
2778 2779 2780 2781 2782 2783
# ifdef PKCHECK_SUPPORTS_UID
    supportsuid = true;
# endif
    if (supportsuid) {
        virCommandAddArgFormat(cmd, "%lld,%llu,%lu",
                               (long long) callerPid, timestamp, (unsigned long) callerUid);
2784
    } else {
2785 2786 2787 2788 2789
        if (!polkitInsecureWarned) {
            VIR_WARN("No support for caller UID with pkcheck. This deployment is known to be insecure.");
            polkitInsecureWarned = true;
        }
        virCommandAddArgFormat(cmd, "%lld,%llu", (long long) callerPid, timestamp);
2790
    }
2791
    virCommandAddArg(cmd, "--allow-user-interaction");
2792

2793
    if (virAsprintf(&ident, "pid:%lld,uid:%d",
2794
                    (long long) callerPid, callerUid) < 0)
2795 2796
        goto authfail;

2797
    if (virCommandRun(cmd, &status) < 0)
2798
        goto authfail;
2799

2800
    authdismissed = (pkout && strstr(pkout, "dismissed=true"));
2801
    if (status != 0) {
2802
        char *tmp = virProcessTranslateStatus(status);
2803 2804
        VIR_ERROR(_("Policy kit denied action %s from pid %lld, uid %d: %s"),
                  action, (long long) callerPid, callerUid, NULLSTR(tmp));
2805
        VIR_FREE(tmp);
2806
        goto authdeny;
2807
    }
2808 2809 2810
    PROBE(RPC_SERVER_CLIENT_AUTH_ALLOW,
          "client=%p auth=%d identity=%s",
          client, REMOTE_AUTH_POLKIT, ident);
2811 2812
    VIR_INFO("Policy allowed action %s from pid %lld, uid %d",
             action, (long long) callerPid, callerUid);
2813 2814
    ret->complete = 1;

2815
    virNetServerClientSetAuth(client, 0);
2816
    virMutexUnlock(&priv->lock);
2817
    virCommandFree(cmd);
E
Eric Blake 已提交
2818
    VIR_FREE(pkout);
2819
    VIR_FREE(ident);
2820

2821 2822
    return 0;

2823
error:
2824 2825
    virCommandFree(cmd);
    VIR_FREE(ident);
2826
    virResetLastError();
2827

2828
    if (authdismissed) {
2829 2830
        virReportError(VIR_ERR_AUTH_CANCELLED, "%s",
                       _("authentication cancelled by user"));
2831 2832
    } else if (pkout && *pkout) {
        virReportError(VIR_ERR_AUTH_FAILED, _("polkit: %s"), pkout);
2833
    } else {
2834
        virReportError(VIR_ERR_AUTH_FAILED, "%s", _("authentication failed"));
2835
    }
2836 2837

    VIR_FREE(pkout);
2838 2839 2840 2841
    virNetMessageSaveError(rerr);
    virMutexUnlock(&priv->lock);
    return -1;

2842
authfail:
2843 2844 2845
    PROBE(RPC_SERVER_CLIENT_AUTH_FAIL,
          "client=%p auth=%d",
          client, REMOTE_AUTH_POLKIT);
2846 2847 2848
    goto error;

authdeny:
2849 2850
    PROBE(RPC_SERVER_CLIENT_AUTH_DENY,
          "client=%p auth=%d identity=%s",
2851
          client, REMOTE_AUTH_POLKIT, ident);
2852
    goto error;
2853
}
2854
#elif WITH_POLKIT0
2855
static int
2856
remoteDispatchAuthPolkit(virNetServerPtr server ATTRIBUTE_UNUSED,
2857
                         virNetServerClientPtr client,
2858
                         virNetMessagePtr msg ATTRIBUTE_UNUSED,
2859
                         virNetMessageErrorPtr rerr,
2860
                         remote_auth_polkit_ret *ret)
2861 2862
{
    pid_t callerPid;
2863
    gid_t callerGid;
2864
    uid_t callerUid;
2865 2866 2867 2868 2869 2870
    PolKitCaller *pkcaller = NULL;
    PolKitAction *pkaction = NULL;
    PolKitContext *pkcontext = NULL;
    PolKitError *pkerr = NULL;
    PolKitResult pkresult;
    DBusError err;
2871
    const char *action;
2872
    char *ident = NULL;
2873 2874
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
2875
    DBusConnection *sysbus;
J
Jim Fehlig 已提交
2876
    unsigned long long timestamp;
2877

J
Jim Fehlig 已提交
2878
    virMutexLock(&priv->lock);
2879

J
Jim Fehlig 已提交
2880
    action = virNetServerClientGetReadonly(client) ?
2881 2882
        "org.libvirt.unix.monitor" :
        "org.libvirt.unix.manage";
2883

2884
    VIR_DEBUG("Start PolicyKit auth %d", virNetServerClientGetFD(client));
J
Jim Fehlig 已提交
2885
    if (virNetServerClientGetAuth(client) != VIR_NET_SERVER_SERVICE_AUTH_POLKIT) {
2886
        VIR_ERROR(_("client tried invalid PolicyKit init request"));
2887
        goto authfail;
2888 2889
    }

2890
    if (virNetServerClientGetUNIXIdentity(client, &callerUid, &callerGid,
J
Jim Fehlig 已提交
2891
                                          &callerPid, &timestamp) < 0) {
2892
        VIR_ERROR(_("cannot get peer socket identity"));
2893
        goto authfail;
2894 2895
    }

2896
    if (virAsprintf(&ident, "pid:%lld,uid:%d",
2897
                    (long long) callerPid, callerUid) < 0)
2898 2899
        goto authfail;

2900 2901 2902
    if (!(sysbus = virDBusGetSystemBus()))
        goto authfail;

2903 2904
    VIR_INFO("Checking PID %lld running as %d",
             (long long) callerPid, callerUid);
2905
    dbus_error_init(&err);
2906
    if (!(pkcaller = polkit_caller_new_from_pid(sysbus,
2907
                                                callerPid, &err))) {
2908
        VIR_ERROR(_("Failed to lookup policy kit caller: %s"), err.message);
2909
        dbus_error_free(&err);
2910
        goto authfail;
2911
    }
2912

2913
    if (!(pkaction = polkit_action_new())) {
2914
        char ebuf[1024];
2915
        VIR_ERROR(_("Failed to create polkit action %s"),
2916
                  virStrerror(errno, ebuf, sizeof(ebuf)));
2917
        polkit_caller_unref(pkcaller);
2918
        goto authfail;
2919 2920 2921 2922 2923
    }
    polkit_action_set_action_id(pkaction, action);

    if (!(pkcontext = polkit_context_new()) ||
        !polkit_context_init(pkcontext, &pkerr)) {
2924
        char ebuf[1024];
2925
        VIR_ERROR(_("Failed to create polkit context %s"),
2926
                  (pkerr ? polkit_error_get_error_message(pkerr)
2927
                   : virStrerror(errno, ebuf, sizeof(ebuf))));
2928 2929 2930 2931 2932
        if (pkerr)
            polkit_error_free(pkerr);
        polkit_caller_unref(pkcaller);
        polkit_action_unref(pkaction);
        dbus_error_free(&err);
2933
        goto authfail;
2934
    }
2935

2936
# if HAVE_POLKIT_CONTEXT_IS_CALLER_AUTHORIZED
2937 2938 2939 2940 2941 2942
    pkresult = polkit_context_is_caller_authorized(pkcontext,
                                                   pkaction,
                                                   pkcaller,
                                                   0,
                                                   &pkerr);
    if (pkerr && polkit_error_is_set(pkerr)) {
2943 2944 2945
        VIR_ERROR(_("Policy kit failed to check authorization %d %s"),
                  polkit_error_get_error_code(pkerr),
                  polkit_error_get_error_message(pkerr));
2946
        goto authfail;
2947
    }
2948
# else
2949 2950 2951
    pkresult = polkit_context_can_caller_do_action(pkcontext,
                                                   pkaction,
                                                   pkcaller);
2952
# endif
2953 2954 2955 2956
    polkit_context_unref(pkcontext);
    polkit_caller_unref(pkcaller);
    polkit_action_unref(pkaction);
    if (pkresult != POLKIT_RESULT_YES) {
2957 2958
        VIR_ERROR(_("Policy kit denied action %s from pid %lld, uid %d, result: %s"),
                  action, (long long) callerPid, callerUid,
2959
                  polkit_result_to_string_representation(pkresult));
2960
        goto authdeny;
2961
    }
2962 2963 2964
    PROBE(RPC_SERVER_CLIENT_AUTH_ALLOW,
          "client=%p auth=%d identity=%s",
          client, REMOTE_AUTH_POLKIT, ident);
2965 2966
    VIR_INFO("Policy allowed action %s from pid %lld, uid %d, result %s",
             action, (long long) callerPid, callerUid,
2967 2968
             polkit_result_to_string_representation(pkresult));
    ret->complete = 1;
2969

2970
    virNetServerClientSetAuth(client, 0);
J
Jim Fehlig 已提交
2971
    virMutexUnlock(&priv->lock);
2972
    VIR_FREE(ident);
2973
    return 0;
2974

2975
error:
2976
    VIR_FREE(ident);
2977
    virResetLastError();
2978 2979
    virReportError(VIR_ERR_AUTH_FAILED, "%s",
                   _("authentication failed"));
2980
    virNetMessageSaveError(rerr);
J
Jim Fehlig 已提交
2981
    virMutexUnlock(&priv->lock);
2982 2983
    return -1;

2984
authfail:
2985 2986 2987
    PROBE(RPC_SERVER_CLIENT_AUTH_FAIL,
          "client=%p auth=%d",
          client, REMOTE_AUTH_POLKIT);
2988
    goto error;
2989

2990
authdeny:
2991 2992 2993
    PROBE(RPC_SERVER_CLIENT_AUTH_DENY,
          "client=%p auth=%d identity=%s",
          client, REMOTE_AUTH_POLKIT, ident);
2994
    goto error;
2995 2996
}

2997
#else /* !WITH_POLKIT0 & !HAVE_POLKIT1*/
2998 2999

static int
3000
remoteDispatchAuthPolkit(virNetServerPtr server ATTRIBUTE_UNUSED,
J
Jiri Denemark 已提交
3001
                         virNetServerClientPtr client ATTRIBUTE_UNUSED,
3002
                         virNetMessagePtr msg ATTRIBUTE_UNUSED,
3003
                         virNetMessageErrorPtr rerr,
3004
                         remote_auth_polkit_ret *ret ATTRIBUTE_UNUSED)
3005
{
3006
    VIR_ERROR(_("client tried unsupported PolicyKit init request"));
3007 3008
    virReportError(VIR_ERR_AUTH_FAILED, "%s",
                   _("authentication failed"));
3009
    virNetMessageSaveError(rerr);
3010 3011
    return -1;
}
3012
#endif /* WITH_POLKIT1 */
3013 3014


3015 3016 3017
/***************************************************************
 *     NODE INFO APIS
 **************************************************************/
3018

3019
static int
3020 3021
remoteDispatchNodeDeviceGetParent(virNetServerPtr server ATTRIBUTE_UNUSED,
                                  virNetServerClientPtr client ATTRIBUTE_UNUSED,
3022
                                  virNetMessagePtr msg ATTRIBUTE_UNUSED,
3023
                                  virNetMessageErrorPtr rerr,
3024 3025
                                  remote_node_device_get_parent_args *args,
                                  remote_node_device_get_parent_ret *ret)
3026
{
3027 3028
    virNodeDevicePtr dev = NULL;
    const char *parent = NULL;
3029
    int rv = -1;
3030 3031
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
3032

3033
    if (!priv->conn) {
3034
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
3035
        goto cleanup;
3036 3037
    }

3038
    if (!(dev = virNodeDeviceLookupByName(priv->conn, args->name)))
3039 3040
        goto cleanup;

3041 3042 3043 3044 3045 3046 3047
    parent = virNodeDeviceGetParent(dev);

    if (parent == NULL) {
        ret->parent = NULL;
    } else {
        /* remoteDispatchClientRequest will free this. */
        char **parent_p;
3048
        if (VIR_ALLOC(parent_p) < 0)
3049
            goto cleanup;
3050
        if (VIR_STRDUP(*parent_p, parent) < 0) {
3051 3052 3053 3054 3055 3056
            VIR_FREE(parent_p);
            goto cleanup;
        }
        ret->parent = parent_p;
    }

3057 3058 3059 3060
    rv = 0;

cleanup:
    if (rv < 0)
3061
        virNetMessageSaveError(rerr);
3062 3063
    if (dev)
        virNodeDeviceFree(dev);
3064
    return rv;
3065 3066
}

3067 3068 3069 3070 3071

/***************************
 * Register / deregister events
 ***************************/
static int
3072 3073 3074 3075 3076
remoteDispatchConnectDomainEventRegister(virNetServerPtr server ATTRIBUTE_UNUSED,
                                         virNetServerClientPtr client ATTRIBUTE_UNUSED,
                                         virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                         virNetMessageErrorPtr rerr ATTRIBUTE_UNUSED,
                                         remote_connect_domain_event_register_ret *ret ATTRIBUTE_UNUSED)
O
Osier Yang 已提交
3077
{
3078
    int callbackID;
3079
    int rv = -1;
3080 3081
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
O
Osier Yang 已提交
3082

3083
    if (!priv->conn) {
3084
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
3085
        goto cleanup;
3086 3087
    }

3088 3089 3090
    virMutexLock(&priv->lock);

    if (priv->domainEventCallbackID[VIR_DOMAIN_EVENT_ID_LIFECYCLE] != -1) {
3091
        virReportError(VIR_ERR_INTERNAL_ERROR, _("domain event %d already registered"), VIR_DOMAIN_EVENT_ID_LIFECYCLE);
3092
        goto cleanup;
3093
    }
O
Osier Yang 已提交
3094

3095
    if ((callbackID = virConnectDomainEventRegisterAny(priv->conn,
3096 3097 3098 3099
                                                       NULL,
                                                       VIR_DOMAIN_EVENT_ID_LIFECYCLE,
                                                       VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventLifecycle),
                                                       client, NULL)) < 0)
3100
        goto cleanup;
O
Osier Yang 已提交
3101

3102
    priv->domainEventCallbackID[VIR_DOMAIN_EVENT_ID_LIFECYCLE] = callbackID;
3103

3104 3105 3106 3107
    rv = 0;

cleanup:
    if (rv < 0)
3108 3109
        virNetMessageSaveError(rerr);
    virMutexUnlock(&priv->lock);
3110
    return rv;
O
Osier Yang 已提交
3111 3112
}

3113
static int
3114 3115 3116 3117 3118
remoteDispatchConnectDomainEventDeregister(virNetServerPtr server ATTRIBUTE_UNUSED,
                                           virNetServerClientPtr client ATTRIBUTE_UNUSED,
                                           virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                           virNetMessageErrorPtr rerr ATTRIBUTE_UNUSED,
                                           remote_connect_domain_event_deregister_ret *ret ATTRIBUTE_UNUSED)
3119
{
3120
    int rv = -1;
3121 3122
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
3123

3124
    if (!priv->conn) {
3125
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
3126
        goto cleanup;
3127 3128
    }

3129 3130 3131
    virMutexLock(&priv->lock);

    if (priv->domainEventCallbackID[VIR_DOMAIN_EVENT_ID_LIFECYCLE] < 0) {
3132
        virReportError(VIR_ERR_INTERNAL_ERROR, _("domain event %d not registered"), VIR_DOMAIN_EVENT_ID_LIFECYCLE);
3133
        goto cleanup;
3134
    }
3135

3136 3137
    if (virConnectDomainEventDeregisterAny(priv->conn,
                                           priv->domainEventCallbackID[VIR_DOMAIN_EVENT_ID_LIFECYCLE]) < 0)
3138
        goto cleanup;
3139

3140 3141
    priv->domainEventCallbackID[VIR_DOMAIN_EVENT_ID_LIFECYCLE] = -1;

3142 3143 3144
    rv = 0;

cleanup:
3145
    if (rv < 0)
3146 3147
        virNetMessageSaveError(rerr);
    virMutexUnlock(&priv->lock);
3148 3149 3150 3151
    return rv;
}

static void
3152 3153
remoteDispatchDomainEventSend(virNetServerClientPtr client,
                              virNetServerProgramPtr program,
3154 3155 3156 3157
                              int procnr,
                              xdrproc_t proc,
                              void *data)
{
3158
    virNetMessagePtr msg;
3159

3160
    if (!(msg = virNetMessageNew(false)))
3161
        goto cleanup;
3162

3163 3164 3165 3166 3167 3168
    msg->header.prog = virNetServerProgramGetID(program);
    msg->header.vers = virNetServerProgramGetVersion(program);
    msg->header.proc = procnr;
    msg->header.type = VIR_NET_MESSAGE;
    msg->header.serial = 1;
    msg->header.status = VIR_NET_OK;
3169

3170
    if (virNetMessageEncodeHeader(msg) < 0)
3171 3172
        goto cleanup;

3173 3174
    if (virNetMessageEncodePayload(msg, proc, data) < 0)
        goto cleanup;
3175

3176 3177
    VIR_DEBUG("Queue event %d %zu", procnr, msg->bufferLength);
    virNetServerClientSendMessage(client, msg);
3178

3179
    xdr_free(proc, data);
3180 3181 3182
    return;

cleanup:
3183
    virNetMessageFree(msg);
3184
    xdr_free(proc, data);
3185 3186
}

3187
static int
3188 3189
remoteDispatchSecretGetValue(virNetServerPtr server ATTRIBUTE_UNUSED,
                             virNetServerClientPtr client ATTRIBUTE_UNUSED,
3190
                             virNetMessagePtr msg ATTRIBUTE_UNUSED,
3191
                             virNetMessageErrorPtr rerr,
3192 3193
                             remote_secret_get_value_args *args,
                             remote_secret_get_value_ret *ret)
3194
{
3195 3196 3197
    virSecretPtr secret = NULL;
    size_t value_size;
    unsigned char *value;
3198
    int rv = -1;
3199 3200
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
3201

3202
    if (!priv->conn) {
3203
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
3204
        goto cleanup;
3205 3206
    }

3207
    if (!(secret = get_nonnull_secret(priv->conn, args->secret)))
3208
        goto cleanup;
3209

3210
    if (!(value = virSecretGetValue(secret, &value_size, args->flags)))
3211
        goto cleanup;
3212

3213 3214 3215
    ret->value.value_len = value_size;
    ret->value.value_val = (char *)value;

3216 3217 3218 3219
    rv = 0;

cleanup:
    if (rv < 0)
3220
        virNetMessageSaveError(rerr);
3221 3222
    if (secret)
        virSecretFree(secret);
3223
    return rv;
3224 3225
}

3226
static int
3227 3228
remoteDispatchDomainGetState(virNetServerPtr server ATTRIBUTE_UNUSED,
                             virNetServerClientPtr client ATTRIBUTE_UNUSED,
3229
                             virNetMessagePtr msg ATTRIBUTE_UNUSED,
3230
                             virNetMessageErrorPtr rerr,
3231 3232 3233 3234 3235
                             remote_domain_get_state_args *args,
                             remote_domain_get_state_ret *ret)
{
    virDomainPtr dom = NULL;
    int rv = -1;
3236 3237
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
3238

3239
    if (!priv->conn) {
3240
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
3241 3242 3243
        goto cleanup;
    }

3244
    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
3245 3246 3247 3248 3249 3250 3251 3252 3253
        goto cleanup;

    if (virDomainGetState(dom, &ret->state, &ret->reason, args->flags) < 0)
        goto cleanup;

    rv = 0;

cleanup:
    if (rv < 0)
3254
        virNetMessageSaveError(rerr);
3255 3256 3257 3258 3259
    if (dom)
        virDomainFree(dom);
    return rv;
}

3260
static int
3261 3262 3263 3264 3265
remoteDispatchConnectDomainEventRegisterAny(virNetServerPtr server ATTRIBUTE_UNUSED,
                                            virNetServerClientPtr client ATTRIBUTE_UNUSED,
                                            virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                            virNetMessageErrorPtr rerr ATTRIBUTE_UNUSED,
                                            remote_connect_domain_event_register_any_args *args)
3266 3267
{
    int callbackID;
3268
    int rv = -1;
3269 3270
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
3271

3272
    if (!priv->conn) {
3273
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
3274
        goto cleanup;
3275 3276
    }

3277 3278
    virMutexLock(&priv->lock);

3279 3280
    if (args->eventID >= VIR_DOMAIN_EVENT_ID_LAST ||
        args->eventID < 0) {
3281
        virReportError(VIR_ERR_INTERNAL_ERROR, _("unsupported event ID %d"), args->eventID);
3282
        goto cleanup;
3283 3284
    }

3285
    if (priv->domainEventCallbackID[args->eventID] != -1)  {
3286
        virReportError(VIR_ERR_INTERNAL_ERROR, _("domain event %d already registered"), args->eventID);
3287
        goto cleanup;
3288 3289
    }

3290
    if ((callbackID = virConnectDomainEventRegisterAny(priv->conn,
3291 3292 3293
                                                       NULL,
                                                       args->eventID,
                                                       domainEventCallbacks[args->eventID],
3294
                                                       client, NULL)) < 0)
3295
        goto cleanup;
3296

3297
    priv->domainEventCallbackID[args->eventID] = callbackID;
3298

3299 3300 3301 3302
    rv = 0;

cleanup:
    if (rv < 0)
3303 3304
        virNetMessageSaveError(rerr);
    virMutexUnlock(&priv->lock);
3305
    return rv;
3306 3307 3308 3309
}


static int
3310 3311 3312 3313 3314
remoteDispatchConnectDomainEventDeregisterAny(virNetServerPtr server ATTRIBUTE_UNUSED,
                                              virNetServerClientPtr client ATTRIBUTE_UNUSED,
                                              virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                              virNetMessageErrorPtr rerr ATTRIBUTE_UNUSED,
                                              remote_connect_domain_event_deregister_any_args *args)
3315 3316
{
    int callbackID = -1;
3317
    int rv = -1;
3318 3319
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
3320

3321
    if (!priv->conn) {
3322
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
3323
        goto cleanup;
3324 3325
    }

3326 3327
    virMutexLock(&priv->lock);

3328 3329
    if (args->eventID >= VIR_DOMAIN_EVENT_ID_LAST ||
        args->eventID < 0) {
3330
        virReportError(VIR_ERR_INTERNAL_ERROR, _("unsupported event ID %d"), args->eventID);
3331
        goto cleanup;
3332 3333
    }

3334 3335
    callbackID = priv->domainEventCallbackID[args->eventID];
    if (callbackID < 0) {
3336
        virReportError(VIR_ERR_INTERNAL_ERROR, _("domain event %d not registered"), args->eventID);
3337
        goto cleanup;
3338 3339
    }

3340
    if (virConnectDomainEventDeregisterAny(priv->conn, callbackID) < 0)
3341
        goto cleanup;
3342

3343 3344
    priv->domainEventCallbackID[args->eventID] = -1;

3345 3346 3347 3348
    rv = 0;

cleanup:
    if (rv < 0)
3349 3350
        virNetMessageSaveError(rerr);
    virMutexUnlock(&priv->lock);
3351
    return rv;
3352 3353
}

C
Chris Lalancette 已提交
3354
static int
3355 3356 3357 3358 3359 3360
qemuDispatchDomainMonitorCommand(virNetServerPtr server ATTRIBUTE_UNUSED,
                                 virNetServerClientPtr client ATTRIBUTE_UNUSED,
                                 virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                 virNetMessageErrorPtr rerr,
                                 qemu_domain_monitor_command_args *args,
                                 qemu_domain_monitor_command_ret *ret)
C
Chris Lalancette 已提交
3361
{
3362
    virDomainPtr dom = NULL;
3363
    int rv = -1;
3364 3365
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
C
Chris Lalancette 已提交
3366

3367
    if (!priv->conn) {
3368
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
3369
        goto cleanup;
3370 3371
    }

3372
    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
3373
        goto cleanup;
C
Chris Lalancette 已提交
3374

3375
    if (virDomainQemuMonitorCommand(dom, args->cmd, &ret->result,
3376
                                    args->flags) < 0)
3377
        goto cleanup;
C
Chris Lalancette 已提交
3378

3379
    rv = 0;
C
Chris Lalancette 已提交
3380

3381 3382
cleanup:
    if (rv < 0)
3383
        virNetMessageSaveError(rerr);
3384 3385
    if (dom)
        virDomainFree(dom);
3386
    return rv;
C
Chris Lalancette 已提交
3387 3388
}

3389

3390
static int
3391 3392
remoteDispatchDomainMigrateBegin3(virNetServerPtr server ATTRIBUTE_UNUSED,
                                  virNetServerClientPtr client ATTRIBUTE_UNUSED,
3393
                                  virNetMessagePtr msg ATTRIBUTE_UNUSED,
3394
                                  virNetMessageErrorPtr rerr,
3395 3396 3397 3398 3399 3400
                                  remote_domain_migrate_begin3_args *args,
                                  remote_domain_migrate_begin3_ret *ret)
{
    char *xml = NULL;
    virDomainPtr dom = NULL;
    char *dname;
3401
    char *xmlin;
3402 3403 3404
    char *cookieout = NULL;
    int cookieoutlen = 0;
    int rv = -1;
3405 3406
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
3407

3408
    if (!priv->conn) {
3409
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
3410 3411 3412
        goto cleanup;
    }

3413
    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
3414 3415
        goto cleanup;

3416
    xmlin = args->xmlin == NULL ? NULL : *args->xmlin;
3417 3418
    dname = args->dname == NULL ? NULL : *args->dname;

3419
    if (!(xml = virDomainMigrateBegin3(dom, xmlin,
3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434
                                       &cookieout, &cookieoutlen,
                                       args->flags, dname, args->resource)))
        goto cleanup;

    /* remoteDispatchClientRequest will free cookie and
     * the xml string if there is one.
     */
    ret->cookie_out.cookie_out_len = cookieoutlen;
    ret->cookie_out.cookie_out_val = cookieout;
    ret->xml = xml;

    rv = 0;

cleanup:
    if (rv < 0)
3435
        virNetMessageSaveError(rerr);
3436 3437 3438 3439 3440 3441 3442
    if (dom)
        virDomainFree(dom);
    return rv;
}


static int
3443 3444
remoteDispatchDomainMigratePrepare3(virNetServerPtr server ATTRIBUTE_UNUSED,
                                    virNetServerClientPtr client ATTRIBUTE_UNUSED,
3445
                                    virNetMessagePtr msg ATTRIBUTE_UNUSED,
3446
                                    virNetMessageErrorPtr rerr,
3447 3448 3449 3450 3451 3452 3453 3454 3455
                                    remote_domain_migrate_prepare3_args *args,
                                    remote_domain_migrate_prepare3_ret *ret)
{
    char *cookieout = NULL;
    int cookieoutlen = 0;
    char *uri_in;
    char **uri_out;
    char *dname;
    int rv = -1;
3456 3457
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
3458

3459
    if (!priv->conn) {
3460
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
3461 3462 3463 3464 3465 3466 3467
        goto cleanup;
    }

    uri_in = args->uri_in == NULL ? NULL : *args->uri_in;
    dname = args->dname == NULL ? NULL : *args->dname;

    /* Wacky world of XDR ... */
3468
    if (VIR_ALLOC(uri_out) < 0)
3469 3470
        goto cleanup;

3471
    if (virDomainMigratePrepare3(priv->conn,
3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490
                                 args->cookie_in.cookie_in_val,
                                 args->cookie_in.cookie_in_len,
                                 &cookieout, &cookieoutlen,
                                 uri_in, uri_out,
                                 args->flags, dname, args->resource,
                                 args->dom_xml) < 0)
        goto cleanup;

    /* remoteDispatchClientRequest will free cookie, uri_out and
     * the string if there is one.
     */
    ret->cookie_out.cookie_out_len = cookieoutlen;
    ret->cookie_out.cookie_out_val = cookieout;
    ret->uri_out = *uri_out == NULL ? NULL : uri_out;

    rv = 0;

cleanup:
    if (rv < 0) {
3491
        virNetMessageSaveError(rerr);
3492 3493 3494 3495 3496
        VIR_FREE(uri_out);
    }
    return rv;
}

3497

3498
static int
3499 3500
remoteDispatchDomainMigratePerform3(virNetServerPtr server ATTRIBUTE_UNUSED,
                                    virNetServerClientPtr client ATTRIBUTE_UNUSED,
3501
                                    virNetMessagePtr msg ATTRIBUTE_UNUSED,
3502
                                    virNetMessageErrorPtr rerr,
3503 3504 3505 3506
                                    remote_domain_migrate_perform3_args *args,
                                    remote_domain_migrate_perform3_ret *ret)
{
    virDomainPtr dom = NULL;
3507
    char *xmlin;
3508
    char *dname;
3509 3510
    char *uri;
    char *dconnuri;
3511 3512 3513
    char *cookieout = NULL;
    int cookieoutlen = 0;
    int rv = -1;
3514 3515
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
3516

3517
    if (!priv->conn) {
3518
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
3519 3520 3521
        goto cleanup;
    }

3522
    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
3523 3524
        goto cleanup;

3525
    xmlin = args->xmlin == NULL ? NULL : *args->xmlin;
3526
    dname = args->dname == NULL ? NULL : *args->dname;
3527 3528
    uri = args->uri == NULL ? NULL : *args->uri;
    dconnuri = args->dconnuri == NULL ? NULL : *args->dconnuri;
3529

3530
    if (virDomainMigratePerform3(dom, xmlin,
3531 3532 3533
                                 args->cookie_in.cookie_in_val,
                                 args->cookie_in.cookie_in_len,
                                 &cookieout, &cookieoutlen,
3534
                                 dconnuri, uri,
3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546
                                 args->flags, dname, args->resource) < 0)
        goto cleanup;

    /* remoteDispatchClientRequest will free cookie
     */
    ret->cookie_out.cookie_out_len = cookieoutlen;
    ret->cookie_out.cookie_out_val = cookieout;

    rv = 0;

cleanup:
    if (rv < 0)
3547
        virNetMessageSaveError(rerr);
3548 3549 3550 3551 3552 3553 3554
    if (dom)
        virDomainFree(dom);
    return rv;
}


static int
3555 3556
remoteDispatchDomainMigrateFinish3(virNetServerPtr server ATTRIBUTE_UNUSED,
                                   virNetServerClientPtr client ATTRIBUTE_UNUSED,
3557
                                   virNetMessagePtr msg ATTRIBUTE_UNUSED,
3558
                                   virNetMessageErrorPtr rerr,
3559 3560 3561 3562 3563 3564
                                   remote_domain_migrate_finish3_args *args,
                                   remote_domain_migrate_finish3_ret *ret)
{
    virDomainPtr dom = NULL;
    char *cookieout = NULL;
    int cookieoutlen = 0;
3565 3566
    char *uri;
    char *dconnuri;
3567
    int rv = -1;
3568 3569
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
3570

3571
    if (!priv->conn) {
3572
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
3573 3574 3575
        goto cleanup;
    }

3576 3577 3578
    uri = args->uri == NULL ? NULL : *args->uri;
    dconnuri = args->dconnuri == NULL ? NULL : *args->dconnuri;

3579
    if (!(dom = virDomainMigrateFinish3(priv->conn, args->dname,
3580 3581 3582 3583 3584 3585
                                        args->cookie_in.cookie_in_val,
                                        args->cookie_in.cookie_in_len,
                                        &cookieout, &cookieoutlen,
                                        dconnuri, uri,
                                        args->flags,
                                        args->cancelled)))
3586 3587
        goto cleanup;

3588
    make_nonnull_domain(&ret->dom, dom);
3589 3590 3591 3592 3593 3594 3595 3596 3597 3598

    /* remoteDispatchClientRequest will free cookie
     */
    ret->cookie_out.cookie_out_len = cookieoutlen;
    ret->cookie_out.cookie_out_val = cookieout;

    rv = 0;

cleanup:
    if (rv < 0) {
3599
        virNetMessageSaveError(rerr);
3600 3601 3602 3603 3604 3605 3606 3607 3608
        VIR_FREE(cookieout);
    }
    if (dom)
        virDomainFree(dom);
    return rv;
}


static int
3609 3610
remoteDispatchDomainMigrateConfirm3(virNetServerPtr server ATTRIBUTE_UNUSED,
                                    virNetServerClientPtr client ATTRIBUTE_UNUSED,
3611
                                    virNetMessagePtr msg ATTRIBUTE_UNUSED,
3612 3613
                                    virNetMessageErrorPtr rerr,
                                    remote_domain_migrate_confirm3_args *args)
3614 3615 3616
{
    virDomainPtr dom = NULL;
    int rv = -1;
3617 3618
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
3619

3620
    if (!priv->conn) {
3621
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
3622 3623 3624
        goto cleanup;
    }

3625
    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637
        goto cleanup;

    if (virDomainMigrateConfirm3(dom,
                                 args->cookie_in.cookie_in_val,
                                 args->cookie_in.cookie_in_len,
                                 args->flags, args->cancelled) < 0)
        goto cleanup;

    rv = 0;

cleanup:
    if (rv < 0)
3638
        virNetMessageSaveError(rerr);
3639 3640 3641 3642 3643 3644
    if (dom)
        virDomainFree(dom);
    return rv;
}


3645 3646 3647 3648 3649 3650
static int remoteDispatchConnectSupportsFeature(virNetServerPtr server ATTRIBUTE_UNUSED,
                                                virNetServerClientPtr client,
                                                virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                                virNetMessageErrorPtr rerr,
                                                remote_connect_supports_feature_args *args,
                                                remote_connect_supports_feature_ret *ret)
3651 3652 3653 3654 3655 3656
{
    int rv = -1;
    int supported;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);

3657 3658 3659 3660 3661 3662 3663 3664 3665 3666
    /* This feature is checked before opening the connection, thus we must
     * check it first.
     */
    if (args->feature == VIR_DRV_FEATURE_PROGRAM_KEEPALIVE) {
        if (virNetServerClientStartKeepAlive(client) < 0)
            goto cleanup;
        supported = 1;
        goto done;
    }

3667
    if (!priv->conn) {
3668
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
3669 3670 3671 3672 3673 3674 3675 3676 3677
        goto cleanup;
    }

    switch (args->feature) {
    case VIR_DRV_FEATURE_FD_PASSING:
        supported = 1;
        break;

    default:
3678
        if ((supported = virConnectSupportsFeature(priv->conn, args->feature)) < 0)
3679 3680 3681 3682
            goto cleanup;
        break;
    }

3683
done:
3684 3685 3686 3687 3688 3689 3690 3691 3692 3693
    ret->supported = supported;
    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
    return rv;
}


3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707
static int
remoteDispatchDomainOpenGraphics(virNetServerPtr server ATTRIBUTE_UNUSED,
                                 virNetServerClientPtr client ATTRIBUTE_UNUSED,
                                 virNetMessagePtr msg,
                                 virNetMessageErrorPtr rerr,
                                 remote_domain_open_graphics_args *args)
{
    virDomainPtr dom = NULL;
    int rv = -1;
    int fd = -1;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
3708
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734
        goto cleanup;
    }

    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
        goto cleanup;

    if ((fd = virNetMessageDupFD(msg, 0)) < 0)
        goto cleanup;

    if (virDomainOpenGraphics(dom,
                              args->idx,
                              fd,
                              args->flags) < 0)
        goto cleanup;

    rv = 0;

cleanup:
    VIR_FORCE_CLOSE(fd);
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (dom)
        virDomainFree(dom);
    return rv;
}

3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745
static int
remoteDispatchDomainGetInterfaceParameters(virNetServerPtr server ATTRIBUTE_UNUSED,
                                           virNetServerClientPtr client ATTRIBUTE_UNUSED,
                                           virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                           virNetMessageErrorPtr rerr,
                                           remote_domain_get_interface_parameters_args *args,
                                           remote_domain_get_interface_parameters_ret *ret)
{
    virDomainPtr dom = NULL;
    virTypedParameterPtr params = NULL;
    const char *device = args->device;
3746
    int nparams = 0;
3747 3748 3749 3750 3751 3752
    unsigned int flags;
    int rv = -1;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
3753
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
3754 3755 3756 3757 3758
        goto cleanup;
    }

    flags = args->flags;

3759
    if (args->nparams > REMOTE_DOMAIN_INTERFACE_PARAMETERS_MAX) {
3760
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("nparams too large"));
3761 3762
        goto cleanup;
    }
3763
    if (args->nparams && VIR_ALLOC_N(params, args->nparams) < 0)
3764
        goto cleanup;
3765
    nparams = args->nparams;
3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792

    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
        goto cleanup;

    if (virDomainGetInterfaceParameters(dom, device, params, &nparams, flags) < 0)
        goto cleanup;

    /* In this case, we need to send back the number of parameters
     * supported
     */
    if (args->nparams == 0) {
        ret->nparams = nparams;
        goto success;
    }

    if (remoteSerializeTypedParameters(params, nparams,
                                       &ret->params.params_val,
                                       &ret->params.params_len,
                                       flags) < 0)
        goto cleanup;

success:
    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
3793
    virTypedParamsFree(params, nparams);
3794 3795 3796 3797
    if (dom)
        virDomainFree(dom);
    return rv;
}
3798

3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814
static int
remoteDispatchDomainGetCPUStats(virNetServerPtr server ATTRIBUTE_UNUSED,
                                virNetServerClientPtr client ATTRIBUTE_UNUSED,
                                virNetMessagePtr hdr ATTRIBUTE_UNUSED,
                                virNetMessageErrorPtr rerr,
                                remote_domain_get_cpu_stats_args *args,
                                remote_domain_get_cpu_stats_ret *ret)
{
    virDomainPtr dom = NULL;
    struct daemonClientPrivate *priv;
    virTypedParameterPtr params = NULL;
    int rv = -1;
    int percpu_len = 0;

    priv = virNetServerClientGetPrivateData(client);
    if (!priv->conn) {
3815
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
3816 3817 3818 3819
        goto cleanup;
    }

    if (args->nparams > REMOTE_NODE_CPU_STATS_MAX) {
3820
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("nparams too large"));
3821 3822 3823
        goto cleanup;
    }
    if (args->ncpus > REMOTE_DOMAIN_GET_CPU_STATS_NCPUS_MAX) {
3824
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("ncpus too large"));
3825 3826 3827 3828
        goto cleanup;
    }

    if (args->nparams > 0 &&
3829
        VIR_ALLOC_N(params, args->ncpus * args->nparams) < 0)
3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852
        goto cleanup;

    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
        goto cleanup;

    percpu_len = virDomainGetCPUStats(dom, params, args->nparams,
                                      args->start_cpu, args->ncpus,
                                      args->flags);
    if (percpu_len < 0)
        goto cleanup;
    /* If nparams == 0, the function returns a single value */
    if (args->nparams == 0)
        goto success;

    if (remoteSerializeTypedParameters(params, args->nparams * args->ncpus,
                                       &ret->params.params_val,
                                       &ret->params.params_len,
                                       args->flags) < 0)
        goto cleanup;

success:
    rv = 0;
    ret->nparams = percpu_len;
3853
    if (args->nparams && !(args->flags & VIR_TYPED_PARAM_STRING_OKAY)) {
3854
        size_t i;
3855 3856 3857 3858 3859 3860

        for (i = 0; i < percpu_len; i++) {
            if (params[i].type == VIR_TYPED_PARAM_STRING)
                ret->nparams--;
        }
    }
3861 3862 3863 3864

cleanup:
    if (rv < 0)
         virNetMessageSaveError(rerr);
3865
    virTypedParamsFree(params, args->ncpus * args->nparams);
3866 3867 3868 3869 3870
    if (dom)
        virDomainFree(dom);
    return rv;
}

3871 3872 3873 3874 3875 3876 3877
static int
remoteDispatchDomainGetDiskErrors(virNetServerPtr server ATTRIBUTE_UNUSED,
                                  virNetServerClientPtr client,
                                  virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                  virNetMessageErrorPtr rerr,
                                  remote_domain_get_disk_errors_args *args,
                                  remote_domain_get_disk_errors_ret *ret)
3878 3879 3880 3881
{
    int rv = -1;
    virDomainPtr dom = NULL;
    virDomainDiskErrorPtr errors = NULL;
3882
    int len = 0;
3883 3884 3885 3886
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
3887
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
3888 3889 3890 3891 3892 3893 3894
        goto cleanup;
    }

    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
        goto cleanup;

    if (args->maxerrors > REMOTE_DOMAIN_DISK_ERRORS_MAX) {
3895 3896
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("maxerrors too large"));
3897 3898 3899 3900
        goto cleanup;
    }

    if (args->maxerrors &&
3901
        VIR_ALLOC_N(errors, args->maxerrors) < 0)
3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923
        goto cleanup;

    if ((len = virDomainGetDiskErrors(dom, errors,
                                      args->maxerrors,
                                      args->flags)) < 0)
        goto cleanup;

    ret->nerrors = len;
    if (errors &&
        remoteSerializeDomainDiskErrors(errors, len,
                                        &ret->errors.errors_val,
                                        &ret->errors.errors_len) < 0)
        goto cleanup;

    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (dom)
        virDomainFree(dom);
    if (errors) {
3924
        size_t i;
3925 3926 3927 3928 3929 3930 3931
        for (i = 0; i < len; i++)
            VIR_FREE(errors[i].disk);
    }
    VIR_FREE(errors);
    return rv;
}

3932 3933 3934 3935 3936 3937 3938 3939 3940 3941
static int
remoteDispatchDomainListAllSnapshots(virNetServerPtr server ATTRIBUTE_UNUSED,
                                     virNetServerClientPtr client,
                                     virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                     virNetMessageErrorPtr rerr,
                                     remote_domain_list_all_snapshots_args *args,
                                     remote_domain_list_all_snapshots_ret *ret)
{
    virDomainSnapshotPtr *snaps = NULL;
    int nsnaps = 0;
3942
    size_t i;
3943 3944 3945 3946 3947
    int rv = -1;
    struct daemonClientPrivate *priv = virNetServerClientGetPrivateData(client);
    virDomainPtr dom = NULL;

    if (!priv->conn) {
3948
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959
        goto cleanup;
    }

    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
        goto cleanup;

    if ((nsnaps = virDomainListAllSnapshots(dom,
                                            args->need_results ? &snaps : NULL,
                                            args->flags)) < 0)
        goto cleanup;

3960 3961 3962 3963 3964 3965 3966
    if (nsnaps > REMOTE_DOMAIN_SNAPSHOT_LIST_MAX) {
        virReportError(VIR_ERR_RPC,
                       _("Too many domain snapshots '%d' for limit '%d'"),
                       nsnaps, REMOTE_DOMAIN_SNAPSHOT_LIST_MAX);
        goto cleanup;
    }

3967
    if (snaps && nsnaps) {
3968
        if (VIR_ALLOC_N(ret->snapshots.snapshots_val, nsnaps) < 0)
3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006
            goto cleanup;

        ret->snapshots.snapshots_len = nsnaps;

        for (i = 0; i < nsnaps; i++)
            make_nonnull_domain_snapshot(ret->snapshots.snapshots_val + i,
                                         snaps[i]);
    } else {
        ret->snapshots.snapshots_len = 0;
        ret->snapshots.snapshots_val = NULL;
    }

    ret->ret = nsnaps;
    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (dom)
        virDomainFree(dom);
    if (snaps) {
        for (i = 0; i < nsnaps; i++)
            virDomainSnapshotFree(snaps[i]);
        VIR_FREE(snaps);
    }
    return rv;
}

static int
remoteDispatchDomainSnapshotListAllChildren(virNetServerPtr server ATTRIBUTE_UNUSED,
                                            virNetServerClientPtr client,
                                            virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                            virNetMessageErrorPtr rerr,
                                            remote_domain_snapshot_list_all_children_args *args,
                                            remote_domain_snapshot_list_all_children_ret *ret)
{
    virDomainSnapshotPtr *snaps = NULL;
    int nsnaps = 0;
4007
    size_t i;
4008 4009 4010 4011 4012 4013
    int rv = -1;
    struct daemonClientPrivate *priv = virNetServerClientGetPrivateData(client);
    virDomainPtr dom = NULL;
    virDomainSnapshotPtr snapshot = NULL;

    if (!priv->conn) {
4014
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028
        goto cleanup;
    }

    if (!(dom = get_nonnull_domain(priv->conn, args->snapshot.dom)))
        goto cleanup;

    if (!(snapshot = get_nonnull_domain_snapshot(dom, args->snapshot)))
        goto cleanup;

    if ((nsnaps = virDomainSnapshotListAllChildren(snapshot,
                                                   args->need_results ? &snaps : NULL,
                                                   args->flags)) < 0)
        goto cleanup;

4029 4030 4031 4032 4033 4034 4035
    if (nsnaps > REMOTE_DOMAIN_SNAPSHOT_LIST_MAX) {
        virReportError(VIR_ERR_RPC,
                       _("Too many domain snapshots '%d' for limit '%d'"),
                       nsnaps, REMOTE_DOMAIN_SNAPSHOT_LIST_MAX);
        goto cleanup;
    }

4036
    if (snaps && nsnaps) {
4037
        if (VIR_ALLOC_N(ret->snapshots.snapshots_val, nsnaps) < 0)
4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067
            goto cleanup;

        ret->snapshots.snapshots_len = nsnaps;

        for (i = 0; i < nsnaps; i++)
            make_nonnull_domain_snapshot(ret->snapshots.snapshots_val + i,
                                         snaps[i]);
    } else {
        ret->snapshots.snapshots_len = 0;
        ret->snapshots.snapshots_val = NULL;
    }

    ret->ret = nsnaps;
    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (snapshot)
        virDomainSnapshotFree(snapshot);
    if (dom)
        virDomainFree(dom);
    if (snaps) {
        for (i = 0; i < nsnaps; i++)
            virDomainSnapshotFree(snaps[i]);
        VIR_FREE(snaps);
    }
    return rv;
}

4068 4069 4070 4071 4072 4073 4074 4075 4076 4077
static int
remoteDispatchConnectListAllStoragePools(virNetServerPtr server ATTRIBUTE_UNUSED,
                                         virNetServerClientPtr client,
                                         virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                         virNetMessageErrorPtr rerr,
                                         remote_connect_list_all_storage_pools_args *args,
                                         remote_connect_list_all_storage_pools_ret *ret)
{
    virStoragePoolPtr *pools = NULL;
    int npools = 0;
4078
    size_t i;
4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091
    int rv = -1;
    struct daemonClientPrivate *priv = virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

    if ((npools = virConnectListAllStoragePools(priv->conn,
                                                args->need_results ? &pools : NULL,
                                                args->flags)) < 0)
        goto cleanup;

4092 4093 4094 4095 4096 4097 4098
    if (npools > REMOTE_STORAGE_POOL_LIST_MAX) {
        virReportError(VIR_ERR_RPC,
                       _("Too many storage pools '%d' for limit '%d'"),
                       npools, REMOTE_STORAGE_POOL_LIST_MAX);
        goto cleanup;
    }

4099
    if (pools && npools) {
4100
        if (VIR_ALLOC_N(ret->pools.pools_val, npools) < 0)
4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126
            goto cleanup;

        ret->pools.pools_len = npools;

        for (i = 0; i < npools; i++)
            make_nonnull_storage_pool(ret->pools.pools_val + i, pools[i]);
    } else {
        ret->pools.pools_len = 0;
        ret->pools.pools_val = NULL;
    }

    ret->ret = npools;

    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (pools) {
        for (i = 0; i < npools; i++)
            virStoragePoolFree(pools[i]);
        VIR_FREE(pools);
    }
    return rv;
}

4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137
static int
remoteDispatchStoragePoolListAllVolumes(virNetServerPtr server ATTRIBUTE_UNUSED,
                                        virNetServerClientPtr client,
                                        virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                        virNetMessageErrorPtr rerr,
                                        remote_storage_pool_list_all_volumes_args *args,
                                        remote_storage_pool_list_all_volumes_ret *ret)
{
    virStorageVolPtr *vols = NULL;
    virStoragePoolPtr pool = NULL;
    int nvols = 0;
4138
    size_t i;
4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154
    int rv = -1;
    struct daemonClientPrivate *priv = virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

    if (!(pool = get_nonnull_storage_pool(priv->conn, args->pool)))
        goto cleanup;

    if ((nvols = virStoragePoolListAllVolumes(pool,
                                              args->need_results ? &vols : NULL,
                                              args->flags)) < 0)
        goto cleanup;

4155 4156 4157 4158 4159 4160 4161
    if (nvols > REMOTE_STORAGE_VOL_LIST_MAX) {
        virReportError(VIR_ERR_RPC,
                       _("Too many storage volumes '%d' for limit '%d'"),
                       nvols, REMOTE_STORAGE_VOL_LIST_MAX);
        goto cleanup;
    }

4162
    if (vols && nvols) {
4163
        if (VIR_ALLOC_N(ret->vols.vols_val, nvols) < 0)
4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186
            goto cleanup;

        ret->vols.vols_len = nvols;

        for (i = 0; i < nvols; i++)
            make_nonnull_storage_vol(ret->vols.vols_val + i, vols[i]);
    } else {
        ret->vols.vols_len = 0;
        ret->vols.vols_val = NULL;
    }

    ret->ret = nvols;

    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (vols) {
        for (i = 0; i < nvols; i++)
            virStorageVolFree(vols[i]);
        VIR_FREE(vols);
    }
4187 4188
    if (pool)
        virStoragePoolFree(pool);
4189 4190 4191
    return rv;
}

4192 4193 4194 4195 4196 4197 4198 4199 4200 4201
static int
remoteDispatchConnectListAllNetworks(virNetServerPtr server ATTRIBUTE_UNUSED,
                                     virNetServerClientPtr client,
                                     virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                     virNetMessageErrorPtr rerr,
                                     remote_connect_list_all_networks_args *args,
                                     remote_connect_list_all_networks_ret *ret)
{
    virNetworkPtr *nets = NULL;
    int nnets = 0;
4202
    size_t i;
4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215
    int rv = -1;
    struct daemonClientPrivate *priv = virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

    if ((nnets = virConnectListAllNetworks(priv->conn,
                                           args->need_results ? &nets : NULL,
                                           args->flags)) < 0)
        goto cleanup;

4216 4217 4218 4219 4220 4221 4222
    if (nnets > REMOTE_NETWORK_LIST_MAX) {
        virReportError(VIR_ERR_RPC,
                       _("Too many networks '%d' for limit '%d'"),
                       nnets, REMOTE_NETWORK_LIST_MAX);
        goto cleanup;
    }

4223
    if (nets && nnets) {
4224
        if (VIR_ALLOC_N(ret->nets.nets_val, nnets) < 0)
4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250
            goto cleanup;

        ret->nets.nets_len = nnets;

        for (i = 0; i < nnets; i++)
            make_nonnull_network(ret->nets.nets_val + i, nets[i]);
    } else {
        ret->nets.nets_len = 0;
        ret->nets.nets_val = NULL;
    }

    ret->ret = nnets;

    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (nets) {
        for (i = 0; i < nnets; i++)
            virNetworkFree(nets[i]);
        VIR_FREE(nets);
    }
    return rv;
}

4251 4252 4253 4254 4255 4256 4257 4258 4259 4260
static int
remoteDispatchConnectListAllInterfaces(virNetServerPtr server ATTRIBUTE_UNUSED,
                                       virNetServerClientPtr client,
                                       virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                       virNetMessageErrorPtr rerr,
                                       remote_connect_list_all_interfaces_args *args,
                                       remote_connect_list_all_interfaces_ret *ret)
{
    virInterfacePtr *ifaces = NULL;
    int nifaces = 0;
4261
    size_t i;
4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274
    int rv = -1;
    struct daemonClientPrivate *priv = virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

    if ((nifaces = virConnectListAllInterfaces(priv->conn,
                                               args->need_results ? &ifaces : NULL,
                                               args->flags)) < 0)
        goto cleanup;

4275 4276 4277 4278 4279 4280 4281
    if (nifaces > REMOTE_INTERFACE_LIST_MAX) {
        virReportError(VIR_ERR_RPC,
                       _("Too many interfaces '%d' for limit '%d'"),
                       nifaces, REMOTE_INTERFACE_LIST_MAX);
        goto cleanup;
    }

4282
    if (ifaces && nifaces) {
4283
        if (VIR_ALLOC_N(ret->ifaces.ifaces_val, nifaces) < 0)
4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309
            goto cleanup;

        ret->ifaces.ifaces_len = nifaces;

        for (i = 0; i < nifaces; i++)
            make_nonnull_interface(ret->ifaces.ifaces_val + i, ifaces[i]);
    } else {
        ret->ifaces.ifaces_len = 0;
        ret->ifaces.ifaces_val = NULL;
    }

    ret->ret = nifaces;

    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (ifaces) {
        for (i = 0; i < nifaces; i++)
            virInterfaceFree(ifaces[i]);
        VIR_FREE(ifaces);
    }
    return rv;
}

4310 4311 4312 4313 4314 4315 4316 4317 4318 4319
static int
remoteDispatchConnectListAllNodeDevices(virNetServerPtr server ATTRIBUTE_UNUSED,
                                        virNetServerClientPtr client,
                                        virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                        virNetMessageErrorPtr rerr,
                                        remote_connect_list_all_node_devices_args *args,
                                        remote_connect_list_all_node_devices_ret *ret)
{
    virNodeDevicePtr *devices = NULL;
    int ndevices = 0;
4320
    size_t i;
4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333
    int rv = -1;
    struct daemonClientPrivate *priv = virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

    if ((ndevices = virConnectListAllNodeDevices(priv->conn,
                                                 args->need_results ? &devices : NULL,
                                                 args->flags)) < 0)
        goto cleanup;

4334 4335 4336 4337 4338 4339 4340
    if (ndevices > REMOTE_NODE_DEVICE_LIST_MAX) {
        virReportError(VIR_ERR_RPC,
                       _("Too many node devices '%d' for limit '%d'"),
                       ndevices, REMOTE_NODE_DEVICE_LIST_MAX);
        goto cleanup;
    }

4341
    if (devices && ndevices) {
4342
        if (VIR_ALLOC_N(ret->devices.devices_val, ndevices) < 0)
4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367
            goto cleanup;

        ret->devices.devices_len = ndevices;

        for (i = 0; i < ndevices; i++)
            make_nonnull_node_device(ret->devices.devices_val + i, devices[i]);
    } else {
        ret->devices.devices_len = 0;
        ret->devices.devices_val = NULL;
    }

    ret->ret = ndevices;

    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (devices) {
        for (i = 0; i < ndevices; i++)
            virNodeDeviceFree(devices[i]);
        VIR_FREE(devices);
    }
    return rv;
}
4368

4369 4370 4371 4372 4373 4374 4375 4376 4377 4378
static int
remoteDispatchConnectListAllNWFilters(virNetServerPtr server ATTRIBUTE_UNUSED,
                                      virNetServerClientPtr client,
                                      virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                      virNetMessageErrorPtr rerr,
                                      remote_connect_list_all_nwfilters_args *args,
                                      remote_connect_list_all_nwfilters_ret *ret)
{
    virNWFilterPtr *filters = NULL;
    int nfilters = 0;
4379
    size_t i;
4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392
    int rv = -1;
    struct daemonClientPrivate *priv = virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

    if ((nfilters = virConnectListAllNWFilters(priv->conn,
                                               args->need_results ? &filters : NULL,
                                               args->flags)) < 0)
        goto cleanup;

4393 4394 4395 4396 4397 4398 4399
    if (nfilters > REMOTE_NWFILTER_LIST_MAX) {
        virReportError(VIR_ERR_RPC,
                       _("Too many network filters '%d' for limit '%d'"),
                       nfilters, REMOTE_NWFILTER_LIST_MAX);
        goto cleanup;
    }

4400
    if (filters && nfilters) {
4401
        if (VIR_ALLOC_N(ret->filters.filters_val, nfilters) < 0)
4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427
            goto cleanup;

        ret->filters.filters_len = nfilters;

        for (i = 0; i < nfilters; i++)
            make_nonnull_nwfilter(ret->filters.filters_val + i, filters[i]);
    } else {
        ret->filters.filters_len = 0;
        ret->filters.filters_val = NULL;
    }

    ret->ret = nfilters;

    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (filters) {
        for (i = 0; i < nfilters; i++)
            virNWFilterFree(filters[i]);
        VIR_FREE(filters);
    }
    return rv;
}

4428 4429 4430 4431 4432 4433 4434 4435 4436 4437
static int
remoteDispatchConnectListAllSecrets(virNetServerPtr server ATTRIBUTE_UNUSED,
                                    virNetServerClientPtr client,
                                    virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                    virNetMessageErrorPtr rerr,
                                    remote_connect_list_all_secrets_args *args,
                                    remote_connect_list_all_secrets_ret *ret)
{
    virSecretPtr *secrets = NULL;
    int nsecrets = 0;
4438
    size_t i;
4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451
    int rv = -1;
    struct daemonClientPrivate *priv = virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

    if ((nsecrets = virConnectListAllSecrets(priv->conn,
                                             args->need_results ? &secrets : NULL,
                                             args->flags)) < 0)
        goto cleanup;

4452 4453 4454 4455 4456 4457 4458
    if (nsecrets > REMOTE_SECRET_LIST_MAX) {
        virReportError(VIR_ERR_RPC,
                       _("Too many secrets '%d' for limit '%d'"),
                       nsecrets, REMOTE_SECRET_LIST_MAX);
        goto cleanup;
    }

4459
    if (secrets && nsecrets) {
4460
        if (VIR_ALLOC_N(ret->secrets.secrets_val, nsecrets) < 0)
4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486
            goto cleanup;

        ret->secrets.secrets_len = nsecrets;

        for (i = 0; i < nsecrets; i++)
            make_nonnull_secret(ret->secrets.secrets_val + i, secrets[i]);
    } else {
        ret->secrets.secrets_len = 0;
        ret->secrets.secrets_val = NULL;
    }

    ret->ret = nsecrets;

    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (secrets) {
        for (i = 0; i < nsecrets; i++)
            virSecretFree(secrets[i]);
        VIR_FREE(secrets);
    }
    return rv;
}

4487 4488 4489 4490 4491 4492 4493 4494 4495
static int
remoteDispatchNodeGetMemoryParameters(virNetServerPtr server ATTRIBUTE_UNUSED,
                                      virNetServerClientPtr client ATTRIBUTE_UNUSED,
                                      virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                      virNetMessageErrorPtr rerr,
                                      remote_node_get_memory_parameters_args *args,
                                      remote_node_get_memory_parameters_ret *ret)
{
    virTypedParameterPtr params = NULL;
4496
    int nparams = 0;
4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508
    unsigned int flags;
    int rv = -1;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

    flags = args->flags;

4509
    if (args->nparams > REMOTE_NODE_MEMORY_PARAMETERS_MAX) {
4510 4511 4512
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("nparams too large"));
        goto cleanup;
    }
4513
    if (args->nparams && VIR_ALLOC_N(params, args->nparams) < 0)
4514
        goto cleanup;
4515
    nparams = args->nparams;
4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539

    if (virNodeGetMemoryParameters(priv->conn, params, &nparams, flags) < 0)
        goto cleanup;

    /* In this case, we need to send back the number of parameters
     * supported
     */
    if (args->nparams == 0) {
        ret->nparams = nparams;
        goto success;
    }

    if (remoteSerializeTypedParameters(params, nparams,
                                       &ret->params.params_val,
                                       &ret->params.params_len,
                                       args->flags) < 0)
        goto cleanup;

success:
    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
4540
    virTypedParamsFree(params, nparams);
4541 4542 4543
    return rv;
}

4544 4545 4546 4547 4548 4549 4550 4551 4552
static int
remoteDispatchNodeGetCPUMap(virNetServerPtr server ATTRIBUTE_UNUSED,
                            virNetServerClientPtr client ATTRIBUTE_UNUSED,
                            virNetMessagePtr msg ATTRIBUTE_UNUSED,
                            virNetMessageErrorPtr rerr,
                            remote_node_get_cpu_map_args *args,
                            remote_node_get_cpu_map_ret *ret)
{
    unsigned char *cpumap = NULL;
4553
    unsigned int online = 0;
4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566
    unsigned int flags;
    int cpunum;
    int rv = -1;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

    flags = args->flags;

4567 4568
    cpunum = virNodeGetCPUMap(priv->conn, args->need_map ? &cpumap : NULL,
                              args->need_online ? &online : NULL, flags);
4569 4570 4571 4572
    if (cpunum < 0)
        goto cleanup;

    /* 'serialize' return cpumap */
4573
    if (args->need_map) {
4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590
        ret->cpumap.cpumap_len = VIR_CPU_MAPLEN(cpunum);
        ret->cpumap.cpumap_val = (char *) cpumap;
        cpumap = NULL;
    }

    ret->online = online;
    ret->ret = cpunum;

    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
    VIR_FREE(cpumap);
    return rv;
}

4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623
static int
lxcDispatchDomainOpenNamespace(virNetServerPtr server ATTRIBUTE_UNUSED,
                               virNetServerClientPtr client ATTRIBUTE_UNUSED,
                               virNetMessagePtr msg ATTRIBUTE_UNUSED,
                               virNetMessageErrorPtr rerr,
                               lxc_domain_open_namespace_args *args)
{
    int rv = -1;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
    int *fdlist = NULL;
    int ret;
    virDomainPtr dom = NULL;
    size_t i;

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
        goto cleanup;

    ret = virDomainLxcOpenNamespace(dom,
                                    &fdlist,
                                    args->flags);
    if (ret < 0)
        goto cleanup;

    /* We shouldn't have received any from the client,
     * but in case they're playing games with us, prevent
     * a resource leak
     */
4624
    for (i = 0; i < msg->nfds; i++)
4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640
        VIR_FORCE_CLOSE(msg->fds[i]);
    VIR_FREE(msg->fds);
    msg->nfds = 0;

    msg->fds = fdlist;
    msg->nfds = ret;

    rv = 1;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
    virDomainFree(dom);
    return rv;
}

4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667
static int
remoteDispatchDomainGetJobStats(virNetServerPtr server ATTRIBUTE_UNUSED,
                                virNetServerClientPtr client,
                                virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                virNetMessageErrorPtr rerr,
                                remote_domain_get_job_stats_args *args,
                                remote_domain_get_job_stats_ret *ret)
{
    virDomainPtr dom = NULL;
    virTypedParameterPtr params = NULL;
    int nparams = 0;
    int rv = -1;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
        goto cleanup;

    if (virDomainGetJobStats(dom, &ret->type, &params,
                             &nparams, args->flags) < 0)
        goto cleanup;

4668 4669 4670 4671 4672 4673 4674
    if (nparams > REMOTE_DOMAIN_JOB_STATS_MAX) {
        virReportError(VIR_ERR_RPC,
                       _("Too many job stats '%d' for limit '%d'"),
                       nparams, REMOTE_DOMAIN_JOB_STATS_MAX);
        goto cleanup;
    }

4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691
    if (remoteSerializeTypedParameters(params, nparams,
                                       &ret->params.params_val,
                                       &ret->params.params_len,
                                       0) < 0)
        goto cleanup;

    rv = 0;

cleanup:
    if (rv < 0)
        virNetMessageSaveError(rerr);
    virTypedParamsFree(params, nparams);
    if (dom)
        virDomainFree(dom);
    return rv;
}

4692
static int
4693 4694 4695 4696 4697 4698
remoteDispatchDomainMigrateBegin3Params(virNetServerPtr server ATTRIBUTE_UNUSED,
                                        virNetServerClientPtr client ATTRIBUTE_UNUSED,
                                        virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                        virNetMessageErrorPtr rerr,
                                        remote_domain_migrate_begin3_params_args *args,
                                        remote_domain_migrate_begin3_params_ret *ret)
4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714
{
    char *xml = NULL;
    virDomainPtr dom = NULL;
    virTypedParameterPtr params = NULL;
    int nparams = 0;
    char *cookieout = NULL;
    int cookieoutlen = 0;
    int rv = -1;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

4715 4716 4717 4718 4719 4720 4721
    if (args->params.params_len > REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX) {
        virReportError(VIR_ERR_RPC,
                       _("Too many migration parameters '%d' for limit '%d'"),
                       args->params.params_len, REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX);
        goto cleanup;
    }

4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750
    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
        goto cleanup;

    if (!(params = remoteDeserializeTypedParameters(args->params.params_val,
                                                    args->params.params_len,
                                                    0, &nparams)))
        goto cleanup;

    if (!(xml = virDomainMigrateBegin3Params(dom, params, nparams,
                                             &cookieout, &cookieoutlen,
                                             args->flags)))
        goto cleanup;

    ret->cookie_out.cookie_out_len = cookieoutlen;
    ret->cookie_out.cookie_out_val = cookieout;
    ret->xml = xml;

    rv = 0;

cleanup:
    virTypedParamsFree(params, nparams);
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (dom)
        virDomainFree(dom);
    return rv;
}

static int
4751 4752 4753 4754 4755 4756
remoteDispatchDomainMigratePrepare3Params(virNetServerPtr server ATTRIBUTE_UNUSED,
                                          virNetServerClientPtr client ATTRIBUTE_UNUSED,
                                          virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                          virNetMessageErrorPtr rerr,
                                          remote_domain_migrate_prepare3_params_args *args,
                                          remote_domain_migrate_prepare3_params_ret *ret)
4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771
{
    virTypedParameterPtr params = NULL;
    int nparams = 0;
    char *cookieout = NULL;
    int cookieoutlen = 0;
    char **uri_out;
    int rv = -1;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

4772 4773 4774 4775 4776 4777 4778
    if (args->params.params_len > REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX) {
        virReportError(VIR_ERR_RPC,
                       _("Too many migration parameters '%d' for limit '%d'"),
                       args->params.params_len, REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX);
        goto cleanup;
    }

4779 4780 4781 4782 4783 4784
    if (!(params = remoteDeserializeTypedParameters(args->params.params_val,
                                                    args->params.params_len,
                                                    0, &nparams)))
        goto cleanup;

    /* Wacky world of XDR ... */
4785
    if (VIR_ALLOC(uri_out) < 0)
4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810
        goto cleanup;

    if (virDomainMigratePrepare3Params(priv->conn, params, nparams,
                                       args->cookie_in.cookie_in_val,
                                       args->cookie_in.cookie_in_len,
                                       &cookieout, &cookieoutlen,
                                       uri_out, args->flags) < 0)
        goto cleanup;

    ret->cookie_out.cookie_out_len = cookieoutlen;
    ret->cookie_out.cookie_out_val = cookieout;
    ret->uri_out = !*uri_out ? NULL : uri_out;

    rv = 0;

cleanup:
    virTypedParamsFree(params, nparams);
    if (rv < 0) {
        virNetMessageSaveError(rerr);
        VIR_FREE(uri_out);
    }
    return rv;
}

static int
4811 4812 4813 4814 4815 4816
remoteDispatchDomainMigratePrepareTunnel3Params(virNetServerPtr server ATTRIBUTE_UNUSED,
                                                virNetServerClientPtr client,
                                                virNetMessagePtr msg,
                                                virNetMessageErrorPtr rerr,
                                                remote_domain_migrate_prepare_tunnel3_params_args *args,
                                                remote_domain_migrate_prepare_tunnel3_params_ret *ret)
4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832
{
    virTypedParameterPtr params = NULL;
    int nparams = 0;
    char *cookieout = NULL;
    int cookieoutlen = 0;
    int rv = -1;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
    virStreamPtr st = NULL;
    daemonClientStreamPtr stream = NULL;

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

4833 4834 4835 4836 4837 4838 4839
    if (args->params.params_len > REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX) {
        virReportError(VIR_ERR_RPC,
                       _("Too many migration parameters '%d' for limit '%d'"),
                       args->params.params_len, REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX);
        goto cleanup;
    }

4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880
    if (!(params = remoteDeserializeTypedParameters(args->params.params_val,
                                                    args->params.params_len,
                                                    0, &nparams)))
        goto cleanup;

    if (!(st = virStreamNew(priv->conn, VIR_STREAM_NONBLOCK)) ||
        !(stream = daemonCreateClientStream(client, st, remoteProgram,
                                            &msg->header)))
        goto cleanup;

    if (virDomainMigratePrepareTunnel3Params(priv->conn, st, params, nparams,
                                             args->cookie_in.cookie_in_val,
                                             args->cookie_in.cookie_in_len,
                                             &cookieout, &cookieoutlen,
                                             args->flags) < 0)
        goto cleanup;

    if (daemonAddClientStream(client, stream, false) < 0)
        goto cleanup;

    ret->cookie_out.cookie_out_val = cookieout;
    ret->cookie_out.cookie_out_len = cookieoutlen;
    rv = 0;

cleanup:
    virTypedParamsFree(params, nparams);
    if (rv < 0) {
        virNetMessageSaveError(rerr);
        VIR_FREE(cookieout);
        if (stream) {
            virStreamAbort(st);
            daemonFreeClientStream(client, stream);
        } else {
            virStreamFree(st);
        }
    }
    return rv;
}


static int
4881 4882 4883 4884 4885 4886
remoteDispatchDomainMigratePerform3Params(virNetServerPtr server ATTRIBUTE_UNUSED,
                                          virNetServerClientPtr client ATTRIBUTE_UNUSED,
                                          virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                          virNetMessageErrorPtr rerr,
                                          remote_domain_migrate_perform3_params_args *args,
                                          remote_domain_migrate_perform3_params_ret *ret)
4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902
{
    virTypedParameterPtr params = NULL;
    int nparams = 0;
    virDomainPtr dom = NULL;
    char *cookieout = NULL;
    int cookieoutlen = 0;
    char *dconnuri;
    int rv = -1;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

4903 4904 4905 4906 4907 4908 4909
    if (args->params.params_len > REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX) {
        virReportError(VIR_ERR_RPC,
                       _("Too many migration parameters '%d' for limit '%d'"),
                       args->params.params_len, REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX);
        goto cleanup;
    }

4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942
    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
        goto cleanup;

    if (!(params = remoteDeserializeTypedParameters(args->params.params_val,
                                                    args->params.params_len,
                                                    0, &nparams)))
        goto cleanup;

    dconnuri = args->dconnuri == NULL ? NULL : *args->dconnuri;

    if (virDomainMigratePerform3Params(dom, dconnuri, params, nparams,
                                       args->cookie_in.cookie_in_val,
                                       args->cookie_in.cookie_in_len,
                                       &cookieout, &cookieoutlen,
                                       args->flags) < 0)
        goto cleanup;

    ret->cookie_out.cookie_out_len = cookieoutlen;
    ret->cookie_out.cookie_out_val = cookieout;

    rv = 0;

cleanup:
    virTypedParamsFree(params, nparams);
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (dom)
        virDomainFree(dom);
    return rv;
}


static int
4943 4944 4945 4946 4947 4948
remoteDispatchDomainMigrateFinish3Params(virNetServerPtr server ATTRIBUTE_UNUSED,
                                         virNetServerClientPtr client ATTRIBUTE_UNUSED,
                                         virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                         virNetMessageErrorPtr rerr,
                                         remote_domain_migrate_finish3_params_args *args,
                                         remote_domain_migrate_finish3_params_ret *ret)
4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963
{
    virTypedParameterPtr params = NULL;
    int nparams = 0;
    virDomainPtr dom = NULL;
    char *cookieout = NULL;
    int cookieoutlen = 0;
    int rv = -1;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

4964 4965 4966 4967 4968 4969 4970
    if (args->params.params_len > REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX) {
        virReportError(VIR_ERR_RPC,
                       _("Too many migration parameters '%d' for limit '%d'"),
                       args->params.params_len, REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX);
        goto cleanup;
    }

4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003
    if (!(params = remoteDeserializeTypedParameters(args->params.params_val,
                                                    args->params.params_len,
                                                    0, &nparams)))
        goto cleanup;

    dom = virDomainMigrateFinish3Params(priv->conn, params, nparams,
                                        args->cookie_in.cookie_in_val,
                                        args->cookie_in.cookie_in_len,
                                        &cookieout, &cookieoutlen,
                                        args->flags, args->cancelled);
    if (!dom)
        goto cleanup;

    make_nonnull_domain(&ret->dom, dom);

    ret->cookie_out.cookie_out_len = cookieoutlen;
    ret->cookie_out.cookie_out_val = cookieout;

    rv = 0;

cleanup:
    virTypedParamsFree(params, nparams);
    if (rv < 0) {
        virNetMessageSaveError(rerr);
        VIR_FREE(cookieout);
    }
    if (dom)
        virDomainFree(dom);
    return rv;
}


static int
5004 5005 5006 5007 5008
remoteDispatchDomainMigrateConfirm3Params(virNetServerPtr server ATTRIBUTE_UNUSED,
                                          virNetServerClientPtr client ATTRIBUTE_UNUSED,
                                          virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                          virNetMessageErrorPtr rerr,
                                          remote_domain_migrate_confirm3_params_args *args)
5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021
{
    virTypedParameterPtr params = NULL;
    int nparams = 0;
    virDomainPtr dom = NULL;
    int rv = -1;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

5022 5023 5024 5025 5026 5027 5028
    if (args->params.params_len > REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX) {
        virReportError(VIR_ERR_RPC,
                       _("Too many migration parameters '%d' for limit '%d'"),
                       args->params.params_len, REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX);
        goto cleanup;
    }

5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054
    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
        goto cleanup;

    if (!(params = remoteDeserializeTypedParameters(args->params.params_val,
                                                    args->params.params_len,
                                                    0, &nparams)))
        goto cleanup;

    if (virDomainMigrateConfirm3Params(dom, params, nparams,
                                       args->cookie_in.cookie_in_val,
                                       args->cookie_in.cookie_in_len,
                                       args->flags, args->cancelled) < 0)
        goto cleanup;

    rv = 0;

cleanup:
    virTypedParamsFree(params, nparams);
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (dom)
        virDomainFree(dom);
    return rv;
}


5055 5056 5057 5058 5059 5060 5061
static int
remoteDispatchDomainCreateXMLWithFiles(virNetServerPtr server ATTRIBUTE_UNUSED,
                                       virNetServerClientPtr client,
                                       virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                       virNetMessageErrorPtr rerr,
                                       remote_domain_create_xml_with_files_args *args,
                                       remote_domain_create_xml_with_files_ret *ret)
5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104
{
    int rv = -1;
    virDomainPtr dom = NULL;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
    int *files = NULL;
    unsigned int nfiles = 0;
    size_t i;

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

    if (VIR_ALLOC_N(files, msg->nfds) < 0)
        goto cleanup;
    for (i = 0; i < msg->nfds; i++) {
        if ((files[i] = virNetMessageDupFD(msg, i)) < 0)
            goto cleanup;
        nfiles++;
    }

    if ((dom = virDomainCreateXMLWithFiles(priv->conn, args->xml_desc,
                                           nfiles, files,
                                           args->flags)) == NULL)
        goto cleanup;

    make_nonnull_domain(&ret->dom, dom);
    rv = 0;

cleanup:
    for (i = 0; i < nfiles; i++) {
        VIR_FORCE_CLOSE(files[i]);
    }
    VIR_FREE(files);
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (dom)
        virDomainFree(dom);
    return rv;
}


5105 5106 5107 5108 5109 5110
static int remoteDispatchDomainCreateWithFiles(virNetServerPtr server ATTRIBUTE_UNUSED,
                                               virNetServerClientPtr client,
                                               virNetMessagePtr msg ATTRIBUTE_UNUSED,
                                               virNetMessageErrorPtr rerr,
                                               remote_domain_create_with_files_args *args,
                                               remote_domain_create_with_files_ret *ret)
5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157
{
    int rv = -1;
    virDomainPtr dom = NULL;
    struct daemonClientPrivate *priv =
        virNetServerClientGetPrivateData(client);
    int *files = NULL;
    unsigned int nfiles = 0;
    size_t i;

    if (!priv->conn) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
        goto cleanup;
    }

    if (VIR_ALLOC_N(files, msg->nfds) < 0)
        goto cleanup;
    for (i = 0; i < msg->nfds; i++) {
        if ((files[i] = virNetMessageDupFD(msg, i)) < 0)
            goto cleanup;
        nfiles++;
    }

    if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
        goto cleanup;

    if (virDomainCreateWithFiles(dom,
                                 nfiles, files,
                                 args->flags) < 0)
        goto cleanup;

    make_nonnull_domain(&ret->dom, dom);
    rv = 0;

cleanup:
    for (i = 0; i < nfiles; i++) {
        VIR_FORCE_CLOSE(files[i]);
    }
    VIR_FREE(files);
    if (rv < 0)
        virNetMessageSaveError(rerr);
    if (dom)
        virDomainFree(dom);
    return rv;
}



5158 5159 5160 5161 5162 5163 5164 5165 5166
/*----- Helpers. -----*/

/* get_nonnull_domain and get_nonnull_network turn an on-wire
 * (name, uuid) pair into virDomainPtr or virNetworkPtr object.
 * virDomainPtr or virNetworkPtr cannot be NULL.
 *
 * NB. If these return NULL then the caller must return an error.
 */
static virDomainPtr
5167
get_nonnull_domain(virConnectPtr conn, remote_nonnull_domain domain)
5168 5169
{
    virDomainPtr dom;
5170
    dom = virGetDomain(conn, domain.name, BAD_CAST domain.uuid);
5171 5172 5173 5174 5175 5176 5177 5178
    /* Should we believe the domain.id sent by the client?  Maybe
     * this should be a check rather than an assignment? XXX
     */
    if (dom) dom->id = domain.id;
    return dom;
}

static virNetworkPtr
5179
get_nonnull_network(virConnectPtr conn, remote_nonnull_network network)
5180
{
5181
    return virGetNetwork(conn, network.name, BAD_CAST network.uuid);
5182 5183
}

D
Daniel Veillard 已提交
5184
static virInterfacePtr
5185
get_nonnull_interface(virConnectPtr conn, remote_nonnull_interface iface)
D
Daniel Veillard 已提交
5186
{
5187
    return virGetInterface(conn, iface.name, iface.mac);
D
Daniel Veillard 已提交
5188 5189
}

5190
static virStoragePoolPtr
5191
get_nonnull_storage_pool(virConnectPtr conn, remote_nonnull_storage_pool pool)
5192
{
5193 5194
    return virGetStoragePool(conn, pool.name, BAD_CAST pool.uuid,
                             NULL, NULL);
5195 5196 5197
}

static virStorageVolPtr
5198
get_nonnull_storage_vol(virConnectPtr conn, remote_nonnull_storage_vol vol)
5199 5200
{
    virStorageVolPtr ret;
5201 5202
    ret = virGetStorageVol(conn, vol.pool, vol.name, vol.key,
                           NULL, NULL);
5203 5204 5205
    return ret;
}

5206
static virSecretPtr
5207
get_nonnull_secret(virConnectPtr conn, remote_nonnull_secret secret)
5208
{
5209
    return virGetSecret(conn, BAD_CAST secret.uuid, secret.usageType, secret.usageID);
5210 5211
}

5212
static virNWFilterPtr
5213
get_nonnull_nwfilter(virConnectPtr conn, remote_nonnull_nwfilter nwfilter)
5214
{
5215
    return virGetNWFilter(conn, nwfilter.name, BAD_CAST nwfilter.uuid);
5216 5217
}

C
Chris Lalancette 已提交
5218
static virDomainSnapshotPtr
5219
get_nonnull_domain_snapshot(virDomainPtr dom, remote_nonnull_domain_snapshot snapshot)
C
Chris Lalancette 已提交
5220
{
5221
    return virGetDomainSnapshot(dom, snapshot.name);
C
Chris Lalancette 已提交
5222 5223
}

5224 5225
/* Make remote_nonnull_domain and remote_nonnull_network. */
static void
5226
make_nonnull_domain(remote_nonnull_domain *dom_dst, virDomainPtr dom_src)
5227 5228
{
    dom_dst->id = dom_src->id;
5229
    ignore_value(VIR_STRDUP_QUIET(dom_dst->name, dom_src->name));
5230
    memcpy(dom_dst->uuid, dom_src->uuid, VIR_UUID_BUFLEN);
5231 5232 5233
}

static void
5234
make_nonnull_network(remote_nonnull_network *net_dst, virNetworkPtr net_src)
5235
{
5236
    ignore_value(VIR_STRDUP_QUIET(net_dst->name, net_src->name));
5237
    memcpy(net_dst->uuid, net_src->uuid, VIR_UUID_BUFLEN);
5238 5239
}

D
Daniel Veillard 已提交
5240
static void
5241 5242
make_nonnull_interface(remote_nonnull_interface *interface_dst,
                       virInterfacePtr interface_src)
D
Daniel Veillard 已提交
5243
{
5244 5245
    ignore_value(VIR_STRDUP_QUIET(interface_dst->name, interface_src->name));
    ignore_value(VIR_STRDUP_QUIET(interface_dst->mac, interface_src->mac));
D
Daniel Veillard 已提交
5246 5247
}

5248
static void
5249
make_nonnull_storage_pool(remote_nonnull_storage_pool *pool_dst, virStoragePoolPtr pool_src)
5250
{
5251
    ignore_value(VIR_STRDUP_QUIET(pool_dst->name, pool_src->name));
5252
    memcpy(pool_dst->uuid, pool_src->uuid, VIR_UUID_BUFLEN);
5253 5254 5255
}

static void
5256
make_nonnull_storage_vol(remote_nonnull_storage_vol *vol_dst, virStorageVolPtr vol_src)
5257
{
5258 5259 5260
    ignore_value(VIR_STRDUP_QUIET(vol_dst->pool, vol_src->pool));
    ignore_value(VIR_STRDUP_QUIET(vol_dst->name, vol_src->name));
    ignore_value(VIR_STRDUP_QUIET(vol_dst->key, vol_src->key));
5261
}
5262 5263

static void
5264
make_nonnull_node_device(remote_nonnull_node_device *dev_dst, virNodeDevicePtr dev_src)
5265
{
5266
    ignore_value(VIR_STRDUP_QUIET(dev_dst->name, dev_src->name));
5267
}
5268 5269

static void
5270
make_nonnull_secret(remote_nonnull_secret *secret_dst, virSecretPtr secret_src)
5271
{
5272
    memcpy(secret_dst->uuid, secret_src->uuid, VIR_UUID_BUFLEN);
5273
    secret_dst->usageType = secret_src->usageType;
5274
    ignore_value(VIR_STRDUP_QUIET(secret_dst->usageID, secret_src->usageID));
5275
}
5276 5277

static void
5278
make_nonnull_nwfilter(remote_nonnull_nwfilter *nwfilter_dst, virNWFilterPtr nwfilter_src)
5279
{
5280
    ignore_value(VIR_STRDUP_QUIET(nwfilter_dst->name, nwfilter_src->name));
5281
    memcpy(nwfilter_dst->uuid, nwfilter_src->uuid, VIR_UUID_BUFLEN);
5282
}
C
Chris Lalancette 已提交
5283 5284

static void
5285
make_nonnull_domain_snapshot(remote_nonnull_domain_snapshot *snapshot_dst, virDomainSnapshotPtr snapshot_src)
C
Chris Lalancette 已提交
5286
{
5287
    ignore_value(VIR_STRDUP_QUIET(snapshot_dst->name, snapshot_src->name));
5288
    make_nonnull_domain(&snapshot_dst->dom, snapshot_src->domain);
C
Chris Lalancette 已提交
5289
}
5290 5291 5292 5293 5294 5295 5296 5297

static int
remoteSerializeDomainDiskErrors(virDomainDiskErrorPtr errors,
                                int nerrors,
                                remote_domain_disk_error **ret_errors_val,
                                u_int *ret_errors_len)
{
    remote_domain_disk_error *val = NULL;
5298
    size_t i = 0;
5299

5300
    if (VIR_ALLOC_N(val, nerrors) < 0)
5301
        goto error;
5302 5303

    for (i = 0; i < nerrors; i++) {
5304 5305
        if (VIR_STRDUP(val[i].disk, errors[i].disk) < 0)
            goto error;
5306 5307 5308 5309 5310 5311 5312 5313
        val[i].error = errors[i].error;
    }

    *ret_errors_len = nerrors;
    *ret_errors_val = val;

    return 0;

5314
error:
5315
    if (val) {
5316
        size_t j;
5317 5318 5319 5320 5321 5322
        for (j = 0; j < i; j++)
            VIR_FREE(val[j].disk);
        VIR_FREE(val);
    }
    return -1;
}