tests/qemumonitortestutils.c

   1 /*
   2  * Copyright (C) 2011-2013 Red Hat, Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library.  If not, see
  16  * <http://www.gnu.org/licenses/>.
  17  *
  18  */
  19
  20 #include <config.h>
  21
  22 #include <time.h>
  23
  24 #include "testutils.h"
  25 #include "testutilsqemuschema.h"
  26 #include "qemumonitortestutils.h"
  27
  28 #include "virthread.h"
  29 #define LIBVIRT_QEMU_PROCESSPRIV_H_ALLOW
  30 #include "qemu/qemu_processpriv.h"
  31 #include "qemu/qemu_monitor.h"
  32 #include "qemu/qemu_agent.h"
  33 #include "qemu/qemu_qapi.h"
  34 #include "rpc/virnetsocket.h"
  35 #include "viralloc.h"
  36 #include "virlog.h"
  37 #include "virerror.h"
  38 #include "virstring.h"
  39
  40 #define VIR_FROM_THIS VIR_FROM_NONE
  41
  42 VIR_LOG_INIT("tests.qemumonitortestutils");
  43
  44 struct _qemuMonitorTestItem {
  45     qemuMonitorTestResponseCallback cb;
  46     void *opaque;
  47     virFreeCallback freecb;
  48 };
  49
  50 struct _qemuMonitorTest {
  51     virMutex lock;
  52     virThread thread;
  53
  54     bool quit;
  55     bool running;
  56     bool started;
  57
  58     char *incoming;
  59     size_t incomingLength;
  60     size_t incomingCapacity;
  61
  62     char *outgoing;
  63     size_t outgoingLength;
  64     size_t outgoingCapacity;
  65
  66     virNetSocketPtr server;
  67     virNetSocketPtr client;
  68
  69     qemuMonitorPtr mon;
  70     qemuAgentPtr agent;
  71
  72     char *tmpdir;
  73
  74     size_t nitems;
  75     qemuMonitorTestItemPtr *items;
  76
  77     virDomainObjPtr vm;
  78     virHashTablePtr qapischema;
  79 };
  80
  81
  82 static void
  83 qemuMonitorTestItemFree(qemuMonitorTestItemPtr item)
  84 {
  85     if (!item)
  86         return;
  87
  88     if (item->freecb)
  89         (item->freecb)(item->opaque);
  90
  91     VIR_FREE(item);
  92 }
  93
  94
  95 /*
  96  * Appends data for a reply to the outgoing buffer
  97  */
  98 int
  99 qemuMonitorTestAddResponse(qemuMonitorTestPtr test,
 100                            const char *response)
 101 {
 102     size_t want = strlen(response) + 2;
 103     size_t have = test->outgoingCapacity - test->outgoingLength;
 104
 105     VIR_DEBUG("Adding response to monitor command: '%s", response);
 106
 107     if (have < want) {
 108         size_t need = want - have;
 109         if (VIR_EXPAND_N(test->outgoing, test->outgoingCapacity, need) < 0)
 110             return -1;
 111     }
 112
 113     want -= 2;
 114     memcpy(test->outgoing + test->outgoingLength, response, want);
 115     memcpy(test->outgoing + test->outgoingLength + want, "\r\n", 2);
 116     test->outgoingLength += want + 2;
 117     return 0;
 118 }
 119
 120
 121 static int
 122 qemuMonitorTestAddErrorResponse(qemuMonitorTestPtr test,
 123                                 const char *usermsg)
 124 {
 125     virBuffer buf = VIR_BUFFER_INITIALIZER;
 126     VIR_AUTOFREE(char *) escapemsg = NULL;
 127     VIR_AUTOFREE(char *) jsonmsg = NULL;
 128     char *tmp;
 129
 130     if (!usermsg)
 131         usermsg = "unexpected command";
 132
 133     virBufferEscape(&buf, '\\', "\"", "%s", usermsg);
 134     if (virBufferCheckError(&buf) < 0)
 135         return -1;
 136     escapemsg = virBufferContentAndReset(&buf);
 137
 138     /* replace newline/carriage return with space */
 139     tmp = escapemsg;
 140     while (*tmp) {
 141         if (*tmp == '\r' || *tmp == '\n')
 142             *tmp = ' ';
 143
 144         tmp++;
 145     }
 146
 147     /* format the JSON error message */
 148     if (virAsprintf(&jsonmsg, "{ \"error\": "
 149                     " { \"desc\": \"%s\", "
 150                     "   \"class\": \"UnexpectedCommand\" } }",
 151                     escapemsg) < 0)
 152         return -1;
 153
 154     return qemuMonitorTestAddResponse(test, jsonmsg);
 155 }
 156
 157
 158 static int
 159 qemuMonitorTestAddUnexpectedErrorResponse(qemuMonitorTestPtr test,
 160                                           const char *command)
 161 {
 162     VIR_AUTOFREE(char *) msg = NULL;
 163
 164     if (virAsprintf(&msg, "unexpected command: '%s'", command) < 0)
 165         return -1;
 166
 167     return qemuMonitorTestAddErrorResponse(test, msg);
 168 }
 169
 170
 171 int
 172 qemuMonitorTestAddInvalidCommandResponse(qemuMonitorTestPtr test,
 173                                          const char *expectedcommand,
 174                                          const char *actualcommand)
 175 {
 176     VIR_AUTOFREE(char *) msg = NULL;
 177
 178     if (virAsprintf(&msg, "expected command '%s' got '%s'",
 179                     expectedcommand, actualcommand) < 0)
 180         return -1;
 181
 182     return qemuMonitorTestAddErrorResponse(test, msg);
 183 }
 184
 185
 186 int ATTRIBUTE_FMT_PRINTF(2, 3)
 187 qemuMonitorReportError(qemuMonitorTestPtr test, const char *errmsg, ...)
 188 {
 189     va_list msgargs;
 190     VIR_AUTOFREE(char *) tmp = NULL;
 191     VIR_AUTOFREE(char *) msg = NULL;
 192     VIR_AUTOFREE(char *) jsonmsg = NULL;
 193     int ret = -1;
 194
 195     va_start(msgargs, errmsg);
 196
 197     if (virVasprintf(&msg, errmsg, msgargs) < 0)
 198         goto cleanup;
 199
 200     if (!(tmp = qemuMonitorEscapeArg(msg)))
 201         goto cleanup;
 202
 203     if (virAsprintf(&jsonmsg, "{ \"error\": "
 204                     " { \"desc\": \"%s\", "
 205                     "   \"class\": \"UnexpectedCommand\" } }",
 206                     tmp) < 0)
 207         goto cleanup;
 208
 209     ret = qemuMonitorTestAddResponse(test, jsonmsg);
 210
 211  cleanup:
 212     va_end(msgargs);
 213     return ret;
 214 }
 215
 216
 217 static int
 218 qemuMonitorTestProcessCommand(qemuMonitorTestPtr test,
 219                               const char *cmdstr)
 220 {
 221     int ret;
 222
 223     VIR_DEBUG("Processing string from monitor handler: '%s", cmdstr);
 224
 225     if (test->nitems == 0) {
 226         return qemuMonitorTestAddUnexpectedErrorResponse(test, cmdstr);
 227     } else {
 228         qemuMonitorTestItemPtr item = test->items[0];
 229         ret = (item->cb)(test, item, cmdstr);
 230         qemuMonitorTestItemFree(item);
 231         if (VIR_DELETE_ELEMENT(test->items, 0, test->nitems) < 0)
 232             return -1;
 233     }
 234
 235     return ret;
 236 }
 237
 238
 239 /*
 240  * Handles read/write of monitor data on the monitor server side
 241  */
 242 static void
 243 qemuMonitorTestIO(virNetSocketPtr sock,
 244                   int events,
 245                   void *opaque)
 246 {
 247     qemuMonitorTestPtr test = opaque;
 248     bool err = false;
 249
 250     virMutexLock(&test->lock);
 251     if (test->quit) {
 252         virMutexUnlock(&test->lock);
 253         return;
 254     }
 255     if (events & VIR_EVENT_HANDLE_WRITABLE) {
 256         ssize_t ret;
 257         if ((ret = virNetSocketWrite(sock,
 258                                      test->outgoing,
 259                                      test->outgoingLength)) < 0) {
 260             err = true;
 261             goto cleanup;
 262         }
 263
 264         memmove(test->outgoing,
 265                 test->outgoing + ret,
 266                 test->outgoingLength - ret);
 267         test->outgoingLength -= ret;
 268
 269         if ((test->outgoingCapacity - test->outgoingLength) > 1024)
 270             VIR_SHRINK_N(test->outgoing, test->outgoingCapacity, 1024);
 271     }
 272
 273     if (events & VIR_EVENT_HANDLE_READABLE) {
 274         ssize_t ret, used;
 275         char *t1, *t2;
 276
 277         if ((test->incomingCapacity - test->incomingLength) < 1024) {
 278             if (VIR_EXPAND_N(test->incoming, test->incomingCapacity, 1024) < 0) {
 279                 err = true;
 280                 goto cleanup;
 281             }
 282         }
 283
 284         if ((ret = virNetSocketRead(sock,
 285                                     test->incoming + test->incomingLength,
 286                                     (test->incomingCapacity - test->incomingLength) - 1)) < 0) {
 287             err = true;
 288             goto cleanup;
 289         }
 290         test->incomingLength += ret;
 291         test->incoming[test->incomingLength] = '\0';
 292
 293         /* Look to see if we've got a complete line, and
 294          * if so, handle that command
 295          */
 296         t1 = test->incoming;
 297         while ((t2 = strstr(t1, "\n")) ||
 298                 (test->agent && (t2 = strstr(t1, "\r")))) {
 299             *t2 = '\0';
 300
 301             if (qemuMonitorTestProcessCommand(test, t1) < 0) {
 302                 err = true;
 303                 goto cleanup;
 304             }
 305
 306             t1 = t2 + 1;
 307         }
 308         used = t1 - test->incoming;
 309         memmove(test->incoming, t1, test->incomingLength - used);
 310         test->incomingLength -= used;
 311         if ((test->incomingCapacity - test->incomingLength) > 1024) {
 312             VIR_SHRINK_N(test->incoming,
 313                          test->incomingCapacity,
 314                          1024);
 315         }
 316     }
 317
 318     if (events & (VIR_EVENT_HANDLE_HANGUP |
 319                   VIR_EVENT_HANDLE_ERROR))
 320         err = true;
 321
 322  cleanup:
 323     if (err) {
 324         virNetSocketRemoveIOCallback(sock);
 325         virNetSocketClose(sock);
 326         virObjectUnref(test->client);
 327         test->client = NULL;
 328     } else {
 329         events = VIR_EVENT_HANDLE_READABLE;
 330
 331         if (test->outgoingLength)
 332             events |= VIR_EVENT_HANDLE_WRITABLE;
 333
 334         virNetSocketUpdateIOCallback(sock, events);
 335     }
 336     virMutexUnlock(&test->lock);
 337 }
 338
 339
 340 static void
 341 qemuMonitorTestWorker(void *opaque)
 342 {
 343     qemuMonitorTestPtr test = opaque;
 344
 345     virMutexLock(&test->lock);
 346
 347     while (!test->quit) {
 348         virMutexUnlock(&test->lock);
 349
 350         if (virEventRunDefaultImpl() < 0) {
 351             virMutexLock(&test->lock);
 352             test->quit = true;
 353             break;
 354         }
 355
 356         virMutexLock(&test->lock);
 357     }
 358
 359     test->running = false;
 360
 361     virMutexUnlock(&test->lock);
 362     return;
 363 }
 364
 365
 366 static void
 367 qemuMonitorTestFreeTimer(int timer ATTRIBUTE_UNUSED,
 368                          void *opaque ATTRIBUTE_UNUSED)
 369 {
 370     /* nothing to be done here */
 371 }
 372
 373
 374 void
 375 qemuMonitorTestFree(qemuMonitorTestPtr test)
 376 {
 377     size_t i;
 378     int timer = -1;
 379
 380     if (!test)
 381         return;
 382
 383     virMutexLock(&test->lock);
 384     if (test->running) {
 385         test->quit = true;
 386         /* HACK: Add a dummy timeout to break event loop */
 387         timer = virEventAddTimeout(0, qemuMonitorTestFreeTimer, NULL, NULL);
 388     }
 389     virMutexUnlock(&test->lock);
 390
 391     if (test->client) {
 392         virNetSocketRemoveIOCallback(test->client);
 393         virNetSocketClose(test->client);
 394         virObjectUnref(test->client);
 395     }
 396
 397     virObjectUnref(test->server);
 398     if (test->mon) {
 399         virObjectUnlock(test->mon);
 400         qemuMonitorClose(test->mon);
 401     }
 402
 403     if (test->agent) {
 404         virObjectUnlock(test->agent);
 405         qemuAgentClose(test->agent);
 406     }
 407
 408     virObjectUnref(test->vm);
 409
 410     if (test->started)
 411         virThreadJoin(&test->thread);
 412
 413     if (timer != -1)
 414         virEventRemoveTimeout(timer);
 415
 416     VIR_FREE(test->incoming);
 417     VIR_FREE(test->outgoing);
 418
 419     for (i = 0; i < test->nitems; i++)
 420         qemuMonitorTestItemFree(test->items[i]);
 421     VIR_FREE(test->items);
 422
 423     if (test->tmpdir && rmdir(test->tmpdir) < 0)
 424         VIR_WARN("Failed to remove tempdir: %s", strerror(errno));
 425
 426     VIR_FREE(test->tmpdir);
 427
 428     virMutexDestroy(&test->lock);
 429     VIR_FREE(test);
 430 }
 431
 432
 433 int
 434 qemuMonitorTestAddHandler(qemuMonitorTestPtr test,
 435                           qemuMonitorTestResponseCallback cb,
 436                           void *opaque,
 437                           virFreeCallback freecb)
 438 {
 439     qemuMonitorTestItemPtr item;
 440
 441     if (VIR_ALLOC(item) < 0)
 442         goto error;
 443
 444     item->cb = cb;
 445     item->freecb = freecb;
 446     item->opaque = opaque;
 447
 448     virMutexLock(&test->lock);
 449     if (VIR_APPEND_ELEMENT(test->items, test->nitems, item) < 0) {
 450         virMutexUnlock(&test->lock);
 451         goto error;
 452     }
 453     virMutexUnlock(&test->lock);
 454
 455     return 0;
 456
 457  error:
 458     if (freecb)
 459         (freecb)(opaque);
 460     VIR_FREE(item);
 461     return -1;
 462 }
 463
 464 void *
 465 qemuMonitorTestItemGetPrivateData(qemuMonitorTestItemPtr item)
 466 {
 467     return item ? item->opaque : NULL;
 468 }
 469
 470
 471 typedef struct _qemuMonitorTestCommandArgs qemuMonitorTestCommandArgs;
 472 typedef qemuMonitorTestCommandArgs *qemuMonitorTestCommandArgsPtr;
 473 struct _qemuMonitorTestCommandArgs {
 474     char *argname;
 475     char *argval;
 476 };
 477
 478
 479 struct qemuMonitorTestHandlerData {
 480     char *command_name;
 481     char *cmderr;
 482     char *response;
 483     size_t nargs;
 484     qemuMonitorTestCommandArgsPtr args;
 485     char *expectArgs;
 486 };
 487
 488 static void
 489 qemuMonitorTestHandlerDataFree(void *opaque)
 490 {
 491     struct qemuMonitorTestHandlerData *data = opaque;
 492     size_t i;
 493
 494     if (!data)
 495         return;
 496
 497     for (i = 0; i < data->nargs; i++) {
 498         VIR_FREE(data->args[i].argname);
 499         VIR_FREE(data->args[i].argval);
 500     }
 501
 502     VIR_FREE(data->command_name);
 503     VIR_FREE(data->cmderr);
 504     VIR_FREE(data->response);
 505     VIR_FREE(data->args);
 506     VIR_FREE(data->expectArgs);
 507     VIR_FREE(data);
 508 }
 509
 510
 511 /* Returns -1 on error, 0 if validation was successful/not necessary, 1 if
 512  * the validation has failed, and the reply was properly constructed */
 513 static int
 514 qemuMonitorTestProcessCommandDefaultValidate(qemuMonitorTestPtr test,
 515                                              const char *cmdname,
 516                                              virJSONValuePtr args)
 517 {
 518     VIR_AUTOCLEAN(virBuffer) debug = VIR_BUFFER_INITIALIZER;
 519     virJSONValuePtr schemaroot;
 520     VIR_AUTOPTR(virJSONValue) emptyargs = NULL;
 521     VIR_AUTOFREE(char *) schemapath = NULL;
 522
 523     if (!test->qapischema)
 524         return 0;
 525
 526     if (test->agent) {
 527         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
 528                        "Command validation testing is not "
 529                        "implemented for the guest agent");
 530         return -1;
 531     }
 532
 533     /* 'device_add' needs to be skipped as it does not have fully defined schema */
 534     if (STREQ(cmdname, "device_add"))
 535         return 0;
 536
 537     if (virAsprintf(&schemapath, "%s/arg-type", cmdname) < 0)
 538         return -1;
 539
 540     if (virQEMUQAPISchemaPathGet(schemapath, test->qapischema, &schemaroot) < 0 ||
 541         !schemaroot) {
 542         if (qemuMonitorReportError(test,
 543                                    "command '%s' not found in QAPI schema",
 544                                    cmdname) == 0)
 545             return 1;
 546         return -1;
 547     }
 548
 549     if (!args) {
 550         if (!(emptyargs = virJSONValueNewObject()))
 551             return -1;
 552
 553         args = emptyargs;
 554     }
 555
 556     if (testQEMUSchemaValidate(args, schemaroot, test->qapischema, &debug) < 0) {
 557         if (qemuMonitorReportError(test,
 558                                    "failed to validate arguments of '%s' "
 559                                    "against QAPI schema: %s",
 560                                    cmdname, virBufferCurrentContent(&debug)) == 0)
 561             return 1;
 562         return -1;
 563     }
 564
 565     return 0;
 566 }
 567
 568
 569 static int
 570 qemuMonitorTestProcessCommandDefault(qemuMonitorTestPtr test,
 571                                      qemuMonitorTestItemPtr item,
 572                                      const char *cmdstr)
 573 {
 574     struct qemuMonitorTestHandlerData *data = item->opaque;
 575     VIR_AUTOPTR(virJSONValue) val = NULL;
 576     virJSONValuePtr cmdargs = NULL;
 577     const char *cmdname;
 578     int rc;
 579
 580     if (!(val = virJSONValueFromString(cmdstr)))
 581         return -1;
 582
 583     if (!(cmdname = virJSONValueObjectGetString(val, "execute")))
 584         return qemuMonitorReportError(test, "Missing command name in %s", cmdstr);
 585
 586     cmdargs = virJSONValueObjectGet(val, "arguments");
 587     if ((rc = qemuMonitorTestProcessCommandDefaultValidate(test, cmdname, cmdargs)) < 0)
 588         return -1;
 589     if (rc == 1)
 590         return 0;
 591
 592     if (data->command_name && STRNEQ(data->command_name, cmdname)) {
 593         return qemuMonitorTestAddInvalidCommandResponse(test, data->command_name,
 594                                                         cmdname);
 595     } else {
 596         return qemuMonitorTestAddResponse(test, data->response);
 597     }
 598 }
 599
 600
 601 int
 602 qemuMonitorTestAddItem(qemuMonitorTestPtr test,
 603                        const char *command_name,
 604                        const char *response)
 605 {
 606     struct qemuMonitorTestHandlerData *data;
 607
 608     if (VIR_ALLOC(data) < 0)
 609         return -1;
 610
 611     if (VIR_STRDUP(data->command_name, command_name) < 0 ||
 612         VIR_STRDUP(data->response, response) < 0) {
 613         qemuMonitorTestHandlerDataFree(data);
 614         return -1;
 615     }
 616
 617     return qemuMonitorTestAddHandler(test,
 618                                      qemuMonitorTestProcessCommandDefault,
 619                                      data, qemuMonitorTestHandlerDataFree);
 620 }
 621
 622
 623 static int
 624 qemuMonitorTestProcessCommandVerbatim(qemuMonitorTestPtr test,
 625                                       qemuMonitorTestItemPtr item,
 626                                       const char *cmdstr)
 627 {
 628     struct qemuMonitorTestHandlerData *data = item->opaque;
 629     VIR_AUTOFREE(char *) reformatted = NULL;
 630     VIR_AUTOFREE(char *) errmsg = NULL;
 631     VIR_AUTOPTR(virJSONValue) json = NULL;
 632     virJSONValuePtr cmdargs;
 633     const char *cmdname;
 634     int ret = -1;
 635     int rc;
 636
 637     /* JSON strings will be reformatted to simplify checking */
 638     if (!(json = virJSONValueFromString(cmdstr)) ||
 639         !(reformatted = virJSONValueToString(json, false)))
 640         return -1;
 641
 642     cmdstr = reformatted;
 643
 644     /* in this case we do a best-effort schema check if we can find the command */
 645     if ((cmdname = virJSONValueObjectGetString(json, "execute"))) {
 646         cmdargs = virJSONValueObjectGet(json, "arguments");
 647
 648         if ((rc = qemuMonitorTestProcessCommandDefaultValidate(test, cmdname, cmdargs)) < 0)
 649             return -1;
 650
 651         if (rc == 1)
 652             return 0;
 653     }
 654
 655     if (STREQ(data->command_name, cmdstr)) {
 656         ret = qemuMonitorTestAddResponse(test, data->response);
 657     } else {
 658         if (data->cmderr) {
 659             if (virAsprintf(&errmsg, "%s: %s", data->cmderr, cmdstr) < 0)
 660                 return -1;
 661
 662             ret = qemuMonitorTestAddErrorResponse(test, errmsg);
 663         } else {
 664             ret = qemuMonitorTestAddInvalidCommandResponse(test,
 665                                                            data->command_name,
 666                                                            cmdstr);
 667         }
 668     }
 669
 670     return ret;
 671 }
 672
 673
 674 /**
 675  * qemuMonitorTestAddItemVerbatim:
 676  * @test: monitor test object
 677  * @command: full expected command syntax
 678  * @cmderr: possible explanation of expected command (may be NULL)
 679  * @response: full reply of @command
 680  *
 681  * Adds a test command for the simulated monitor. The full syntax is checked
 682  * as specified in @command. For JSON monitor tests formatting/whitespace is
 683  * ignored. If the command on the monitor is not as expected an error containing
 684  * @cmderr is returned. Otherwise @response is put as-is on the monitor.
 685  *
 686  * Returns 0 when command was successfully added, -1 on error.
 687  */
 688 int
 689 qemuMonitorTestAddItemVerbatim(qemuMonitorTestPtr test,
 690                                const char *command,
 691                                const char *cmderr,
 692                                const char *response)
 693 {
 694     struct qemuMonitorTestHandlerData *data;
 695
 696     if (VIR_ALLOC(data) < 0)
 697         return -1;
 698
 699     if (VIR_STRDUP(data->response, response) < 0 ||
 700         VIR_STRDUP(data->cmderr, cmderr) < 0)
 701         goto error;
 702
 703     data->command_name = virJSONStringReformat(command, false);
 704     if (!data->command_name)
 705         goto error;
 706
 707     return qemuMonitorTestAddHandler(test,
 708                                      qemuMonitorTestProcessCommandVerbatim,
 709                                      data, qemuMonitorTestHandlerDataFree);
 710
 711  error:
 712     qemuMonitorTestHandlerDataFree(data);
 713     return -1;
 714 }
 715
 716
 717 static int
 718 qemuMonitorTestProcessGuestAgentSync(qemuMonitorTestPtr test,
 719                                      qemuMonitorTestItemPtr item ATTRIBUTE_UNUSED,
 720                                      const char *cmdstr)
 721 {
 722     virJSONValuePtr val = NULL;
 723     virJSONValuePtr args;
 724     unsigned long long id;
 725     const char *cmdname;
 726     char *retmsg = NULL;
 727     int ret = -1;
 728
 729     if (!(val = virJSONValueFromString(cmdstr)))
 730         return -1;
 731
 732     if (!(cmdname = virJSONValueObjectGetString(val, "execute"))) {
 733         ret = qemuMonitorReportError(test, "Missing guest-sync command name");
 734         goto cleanup;
 735     }
 736
 737     if (STRNEQ(cmdname, "guest-sync")) {
 738         ret = qemuMonitorTestAddInvalidCommandResponse(test, "guest-sync", cmdname);
 739         goto cleanup;
 740     }
 741
 742     if (!(args = virJSONValueObjectGet(val, "arguments"))) {
 743         ret = qemuMonitorReportError(test, "Missing arguments for guest-sync");
 744         goto cleanup;
 745     }
 746
 747     if (virJSONValueObjectGetNumberUlong(args, "id", &id)) {
 748         ret = qemuMonitorReportError(test, "Missing id for guest sync");
 749         goto cleanup;
 750     }
 751
 752     if (virAsprintf(&retmsg, "{\"return\":%llu}", id) < 0)
 753         goto cleanup;
 754
 755
 756     ret = qemuMonitorTestAddResponse(test, retmsg);
 757
 758  cleanup:
 759     virJSONValueFree(val);
 760     VIR_FREE(retmsg);
 761     return ret;
 762 }
 763
 764
 765 int
 766 qemuMonitorTestAddAgentSyncResponse(qemuMonitorTestPtr test)
 767 {
 768     if (!test->agent) {
 769         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
 770                        "This test is not an agent test");
 771         return -1;
 772     }
 773
 774     return qemuMonitorTestAddHandler(test,
 775                                      qemuMonitorTestProcessGuestAgentSync,
 776                                      NULL, NULL);
 777 }
 778
 779
 780 static int
 781 qemuMonitorTestProcessCommandWithArgs(qemuMonitorTestPtr test,
 782                                       qemuMonitorTestItemPtr item,
 783                                       const char *cmdstr)
 784 {
 785     struct qemuMonitorTestHandlerData *data = item->opaque;
 786     virJSONValuePtr val = NULL;
 787     virJSONValuePtr args;
 788     virJSONValuePtr argobj;
 789     char *argstr = NULL;
 790     const char *cmdname;
 791     size_t i;
 792     int ret = -1;
 793
 794     if (!(val = virJSONValueFromString(cmdstr)))
 795         return -1;
 796
 797     if (!(cmdname = virJSONValueObjectGetString(val, "execute"))) {
 798         ret = qemuMonitorReportError(test, "Missing command name in %s", cmdstr);
 799         goto cleanup;
 800     }
 801
 802     if (data->command_name &&
 803         STRNEQ(data->command_name, cmdname)) {
 804         ret = qemuMonitorTestAddInvalidCommandResponse(test, data->command_name,
 805                                                        cmdname);
 806         goto cleanup;
 807     }
 808
 809     if (!(args = virJSONValueObjectGet(val, "arguments"))) {
 810         ret = qemuMonitorReportError(test,
 811                                      "Missing arguments section for command '%s'",
 812                                      NULLSTR(data->command_name));
 813         goto cleanup;
 814     }
 815
 816     /* validate the args */
 817     for (i = 0; i < data->nargs; i++) {
 818         qemuMonitorTestCommandArgsPtr arg = &data->args[i];
 819         if (!(argobj = virJSONValueObjectGet(args, arg->argname))) {
 820             ret = qemuMonitorReportError(test,
 821                                          "Missing argument '%s' for command '%s'",
 822                                          arg->argname,
 823                                          NULLSTR(data->command_name));
 824             goto cleanup;
 825         }
 826
 827         /* convert the argument to string */
 828         if (!(argstr = virJSONValueToString(argobj, false)))
 829             goto cleanup;
 830
 831         /* verify that the argument value is expected */
 832         if (STRNEQ(argstr, arg->argval)) {
 833             ret = qemuMonitorReportError(test,
 834                                          "Invalid value of argument '%s' "
 835                                          "of command '%s': "
 836                                          "expected '%s' got '%s'",
 837                                          arg->argname,
 838                                          NULLSTR(data->command_name),
 839                                          arg->argval, argstr);
 840             goto cleanup;
 841         }
 842
 843         VIR_FREE(argstr);
 844     }
 845
 846     /* arguments checked out, return the response */
 847     ret = qemuMonitorTestAddResponse(test, data->response);
 848
 849  cleanup:
 850     VIR_FREE(argstr);
 851     virJSONValueFree(val);
 852     return ret;
 853 }
 854
 855
 856
 857 /* this allows to add a responder that is able to check
 858  * a (shallow) structure of arguments for a command */
 859 int
 860 qemuMonitorTestAddItemParams(qemuMonitorTestPtr test,
 861                              const char *cmdname,
 862                              const char *response,
 863                              ...)
 864 {
 865     struct qemuMonitorTestHandlerData *data;
 866     const char *argname;
 867     const char *argval;
 868     va_list args;
 869
 870     va_start(args, response);
 871
 872     if (VIR_ALLOC(data) < 0)
 873         goto error;
 874
 875     if (VIR_STRDUP(data->command_name, cmdname) < 0 ||
 876         VIR_STRDUP(data->response, response) < 0)
 877         goto error;
 878
 879     while ((argname = va_arg(args, char *))) {
 880         size_t i;
 881         if (!(argval = va_arg(args, char *))) {
 882             virReportError(VIR_ERR_INTERNAL_ERROR,
 883                            "Missing argument value for argument '%s'",
 884                            argname);
 885             goto error;
 886         }
 887
 888         i = data->nargs;
 889         if (VIR_EXPAND_N(data->args, data->nargs, 1))
 890             goto error;
 891
 892         if (VIR_STRDUP(data->args[i].argname, argname) < 0 ||
 893             VIR_STRDUP(data->args[i].argval, argval) < 0)
 894             goto error;
 895     }
 896
 897     va_end(args);
 898
 899     return qemuMonitorTestAddHandler(test,
 900                                      qemuMonitorTestProcessCommandWithArgs,
 901                                      data, qemuMonitorTestHandlerDataFree);
 902
 903  error:
 904     va_end(args);
 905     qemuMonitorTestHandlerDataFree(data);
 906     return -1;
 907 }
 908
 909
 910 static int
 911 qemuMonitorTestProcessCommandWithArgStr(qemuMonitorTestPtr test,
 912                                         qemuMonitorTestItemPtr item,
 913                                         const char *cmdstr)
 914 {
 915     struct qemuMonitorTestHandlerData *data = item->opaque;
 916     virJSONValuePtr val = NULL;
 917     virJSONValuePtr args;
 918     char *argstr = NULL;
 919     const char *cmdname;
 920     int ret = -1;
 921
 922     if (!(val = virJSONValueFromString(cmdstr)))
 923         return -1;
 924
 925     if (!(cmdname = virJSONValueObjectGetString(val, "execute"))) {
 926         ret = qemuMonitorReportError(test, "Missing command name in %s", cmdstr);
 927         goto cleanup;
 928     }
 929
 930     if (STRNEQ(data->command_name, cmdname)) {
 931         ret = qemuMonitorTestAddInvalidCommandResponse(test, data->command_name,
 932                                                        cmdname);
 933         goto cleanup;
 934     }
 935
 936     if (!(args = virJSONValueObjectGet(val, "arguments"))) {
 937         ret = qemuMonitorReportError(test,
 938                                      "Missing arguments section for command '%s'",
 939                                      data->command_name);
 940         goto cleanup;
 941     }
 942
 943     /* convert the arguments to string */
 944     if (!(argstr = virJSONValueToString(args, false)))
 945         goto cleanup;
 946
 947     /* verify that the argument value is expected */
 948     if (STRNEQ(argstr, data->expectArgs)) {
 949         ret = qemuMonitorReportError(test,
 950                                      "%s: expected arguments: '%s', got: '%s'",
 951                                      data->command_name,
 952                                      data->expectArgs, argstr);
 953         goto cleanup;
 954     }
 955
 956     /* arguments checked out, return the response */
 957     ret = qemuMonitorTestAddResponse(test, data->response);
 958
 959  cleanup:
 960     VIR_FREE(argstr);
 961     virJSONValueFree(val);
 962     return ret;
 963 }
 964
 965
 966 /**
 967  * qemuMonitorTestAddItemExpect:
 968  *
 969  * @test: test monitor object
 970  * @cmdname: command name
 971  * @cmdargs: expected arguments of the command
 972  * @apostrophe: convert apostrophes (') in @cmdargs to quotes (")
 973  * @response: simulated response of the command
 974  *
 975  * Simulates a qemu monitor command. Checks that the 'arguments' of the qmp
 976  * command are expected. If @apostrophe is true apostrophes are converted to
 977  * quotes for simplification of writing the strings into code.
 978  */
 979 int
 980 qemuMonitorTestAddItemExpect(qemuMonitorTestPtr test,
 981                              const char *cmdname,
 982                              const char *cmdargs,
 983                              bool apostrophe,
 984                              const char *response)
 985 {
 986     struct qemuMonitorTestHandlerData *data;
 987
 988     if (VIR_ALLOC(data) < 0)
 989         goto error;
 990
 991     if (VIR_STRDUP(data->command_name, cmdname) < 0 ||
 992         VIR_STRDUP(data->response, response) < 0 ||
 993         VIR_STRDUP(data->expectArgs, cmdargs) < 0)
 994         goto error;
 995
 996     if (apostrophe) {
 997         char *tmp = data->expectArgs;
 998
 999         while (*tmp != '\0') {
1000             if (*tmp == '\'')
1001                 *tmp = '"';
1002
1003             tmp++;
1004         }
1005     }
1006
1007     return qemuMonitorTestAddHandler(test,
1008                                      qemuMonitorTestProcessCommandWithArgStr,
1009                                      data, qemuMonitorTestHandlerDataFree);
1010
1011  error:
1012     qemuMonitorTestHandlerDataFree(data);
1013     return -1;
1014 }
1015
1016
1017 static void
1018 qemuMonitorTestEOFNotify(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
1019                          virDomainObjPtr vm ATTRIBUTE_UNUSED,
1020                          void *opaque ATTRIBUTE_UNUSED)
1021 {
1022 }
1023
1024
1025 static void
1026 qemuMonitorTestErrorNotify(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
1027                            virDomainObjPtr vm ATTRIBUTE_UNUSED,
1028                            void *opaque ATTRIBUTE_UNUSED)
1029 {
1030 }
1031
1032
1033 static qemuMonitorCallbacks qemuMonitorTestCallbacks = {
1034     .eofNotify = qemuMonitorTestEOFNotify,
1035     .errorNotify = qemuMonitorTestErrorNotify,
1036     .domainDeviceDeleted = qemuProcessHandleDeviceDeleted,
1037 };
1038
1039
1040 static void
1041 qemuMonitorTestAgentNotify(qemuAgentPtr agent ATTRIBUTE_UNUSED,
1042                            virDomainObjPtr vm ATTRIBUTE_UNUSED)
1043 {
1044 }
1045
1046
1047 static qemuAgentCallbacks qemuMonitorTestAgentCallbacks = {
1048     .eofNotify = qemuMonitorTestAgentNotify,
1049     .errorNotify = qemuMonitorTestAgentNotify,
1050 };
1051
1052
1053 static qemuMonitorTestPtr
1054 qemuMonitorCommonTestNew(virDomainXMLOptionPtr xmlopt,
1055                          virDomainObjPtr vm,
1056                          virDomainChrSourceDefPtr src)
1057 {
1058     qemuMonitorTestPtr test = NULL;
1059     char *path = NULL;
1060     char *tmpdir_template = NULL;
1061
1062     if (VIR_ALLOC(test) < 0)
1063         goto error;
1064
1065     if (virMutexInit(&test->lock) < 0) {
1066         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1067                        "Cannot initialize mutex");
1068         VIR_FREE(test);
1069         return NULL;
1070     }
1071
1072     if (VIR_STRDUP(tmpdir_template, "/tmp/libvirt_XXXXXX") < 0)
1073         goto error;
1074
1075     if (!(test->tmpdir = mkdtemp(tmpdir_template))) {
1076         virReportSystemError(errno, "%s",
1077                              "Failed to create temporary directory");
1078         goto error;
1079     }
1080
1081     tmpdir_template = NULL;
1082
1083     if (virAsprintf(&path, "%s/qemumonitorjsontest.sock", test->tmpdir) < 0)
1084         goto error;
1085
1086     if (vm) {
1087         test->vm = virObjectRef(vm);
1088     } else {
1089         test->vm = virDomainObjNew(xmlopt);
1090         if (!test->vm)
1091             goto error;
1092     }
1093
1094     if (virNetSocketNewListenUNIX(path, 0700, geteuid(), getegid(),
1095                                   &test->server) < 0)
1096         goto error;
1097
1098     memset(src, 0, sizeof(*src));
1099     src->type = VIR_DOMAIN_CHR_TYPE_UNIX;
1100     src->data.nix.path = (char *)path;
1101     src->data.nix.listen = false;
1102     path = NULL;
1103
1104     if (virNetSocketListen(test->server, 1) < 0)
1105         goto error;
1106
1107  cleanup:
1108     return test;
1109
1110  error:
1111     VIR_FREE(path);
1112     VIR_FREE(tmpdir_template);
1113     qemuMonitorTestFree(test);
1114     test = NULL;
1115     goto cleanup;
1116
1117 }
1118
1119
1120 static int
1121 qemuMonitorCommonTestInit(qemuMonitorTestPtr test)
1122 {
1123     int events = VIR_EVENT_HANDLE_READABLE;
1124
1125     if (!test)
1126         return -1;
1127
1128     if (virNetSocketAccept(test->server, &test->client) < 0)
1129         goto error;
1130
1131     if (!test->client)
1132         goto error;
1133
1134     if (test->outgoingLength > 0)
1135         events = VIR_EVENT_HANDLE_WRITABLE;
1136
1137     if (virNetSocketAddIOCallback(test->client,
1138                                   events,
1139                                   qemuMonitorTestIO,
1140                                   test,
1141                                   NULL) < 0)
1142         goto error;
1143
1144     virMutexLock(&test->lock);
1145     if (virThreadCreate(&test->thread,
1146                         true,
1147                         qemuMonitorTestWorker,
1148                         test) < 0) {
1149         virMutexUnlock(&test->lock);
1150         goto error;
1151     }
1152     test->started = test->running = true;
1153     virMutexUnlock(&test->lock);
1154
1155     return 0;
1156
1157  error:
1158     return -1;
1159 }
1160
1161
1162 #define QEMU_JSON_GREETING  "{\"QMP\":"\
1163                             "   {\"version\":"\
1164                             "       {\"qemu\":"\
1165                             "           {\"micro\": 1,"\
1166                             "            \"minor\": 0,"\
1167                             "            \"major\": 1"\
1168                             "           },"\
1169                             "        \"package\": \"(qemu-kvm-1.0.1)"\
1170                             "       \"},"\
1171                             "    \"capabilities\": []"\
1172                             "   }"\
1173                             "}"
1174 /* We skip the normal handshake reply of "{\"execute\":\"qmp_capabilities\"}" */
1175
1176 qemuMonitorTestPtr
1177 qemuMonitorTestNew(virDomainXMLOptionPtr xmlopt,
1178                    virDomainObjPtr vm,
1179                    virQEMUDriverPtr driver,
1180                    const char *greeting,
1181                    virHashTablePtr schema)
1182 {
1183     qemuMonitorTestPtr test = NULL;
1184     virDomainChrSourceDef src;
1185
1186     memset(&src, 0, sizeof(src));
1187
1188     if (!(test = qemuMonitorCommonTestNew(xmlopt, vm, &src)))
1189         goto error;
1190
1191     test->qapischema = schema;
1192     if (!(test->mon = qemuMonitorOpen(test->vm,
1193                                       &src,
1194                                       true,
1195                                       0,
1196                                       &qemuMonitorTestCallbacks,
1197                                       driver)))
1198         goto error;
1199
1200     virObjectLock(test->mon);
1201
1202     if (!greeting)
1203         greeting = QEMU_JSON_GREETING;
1204
1205     if (qemuMonitorTestAddResponse(test, greeting) < 0)
1206         goto error;
1207
1208     if (qemuMonitorCommonTestInit(test) < 0)
1209         goto error;
1210
1211     virDomainChrSourceDefClear(&src);
1212
1213     return test;
1214
1215  error:
1216     virDomainChrSourceDefClear(&src);
1217     qemuMonitorTestFree(test);
1218     return NULL;
1219 }
1220
1221
1222 /**
1223  * qemuMonitorTestNewFromFile:
1224  * @fileName: File name to load monitor replies from
1225  * @xmlopt: XML parser configuration object
1226  * @simple: see below
1227  *
1228  * Create a JSON test monitor simulator object and fill it with replies
1229  * specified in @fileName. The file contains JSON reply objects separated by
1230  * empty lines. If @simple is true a generic QMP greeting is automatically
1231  * added as the first reply, otherwise the first entry in the file is used.
1232  *
1233  * Returns the monitor object on success; NULL on error.
1234  */
1235 qemuMonitorTestPtr
1236 qemuMonitorTestNewFromFile(const char *fileName,
1237                            virDomainXMLOptionPtr xmlopt,
1238                            bool simple)
1239 {
1240     qemuMonitorTestPtr test = NULL;
1241     char *json = NULL;
1242     char *tmp;
1243     char *singleReply;
1244
1245     if (virTestLoadFile(fileName, &json) < 0)
1246         goto cleanup;
1247
1248     if (simple && !(test = qemuMonitorTestNewSimple(xmlopt)))
1249         goto cleanup;
1250
1251     /* Our JSON parser expects replies to be separated by a newline character.
1252      * Hence we must preprocess the file a bit. */
1253     tmp = singleReply = json;
1254     while ((tmp = strchr(tmp, '\n'))) {
1255         /* It is safe to touch tmp[1] since all strings ends with '\0'. */
1256         bool eof = !tmp[1];
1257
1258         if (*(tmp + 1) != '\n') {
1259             *tmp = ' ';
1260             tmp++;
1261         } else {
1262             /* Cut off a single reply. */
1263             *(tmp + 1) = '\0';
1264
1265             if (test) {
1266                 if (qemuMonitorTestAddItem(test, NULL, singleReply) < 0)
1267                     goto error;
1268             } else {
1269                 /* Create new mocked monitor with our greeting */
1270                 if (!(test = qemuMonitorTestNew(xmlopt, NULL, NULL,
1271                                                 singleReply, NULL)))
1272                     goto error;
1273             }
1274
1275             if (!eof) {
1276                 /* Move the @tmp and @singleReply. */
1277                 tmp += 2;
1278                 singleReply = tmp;
1279             }
1280         }
1281
1282         if (eof)
1283             break;
1284     }
1285
1286     if (test && qemuMonitorTestAddItem(test, NULL, singleReply) < 0)
1287         goto error;
1288
1289  cleanup:
1290     VIR_FREE(json);
1291     return test;
1292
1293  error:
1294     qemuMonitorTestFree(test);
1295     test = NULL;
1296     goto cleanup;
1297 }
1298
1299
1300 static int
1301 qemuMonitorTestFullAddItem(qemuMonitorTestPtr test,
1302                            const char *filename,
1303                            const char *command,
1304                            const char *response,
1305                            size_t line)
1306 {
1307     char *cmderr;
1308     int ret;
1309
1310     if (virAsprintf(&cmderr, "wrong expected command in %s:%zu: ",
1311                     filename, line) < 0)
1312         return -1;
1313
1314     ret = qemuMonitorTestAddItemVerbatim(test, command, cmderr, response);
1315
1316     VIR_FREE(cmderr);
1317     return ret;
1318 }
1319
1320
1321 /**
1322  * qemuMonitorTestNewFromFileFull:
1323  * @fileName: File name to load monitor replies from
1324  * @driver: qemu driver object
1325  * @vm: domain object (may be null if it's not needed by the test)
1326  * @qmpschema: QMP schema data hash table if QMP checking is required
1327  *
1328  * Create a JSON test monitor simulator object and fill it with expected command
1329  * sequence and replies specified in @fileName.
1330  *
1331  * The file contains a sequence of JSON commands and reply objects separated by
1332  * empty lines. A command is followed by a reply. The QMP greeting is added
1333  * automatically.
1334  *
1335  * Returns the monitor object on success; NULL on error.
1336  */
1337 qemuMonitorTestPtr
1338 qemuMonitorTestNewFromFileFull(const char *fileName,
1339                                virQEMUDriverPtr driver,
1340                                virDomainObjPtr vm,
1341                                virHashTablePtr qmpschema)
1342 {
1343     qemuMonitorTestPtr ret = NULL;
1344     char *jsonstr = NULL;
1345     char *tmp;
1346     size_t line = 0;
1347
1348     char *command = NULL;
1349     char *response = NULL;
1350     size_t commandln = 0;
1351
1352     if (virTestLoadFile(fileName, &jsonstr) < 0)
1353         return NULL;
1354
1355     if (!(ret = qemuMonitorTestNew(driver->xmlopt, vm, driver, NULL,
1356                                    qmpschema)))
1357         goto cleanup;
1358
1359     tmp = jsonstr;
1360     command = tmp;
1361     while ((tmp = strchr(tmp, '\n'))) {
1362         line++;
1363
1364         /* eof */
1365         if (!tmp[1])
1366             break;
1367
1368         /* concatenate block which was broken up for readability */
1369         if (*(tmp + 1) != '\n') {
1370             *tmp = ' ';
1371             tmp++;
1372             continue;
1373         }
1374
1375         /* Cut off a single reply. */
1376         *(tmp + 1) = '\0';
1377
1378         if (response) {
1379             if (qemuMonitorTestFullAddItem(ret, fileName, command,
1380                                            response, commandln) < 0)
1381                 goto error;
1382             command = NULL;
1383             response = NULL;
1384         }
1385
1386         /* Move the @tmp and @singleReply. */
1387         tmp += 2;
1388
1389         if (!command) {
1390             commandln = line;
1391             command = tmp;
1392         } else {
1393             response = tmp;
1394         }
1395     }
1396
1397     if (command) {
1398         if (!response) {
1399             virReportError(VIR_ERR_INTERNAL_ERROR, "missing response for command "
1400                            "on line '%zu' in '%s'", commandln, fileName);
1401             goto error;
1402         }
1403
1404         if (qemuMonitorTestFullAddItem(ret, fileName, command,
1405                                        response, commandln) < 0)
1406             goto error;
1407     }
1408
1409  cleanup:
1410     VIR_FREE(jsonstr);
1411     return ret;
1412
1413  error:
1414     qemuMonitorTestFree(ret);
1415     ret = NULL;
1416     goto cleanup;
1417 }
1418
1419
1420 qemuMonitorTestPtr
1421 qemuMonitorTestNewAgent(virDomainXMLOptionPtr xmlopt)
1422 {
1423     qemuMonitorTestPtr test = NULL;
1424     virDomainChrSourceDef src;
1425
1426     memset(&src, 0, sizeof(src));
1427
1428     if (!(test = qemuMonitorCommonTestNew(xmlopt, NULL, &src)))
1429         goto error;
1430
1431     if (!(test->agent = qemuAgentOpen(test->vm,
1432                                       &src,
1433                                       &qemuMonitorTestAgentCallbacks)))
1434         goto error;
1435
1436     virObjectLock(test->agent);
1437
1438     if (qemuMonitorCommonTestInit(test) < 0)
1439         goto error;
1440
1441     virDomainChrSourceDefClear(&src);
1442
1443     return test;
1444
1445  error:
1446     virDomainChrSourceDefClear(&src);
1447     qemuMonitorTestFree(test);
1448     return NULL;
1449 }
1450
1451
1452 qemuMonitorPtr
1453 qemuMonitorTestGetMonitor(qemuMonitorTestPtr test)
1454 {
1455     return test->mon;
1456 }
1457
1458
1459 qemuAgentPtr
1460 qemuMonitorTestGetAgent(qemuMonitorTestPtr test)
1461 {
1462     return test->agent;
1463 }
1464
1465
1466 virDomainObjPtr
1467 qemuMonitorTestGetDomainObj(qemuMonitorTestPtr test)
1468 {
1469     return test->vm;
1470 }