[libvirt] [PATCH 19/21] Start of support for QEMU JSON based monitor protocol

Import a JSON parsing / formatting code from http://mjson.sourceforge.net/ with some API changes to better cope with libvirt's needs. Then add basic implementation of the JSON monitor for QEMU driver. * src/util/json.c, src/util/json.h: Import code for simple JSON parsing & formatting * src/libvirt_private.syms: Include all json parser symbols * src/qemu/qemu_conf.c: Support for settin 'control' attribute to turn on JSON protocol mode * src/qemu/qemu_monitor.c: Conditionally call either Text or JSON monitor command serialization code as appropriate * src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h: new JSON based command serialization code --- src/Makefile.am | 3 + src/libvirt_private.syms | 10 + src/qemu/qemu_conf.c | 13 +- src/qemu/qemu_conf.h | 3 + src/qemu/qemu_monitor.c | 202 ++- src/qemu/qemu_monitor_json.c | 797 +++++++++ src/qemu/qemu_monitor_json.h | 155 ++ src/util/json.c | 3904 ++++++++++++++++++++++++++++++++++++++++++ src/util/json.h | 311 ++++ 9 files changed, 5350 insertions(+), 48 deletions(-) create mode 100644 src/qemu/qemu_monitor_json.c create mode 100644 src/qemu/qemu_monitor_json.h create mode 100644 src/util/json.c create mode 100644 src/util/json.h diff --git a/src/Makefile.am b/src/Makefile.am index 9ed9bc3..b87e615 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -51,6 +51,7 @@ UTIL_SOURCES = \ util/event.c util/event.h \ util/hash.c util/hash.h \ util/iptables.c util/iptables.h \ + util/json.c util/json.h \ util/logging.c util/logging.h \ util/memory.c util/memory.h \ util/pci.c util/pci.h \ @@ -184,6 +185,8 @@ QEMU_DRIVER_SOURCES = \ qemu/qemu_monitor.c qemu/qemu_monitor.h \ qemu/qemu_monitor_text.c \ qemu/qemu_monitor_text.h \ + qemu/qemu_monitor_json.c \ + qemu/qemu_monitor_json.h \ qemu/qemu_driver.c qemu/qemu_driver.h UML_DRIVER_SOURCES = \ diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 4f2f048..f0809f8 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -260,6 +260,16 @@ virRegisterDeviceMonitor; virRegisterSecretDriver; +# json.h +json_tree_to_string; +json_parse_document; +json_new_string; +json_new_object; +json_free_value; +json_insert_pair_into_object; +json_find_first_label; + + # logging.h virLogMessage; virLogGetNbFilters; diff --git a/src/qemu/qemu_conf.c b/src/qemu/qemu_conf.c index 951a6c6..16bde05 100644 --- a/src/qemu/qemu_conf.c +++ b/src/qemu/qemu_conf.c @@ -1748,10 +1748,18 @@ int qemudBuildCommandLine(virConnectPtr conn, ADD_ARG_LIT("-nographic"); if (monitor_chr) { + /* XXX gross hack for testing */ +#if QEMU_WITH_JSON + char buf[4096] = "control,"; + + if (qemudBuildCommandLineChrDevStr(monitor_chr, buf + 8, sizeof(buf)-8) < 0) + goto error; +#else char buf[4096]; - if (qemudBuildCommandLineChrDevStr(monitor_chr, buf, sizeof(buf)) < 0) + if (qemudBuildCommandLineChrDevStr(monitor_chr, buf, sizeof(buf)-8) < 0) goto error; +#endif ADD_ARG_LIT("-monitor"); ADD_ARG_LIT(buf); @@ -1885,7 +1893,8 @@ int qemudBuildCommandLine(virConnectPtr conn, break; } - virBufferVSprintf(&opt, "file=%s", disk->src ? disk->src : ""); + if (disk->src) + virBufferVSprintf(&opt, "file=%s", disk->src ? disk->src : ""); virBufferVSprintf(&opt, ",if=%s", bus); if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) virBufferAddLit(&opt, ",media=cdrom"); diff --git a/src/qemu/qemu_conf.h b/src/qemu/qemu_conf.h index a6e68f8..65c6489 100644 --- a/src/qemu/qemu_conf.h +++ b/src/qemu/qemu_conf.h @@ -39,6 +39,9 @@ #define qemudDebug(fmt, ...) do {} while(0) +/* XXX gross hack for testing purposes */ +#define QEMU_WITH_JSON 0 + #define QEMUD_CPUMASK_LEN CPU_SETSIZE /* Internal flags to keep track of qemu command line capabilities */ diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c index fb89f9d..875d339 100644 --- a/src/qemu/qemu_monitor.c +++ b/src/qemu/qemu_monitor.c @@ -30,6 +30,7 @@ #include "qemu_monitor.h" #include "qemu_monitor_text.h" +#include "qemu_monitor_json.h" #include "qemu_conf.h" #include "event.h" #include "virterror_internal.h" @@ -71,6 +72,8 @@ struct _qemuMonitor { unsigned eofcb: 1; /* If the monitor callback should free the closed monitor */ unsigned closed: 1; + + unsigned json: 1; }; static void qemuMonitorLock(qemuMonitorPtr mon) @@ -180,9 +183,14 @@ qemuMonitorIOProcess(qemuMonitorPtr mon) msg = mon->msg; VIR_DEBUG("Process %d", mon->bufferOffset); - len = qemuMonitorTextIOProcess(mon, - mon->buffer, mon->bufferOffset, - msg); + if (mon->json) + len = qemuMonitorJSONIOProcess(mon, + mon->buffer, mon->bufferOffset, + msg); + else + len = qemuMonitorTextIOProcess(mon, + mon->buffer, mon->bufferOffset, + msg); if (len < 0) { mon->lastErrno = errno; @@ -455,6 +463,7 @@ qemuMonitorOpen(virDomainObjPtr vm, mon->fd = -1; mon->vm = vm; mon->eofCB = eofCB; + mon->json = QEMU_WITH_JSON; qemuMonitorLock(mon); switch (vm->monitor_chr->type) { @@ -594,7 +603,10 @@ qemuMonitorStartCPUs(qemuMonitorPtr mon, qemuMonitorLock(mon); DEBUG("mon=%p, fd=%d", mon, mon->fd); - ret = qemuMonitorTextStartCPUs(mon, conn); + if (mon->json) + ret = qemuMonitorJSONStartCPUs(mon, conn); + else + ret = qemuMonitorTextStartCPUs(mon, conn); qemuMonitorUnlock(mon); return ret; } @@ -606,7 +618,10 @@ qemuMonitorStopCPUs(qemuMonitorPtr mon) { qemuMonitorLock(mon); DEBUG("mon=%p, fd=%d", mon, mon->fd); - ret = qemuMonitorTextStopCPUs(mon); + if (mon->json) + ret = qemuMonitorJSONStopCPUs(mon); + else + ret = qemuMonitorTextStopCPUs(mon); qemuMonitorUnlock(mon); return ret; } @@ -617,7 +632,10 @@ int qemuMonitorSystemPowerdown(qemuMonitorPtr mon) { qemuMonitorLock(mon); DEBUG("mon=%p, fd=%d", mon, mon->fd); - ret = qemuMonitorTextSystemPowerdown(mon); + if (mon->json) + ret = qemuMonitorJSONSystemPowerdown(mon); + else + ret = qemuMonitorTextSystemPowerdown(mon); qemuMonitorUnlock(mon); return ret; } @@ -630,7 +648,10 @@ int qemuMonitorGetCPUInfo(qemuMonitorPtr mon, qemuMonitorLock(mon); DEBUG("mon=%p, fd=%d", mon, mon->fd); - ret = qemuMonitorTextGetCPUInfo(mon, pids); + if (mon->json) + ret = qemuMonitorJSONGetCPUInfo(mon, pids); + else + ret = qemuMonitorTextGetCPUInfo(mon, pids); qemuMonitorUnlock(mon); return ret; } @@ -642,7 +663,10 @@ int qemuMonitorGetBalloonInfo(qemuMonitorPtr mon, qemuMonitorLock(mon); DEBUG("mon=%p, fd=%d", mon, mon->fd); - ret = qemuMonitorTextGetBalloonInfo(mon, currmem); + if (mon->json) + ret = qemuMonitorJSONGetBalloonInfo(mon, currmem); + else + ret = qemuMonitorTextGetBalloonInfo(mon, currmem); qemuMonitorUnlock(mon); return ret; } @@ -660,10 +684,16 @@ int qemuMonitorGetBlockStatsInfo(qemuMonitorPtr mon, qemuMonitorLock(mon); DEBUG("mon=%p, fd=%d dev=%s", mon, mon->fd, devname); - ret = qemuMonitorTextGetBlockStatsInfo(mon, devname, - rd_req, rd_bytes, - wr_req, wr_bytes, - errs); + if (mon->json) + ret = qemuMonitorJSONGetBlockStatsInfo(mon, devname, + rd_req, rd_bytes, + wr_req, wr_bytes, + errs); + else + ret = qemuMonitorTextGetBlockStatsInfo(mon, devname, + rd_req, rd_bytes, + wr_req, wr_bytes, + errs); qemuMonitorUnlock(mon); return ret; } @@ -676,7 +706,10 @@ int qemuMonitorSetVNCPassword(qemuMonitorPtr mon, qemuMonitorLock(mon); DEBUG("mon=%p, fd=%d", mon, mon->fd); - ret = qemuMonitorTextSetVNCPassword(mon, password); + if (mon->json) + ret = qemuMonitorJSONSetVNCPassword(mon, password); + else + ret = qemuMonitorTextSetVNCPassword(mon, password); qemuMonitorUnlock(mon); return ret; } @@ -689,7 +722,10 @@ int qemuMonitorSetBalloon(qemuMonitorPtr mon, qemuMonitorLock(mon); DEBUG("mon=%p, fd=%d newmem=%lu", mon, mon->fd, newmem); - ret = qemuMonitorTextSetBalloon(mon, newmem); + if (mon->json) + ret = qemuMonitorJSONSetBalloon(mon, newmem); + else + ret = qemuMonitorTextSetBalloon(mon, newmem); qemuMonitorUnlock(mon); return ret; } @@ -701,7 +737,10 @@ int qemuMonitorEjectMedia(qemuMonitorPtr mon, qemuMonitorLock(mon); DEBUG("mon=%p, fd=%d devname=%s", mon, mon->fd, devname); - ret = qemuMonitorTextEjectMedia(mon, devname); + if (mon->json) + ret = qemuMonitorJSONEjectMedia(mon, devname); + else + ret = qemuMonitorTextEjectMedia(mon, devname); qemuMonitorUnlock(mon); return ret; } @@ -716,7 +755,10 @@ int qemuMonitorChangeMedia(qemuMonitorPtr mon, DEBUG("mon=%p, fd=%d devname=%s newmedia=%s", mon, mon->fd, devname, newmedia); - ret = qemuMonitorTextChangeMedia(mon, devname, newmedia); + if (mon->json) + ret = qemuMonitorJSONChangeMedia(mon, devname, newmedia); + else + ret = qemuMonitorTextChangeMedia(mon, devname, newmedia); qemuMonitorUnlock(mon); return ret; } @@ -732,7 +774,10 @@ int qemuMonitorSaveVirtualMemory(qemuMonitorPtr mon, DEBUG("mon=%p, fd=%d offset=%llu length=%zu path=%s", mon, mon->fd, offset, length, path); - ret = qemuMonitorTextSaveVirtualMemory(mon, offset, length, path); + if (mon->json) + ret = qemuMonitorJSONSaveVirtualMemory(mon, offset, length, path); + else + ret = qemuMonitorTextSaveVirtualMemory(mon, offset, length, path); qemuMonitorUnlock(mon); return ret; } @@ -747,7 +792,10 @@ int qemuMonitorSavePhysicalMemory(qemuMonitorPtr mon, DEBUG("mon=%p, fd=%d offset=%llu length=%zu path=%s", mon, mon->fd, offset, length, path); - ret = qemuMonitorTextSavePhysicalMemory(mon, offset, length, path); + if (mon->json) + ret = qemuMonitorJSONSavePhysicalMemory(mon, offset, length, path); + else + ret = qemuMonitorTextSavePhysicalMemory(mon, offset, length, path); qemuMonitorUnlock(mon); return ret; } @@ -760,7 +808,10 @@ int qemuMonitorSetMigrationSpeed(qemuMonitorPtr mon, qemuMonitorLock(mon); DEBUG("mon=%p, fd=%d bandwidth=%lu", mon, mon->fd, bandwidth); - ret = qemuMonitorTextSetMigrationSpeed(mon, bandwidth); + if (mon->json) + ret = qemuMonitorJSONSetMigrationSpeed(mon, bandwidth); + else + ret = qemuMonitorTextSetMigrationSpeed(mon, bandwidth); qemuMonitorUnlock(mon); return ret; } @@ -775,10 +826,16 @@ int qemuMonitorGetMigrationStatus(qemuMonitorPtr mon, qemuMonitorLock(mon); DEBUG("mon=%p, fd=%d", mon, mon->fd); - ret = qemuMonitorTextGetMigrationStatus(mon, status, - transferred, - remaining, - total); + if (mon->json) + ret = qemuMonitorJSONGetMigrationStatus(mon, status, + transferred, + remaining, + total); + else + ret = qemuMonitorTextGetMigrationStatus(mon, status, + transferred, + remaining, + total); qemuMonitorUnlock(mon); return ret; } @@ -794,7 +851,10 @@ int qemuMonitorMigrateToHost(qemuMonitorPtr mon, DEBUG("mon=%p, fd=%d hostname=%s port=%d", mon, mon->fd, hostname, port); - ret = qemuMonitorTextMigrateToHost(mon, background, hostname, port); + if (mon->json) + ret = qemuMonitorJSONMigrateToHost(mon, background, hostname, port); + else + ret = qemuMonitorTextMigrateToHost(mon, background, hostname, port); qemuMonitorUnlock(mon); return ret; } @@ -810,7 +870,10 @@ int qemuMonitorMigrateToCommand(qemuMonitorPtr mon, DEBUG("mon=%p, fd=%d argv=%p target=%s", mon, mon->fd, argv, target); - ret = qemuMonitorTextMigrateToCommand(mon, background, argv, target); + if (mon->json) + ret = qemuMonitorJSONMigrateToCommand(mon, background, argv, target); + else + ret = qemuMonitorTextMigrateToCommand(mon, background, argv, target); qemuMonitorUnlock(mon); return ret; } @@ -824,7 +887,10 @@ int qemuMonitorMigrateToUnix(qemuMonitorPtr mon, DEBUG("mon=%p fd=%d unixfile=%s", mon, mon->fd, unixfile); - ret = qemuMonitorTextMigrateToUnix(mon, background, unixfile); + if (mon->json) + ret = qemuMonitorJSONMigrateToUnix(mon, background, unixfile); + else + ret = qemuMonitorTextMigrateToUnix(mon, background, unixfile); qemuMonitorUnlock(mon); return ret; } @@ -835,7 +901,10 @@ int qemuMonitorMigrateCancel(qemuMonitorPtr mon) qemuMonitorLock(mon); DEBUG("mon=%p fd=%d", mon, mon->fd); - ret = qemuMonitorTextMigrateCancel(mon); + if (mon->json) + ret = qemuMonitorJSONMigrateCancel(mon); + else + ret = qemuMonitorTextMigrateCancel(mon); qemuMonitorUnlock(mon); return ret; } @@ -847,7 +916,10 @@ int qemuMonitorAddUSBDisk(qemuMonitorPtr mon, qemuMonitorLock(mon); DEBUG("mon=%p, fd=%d path=%s", mon, mon->fd, path); - ret = qemuMonitorTextAddUSBDisk(mon, path); + if (mon->json) + ret = qemuMonitorJSONAddUSBDisk(mon, path); + else + ret = qemuMonitorTextAddUSBDisk(mon, path); qemuMonitorUnlock(mon); return ret; } @@ -861,7 +933,10 @@ int qemuMonitorAddUSBDeviceExact(qemuMonitorPtr mon, qemuMonitorLock(mon); DEBUG("mon=%p, fd=%d bus=%d dev=%d", mon, mon->fd, bus, dev); - ret = qemuMonitorTextAddUSBDeviceExact(mon, bus, dev); + if (mon->json) + ret = qemuMonitorJSONAddUSBDeviceExact(mon, bus, dev); + else + ret = qemuMonitorTextAddUSBDeviceExact(mon, bus, dev); qemuMonitorUnlock(mon); return ret; } @@ -875,7 +950,10 @@ int qemuMonitorAddUSBDeviceMatch(qemuMonitorPtr mon, DEBUG("mon=%p, fd=%d vendor=%d product=%d", mon, mon->fd, vendor, product); - ret = qemuMonitorTextAddUSBDeviceMatch(mon, vendor, product); + if (mon->json) + ret = qemuMonitorJSONAddUSBDeviceMatch(mon, vendor, product); + else + ret = qemuMonitorTextAddUSBDeviceMatch(mon, vendor, product); qemuMonitorUnlock(mon); return ret; } @@ -896,12 +974,20 @@ int qemuMonitorAddPCIHostDevice(qemuMonitorPtr mon, mon, mon->fd, hostDomain, hostBus, hostSlot, hostFunction); - ret = qemuMonitorTextAddPCIHostDevice(mon, hostDomain, - hostBus, hostSlot, - hostFunction, - guestDomain, - guestBus, - guestSlot); + if (mon->json) + ret = qemuMonitorJSONAddPCIHostDevice(mon, hostDomain, + hostBus, hostSlot, + hostFunction, + guestDomain, + guestBus, + guestSlot); + else + ret = qemuMonitorTextAddPCIHostDevice(mon, hostDomain, + hostBus, hostSlot, + hostFunction, + guestDomain, + guestBus, + guestSlot); qemuMonitorUnlock(mon); return ret; } @@ -919,8 +1005,12 @@ int qemuMonitorAddPCIDisk(qemuMonitorPtr mon, DEBUG("mon=%p, fd=%d path=%s bus=%s", mon, mon->fd, path, bus); - ret = qemuMonitorTextAddPCIDisk(mon, path, bus, - guestDomain, guestBus, guestSlot); + if (mon->json) + ret = qemuMonitorJSONAddPCIDisk(mon, path, bus, + guestDomain, guestBus, guestSlot); + else + ret = qemuMonitorTextAddPCIDisk(mon, path, bus, + guestDomain, guestBus, guestSlot); qemuMonitorUnlock(mon); return ret; } @@ -936,8 +1026,12 @@ int qemuMonitorAddPCINetwork(qemuMonitorPtr mon, qemuMonitorLock(mon); DEBUG("mon=%p, fd=%d nicstr=%s", mon, mon->fd, nicstr); - ret = qemuMonitorTextAddPCINetwork(mon, nicstr, guestDomain, - guestBus, guestSlot); + if (mon->json) + ret = qemuMonitorJSONAddPCINetwork(mon, nicstr, guestDomain, + guestBus, guestSlot); + else + ret = qemuMonitorTextAddPCINetwork(mon, nicstr, guestDomain, + guestBus, guestSlot); qemuMonitorUnlock(mon); return ret; } @@ -953,8 +1047,12 @@ int qemuMonitorRemovePCIDevice(qemuMonitorPtr mon, DEBUG("mon=%p, fd=%d domain=%d bus=%d slot=%d", mon, mon->fd, guestDomain, guestBus, guestSlot); - ret = qemuMonitorTextRemovePCIDevice(mon, guestDomain, - guestBus, guestSlot); + if (mon->json) + ret = qemuMonitorJSONRemovePCIDevice(mon, guestDomain, + guestBus, guestSlot); + else + ret = qemuMonitorTextRemovePCIDevice(mon, guestDomain, + guestBus, guestSlot); qemuMonitorUnlock(mon); return ret; } @@ -969,7 +1067,10 @@ int qemuMonitorSendFileHandle(qemuMonitorPtr mon, DEBUG("mon=%p, fd=%d fdname=%s fd=%d", mon, mon->fd, fdname, fd); - ret = qemuMonitorTextSendFileHandle(mon, fdname, fd); + if (mon->json) + ret = qemuMonitorJSONSendFileHandle(mon, fdname, fd); + else + ret = qemuMonitorTextSendFileHandle(mon, fdname, fd); qemuMonitorUnlock(mon); return ret; } @@ -983,7 +1084,10 @@ int qemuMonitorCloseFileHandle(qemuMonitorPtr mon, DEBUG("mon=%p, fd=%d fdname=%s", mon, mon->fd, fdname); - ret = qemuMonitorTextCloseFileHandle(mon, fdname); + if (mon->json) + ret = qemuMonitorJSONCloseFileHandle(mon, fdname); + else + ret = qemuMonitorTextCloseFileHandle(mon, fdname); qemuMonitorUnlock(mon); return ret; } @@ -997,7 +1101,10 @@ int qemuMonitorAddHostNetwork(qemuMonitorPtr mon, DEBUG("mon=%p, fd=%d netstr=%s", mon, mon->fd, netstr); - ret = qemuMonitorTextAddHostNetwork(mon, netstr); + if (mon->json) + ret = qemuMonitorJSONAddHostNetwork(mon, netstr); + else + ret = qemuMonitorTextAddHostNetwork(mon, netstr); qemuMonitorUnlock(mon); return ret; } @@ -1012,7 +1119,10 @@ int qemuMonitorRemoveHostNetwork(qemuMonitorPtr mon, DEBUG("mon=%p, fd=%d netname=%s", mon, mon->fd, netname); - ret = qemuMonitorTextRemoveHostNetwork(mon, vlan, netname); + if (mon->json) + ret = qemuMonitorJSONRemoveHostNetwork(mon, vlan, netname); + else + ret = qemuMonitorTextRemoveHostNetwork(mon, vlan, netname); qemuMonitorUnlock(mon); return ret; } diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c new file mode 100644 index 0000000..d23569c --- /dev/null +++ b/src/qemu/qemu_monitor_json.c @@ -0,0 +1,797 @@ +/* + * qemu_monitor_json.c: interaction with QEMU monitor console + * + * Copyright (C) 2006-2009 Red Hat, Inc. + * Copyright (C) 2006 Daniel P. Berrange + * + * 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 + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Daniel P. Berrange <berrange(a)redhat.com&gt; + */ + +#include <config.h> + +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/un.h> +#include <poll.h> +#include <unistd.h> +#include <string.h> + +#include "qemu_monitor_json.h" +#include "qemu_conf.h" +#include "c-ctype.h" +#include "memory.h" +#include "logging.h" +#include "driver.h" +#include "datatypes.h" +#include "virterror_internal.h" +#include "json.h" + +#define VIR_FROM_THIS VIR_FROM_QEMU + + +#define LINE_ENDING "\r\n" + +static int +qemuMonitorJSONIOProcessLine(qemuMonitorPtr mon ATTRIBUTE_UNUSED, + const char *line, + qemuMonitorMessagePtr msg) +{ + json_t *obj = NULL; + json_t *val; + int ret = -1; + + VIR_DEBUG("Line [%s]", line); + + if (json_parse_document(&obj, line) != JSON_OK) { + VIR_DEBUG0("Parsing JSON string failed"); + errno = EINVAL; + goto cleanup; + } + + if (obj->type != JSON_OBJECT) { + VIR_DEBUG0("Parsed JSON string isn't an object"); + errno = EINVAL; + } + + if (json_find_first_label(obj, "QMP", &val) == JSON_OK) { + VIR_DEBUG0("Got QMP capabilities data"); + ret = 0; + goto cleanup; + } + + if (json_find_first_label(obj, "event", &val) == JSON_OK) { + VIR_DEBUG0("Got an event"); + ret = 0; + goto cleanup; + } + + if (msg) { + msg->rxBuffer = strdup(line); + msg->rxLength = strlen(line); + msg->finished = 1; + } else { + VIR_DEBUG("Ignoring unexpected JSON message [%s]", line); + } + + ret = 0; + +cleanup: + if (obj) + json_free_value(&obj); + return ret; +} + +int qemuMonitorJSONIOProcess(qemuMonitorPtr mon, + const char *data, + size_t len, + qemuMonitorMessagePtr msg) +{ + int used = 0; + VIR_DEBUG("Data %d bytes [%s]", len, data); + + while (used < len) { + char *nl = strstr(data + used, LINE_ENDING); + + if (nl) { + int got = nl - (data + used); + char *line = strndup(data + used, got); + used += got + strlen(LINE_ENDING); + + if (qemuMonitorJSONIOProcessLine(mon, line, msg) < 0) { + VIR_FREE(line); + return -1; + } + + VIR_FREE(line); + } else { + break; + } + } + + VIR_DEBUG("Total used %d", used); + return used; +} + +static int +qemuMonitorCommandWithFd(qemuMonitorPtr mon, + json_t *cmd, + int scm_fd, + json_t **reply) +{ + int ret = -1; + qemuMonitorMessage msg; + char *cmdstr = NULL; + + *reply = NULL; + + memset(&msg, 0, sizeof msg); + + if (json_tree_to_string(cmd, &cmdstr) != JSON_OK) { + virReportOOMError(NULL); + goto cleanup; + } + if (virAsprintf(&msg.txBuffer, "%s\r\n", cmdstr) < 0) { + virReportOOMError(NULL); + goto cleanup; + } + msg.txLength = strlen(msg.txBuffer); + msg.txFD = scm_fd; + + VIR_DEBUG("Send command '%s' for write with FD %d", cmdstr, scm_fd); + + ret = qemuMonitorSend(mon, &msg); + + VIR_DEBUG("Receive command reply ret=%d errno=%d %d bytes '%s'", + ret, msg.lastErrno, msg.rxLength, msg.rxBuffer); + + + /* To make life safer for callers, already ensure there's at least an empty string */ + if (msg.rxBuffer && ret == 0) { + if (json_parse_document(reply, msg.rxBuffer) != JSON_OK) { + qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR, + _("cannot parse JSON doc '%s'"), msg.rxBuffer); + goto cleanup; + } + } + + if (ret < 0) + virReportSystemError(NULL, msg.lastErrno, + _("cannot send monitor command '%s'"), cmdstr); + +cleanup: + VIR_FREE(cmdstr); + VIR_FREE(msg.txBuffer); + VIR_FREE(msg.rxBuffer); + + return ret; +} + + +static int +qemuMonitorCommand(qemuMonitorPtr mon, + json_t *cmd, + json_t **reply) { + return qemuMonitorCommandWithFd(mon, cmd, -1, reply); +} + + +static json_t * +qemuMonitorJSONMakeCommand(const char *cmdname, + json_t *args) +{ + json_t *obj, *tmp = NULL; + if (!(obj = json_new_object())) + goto no_memory; + + if (!(tmp = json_new_string(cmdname))) + goto no_memory; + + if (json_insert_pair_into_object(obj, "execute", tmp) != JSON_OK) + goto no_memory; + tmp = NULL; + + if (args && + json_insert_pair_into_object(obj, "arguments", args) != JSON_OK) + goto no_memory; + + return obj; + +no_memory: + virReportOOMError(NULL); + if (obj) + json_free_value(&obj); + if (tmp) + json_free_value(&tmp); + return NULL; +} + +int +qemuMonitorJSONStartCPUs(qemuMonitorPtr mon, + virConnectPtr conn ATTRIBUTE_UNUSED) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("cont", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + + +int +qemuMonitorJSONStopCPUs(qemuMonitorPtr mon) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("stop", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + + +int qemuMonitorJSONSystemPowerdown(qemuMonitorPtr mon) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("system_powerdown", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + + +int qemuMonitorJSONGetCPUInfo(qemuMonitorPtr mon, + int **pids) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("info cpus", NULL); + json_t *reply = NULL; + + *pids = NULL; + + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + + + +/* + * Returns: 0 if balloon not supported, +1 if balloon query worked + * or -1 on failure + */ +int qemuMonitorJSONGetBalloonInfo(qemuMonitorPtr mon, + unsigned long *currmem) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("info balloon", NULL); + json_t *reply = NULL; + + *currmem = 0; + + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + + +int qemuMonitorJSONGetBlockStatsInfo(qemuMonitorPtr mon, + const char *devname ATTRIBUTE_UNUSED, + long long *rd_req, + long long *rd_bytes, + long long *wr_req, + long long *wr_bytes, + long long *errs) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("info blockstats", NULL); + json_t *reply = NULL; + + *rd_req = *rd_bytes = *wr_req = *wr_bytes = *errs = 0; + + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + + +int qemuMonitorJSONSetVNCPassword(qemuMonitorPtr mon, + const char *password ATTRIBUTE_UNUSED) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("change vnc password", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + +/* + * Returns: 0 if balloon not supported, +1 if balloon adjust worked + * or -1 on failure + */ +int qemuMonitorJSONSetBalloon(qemuMonitorPtr mon, + unsigned long newmem ATTRIBUTE_UNUSED) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("balloon", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + +int qemuMonitorJSONEjectMedia(qemuMonitorPtr mon, + const char *devname ATTRIBUTE_UNUSED) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("eject", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + + +int qemuMonitorJSONChangeMedia(qemuMonitorPtr mon, + const char *devname ATTRIBUTE_UNUSED, + const char *newmedia ATTRIBUTE_UNUSED) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("change", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + +static int qemuMonitorJSONSaveMemory(qemuMonitorPtr mon, + const char *cmdtype, + unsigned long long offset ATTRIBUTE_UNUSED, + size_t length ATTRIBUTE_UNUSED, + const char *path ATTRIBUTE_UNUSED) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand(cmdtype, NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + + +int qemuMonitorJSONSaveVirtualMemory(qemuMonitorPtr mon, + unsigned long long offset, + size_t length, + const char *path) +{ + return qemuMonitorJSONSaveMemory(mon, "memsave", offset, length, path); +} + +int qemuMonitorJSONSavePhysicalMemory(qemuMonitorPtr mon, + unsigned long long offset, + size_t length, + const char *path) +{ + return qemuMonitorJSONSaveMemory(mon, "pmemsave", offset, length, path); +} + + +int qemuMonitorJSONSetMigrationSpeed(qemuMonitorPtr mon, + unsigned long bandwidth ATTRIBUTE_UNUSED) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("migrate_set_speed", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + +int qemuMonitorJSONGetMigrationStatus(qemuMonitorPtr mon, + int *status, + unsigned long long *transferred, + unsigned long long *remaining, + unsigned long long *total) { + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("info migration", NULL); + json_t *reply = NULL; + + *status = 0; + *transferred = *remaining = *total = 0; + + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + + +int qemuMonitorJSONMigrateToHost(qemuMonitorPtr mon, + int background ATTRIBUTE_UNUSED, + const char *hostname ATTRIBUTE_UNUSED, + int port ATTRIBUTE_UNUSED) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("migrate", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + + +int qemuMonitorJSONMigrateToCommand(qemuMonitorPtr mon, + int background ATTRIBUTE_UNUSED, + const char * const *argv ATTRIBUTE_UNUSED, + const char *target ATTRIBUTE_UNUSED) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("migrate", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + +int qemuMonitorJSONMigrateToUnix(qemuMonitorPtr mon, + int background ATTRIBUTE_UNUSED, + const char *unixfile ATTRIBUTE_UNUSED) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("migrate", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + +int qemuMonitorJSONMigrateCancel(qemuMonitorPtr mon) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("migrate", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + +int qemuMonitorJSONAddUSBDisk(qemuMonitorPtr mon, + const char *path ATTRIBUTE_UNUSED) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("usb_add", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + + +int qemuMonitorJSONAddUSBDeviceExact(qemuMonitorPtr mon, + int bus ATTRIBUTE_UNUSED, + int dev ATTRIBUTE_UNUSED) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("usb_add", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; + +} + +int qemuMonitorJSONAddUSBDeviceMatch(qemuMonitorPtr mon, + int vendor ATTRIBUTE_UNUSED, + int product ATTRIBUTE_UNUSED) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("usb_add", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + + +int qemuMonitorJSONAddPCIHostDevice(qemuMonitorPtr mon, + unsigned hostDomain ATTRIBUTE_UNUSED, + unsigned hostBus ATTRIBUTE_UNUSED, + unsigned hostSlot ATTRIBUTE_UNUSED, + unsigned hostFunction ATTRIBUTE_UNUSED, + unsigned *guestDomain, + unsigned *guestBus, + unsigned *guestSlot) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("pci_add", NULL); + json_t *reply = NULL; + + *guestDomain = *guestBus = *guestSlot = 0; + + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + + +int qemuMonitorJSONAddPCIDisk(qemuMonitorPtr mon, + const char *path ATTRIBUTE_UNUSED, + const char *bus ATTRIBUTE_UNUSED, + unsigned *guestDomain, + unsigned *guestBus, + unsigned *guestSlot) { + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("pci_add", NULL); + json_t *reply = NULL; + + *guestDomain = *guestBus = *guestSlot = 0; + + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + + +int qemuMonitorJSONAddPCINetwork(qemuMonitorPtr mon, + const char *nicstr ATTRIBUTE_UNUSED, + unsigned *guestDomain, + unsigned *guestBus, + unsigned *guestSlot) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("pci_add", NULL); + json_t *reply = NULL; + + *guestDomain = *guestBus = *guestSlot = 0; + + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + + +int qemuMonitorJSONRemovePCIDevice(qemuMonitorPtr mon, + unsigned guestDomain ATTRIBUTE_UNUSED, + unsigned guestBus ATTRIBUTE_UNUSED, + unsigned guestSlot ATTRIBUTE_UNUSED) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("pci_del", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + + +int qemuMonitorJSONSendFileHandle(qemuMonitorPtr mon, + const char *fdname ATTRIBUTE_UNUSED, + int fd) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("getfd", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommandWithFd(mon, cmd, fd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + + +int qemuMonitorJSONCloseFileHandle(qemuMonitorPtr mon, + const char *fdname ATTRIBUTE_UNUSED) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("closefd", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + + +int qemuMonitorJSONAddHostNetwork(qemuMonitorPtr mon, + const char *netstr ATTRIBUTE_UNUSED) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("host_net_add", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} + + +int qemuMonitorJSONRemoveHostNetwork(qemuMonitorPtr mon, + int vlan ATTRIBUTE_UNUSED, + const char *netname ATTRIBUTE_UNUSED) +{ + int ret; + json_t *cmd = qemuMonitorJSONMakeCommand("host_net_remove", NULL); + json_t *reply = NULL; + if (!cmd) + return -1; + + ret = qemuMonitorCommand(mon, cmd, &reply); + + json_free_value(&cmd); + if (reply) + json_free_value(&reply); + return ret; +} diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h new file mode 100644 index 0000000..a44158a --- /dev/null +++ b/src/qemu/qemu_monitor_json.h @@ -0,0 +1,155 @@ +/* + * qemu_monitor_json.h: interaction with QEMU monitor console + * + * Copyright (C) 2006-2009 Red Hat, Inc. + * Copyright (C) 2006 Daniel P. Berrange + * + * 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 + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Daniel P. Berrange <berrange(a)redhat.com&gt; + */ + + +#ifndef QEMU_MONITOR_JSON_H +#define QEMU_MONITOR_JSON_H + +#include "internal.h" + +#include "qemu_monitor.h" + +int qemuMonitorJSONIOProcess(qemuMonitorPtr mon, + const char *data, + size_t len, + qemuMonitorMessagePtr msg); + +int qemuMonitorJSONStartCPUs(qemuMonitorPtr mon, + virConnectPtr conn); +int qemuMonitorJSONStopCPUs(qemuMonitorPtr mon); + +int qemuMonitorJSONSystemPowerdown(qemuMonitorPtr mon); + +int qemuMonitorJSONGetCPUInfo(qemuMonitorPtr mon, + int **pids); +int qemuMonitorJSONGetBalloonInfo(qemuMonitorPtr mon, + unsigned long *currmem); +int qemuMonitorJSONGetBlockStatsInfo(qemuMonitorPtr mon, + const char *devname, + long long *rd_req, + long long *rd_bytes, + long long *wr_req, + long long *wr_bytes, + long long *errs); + + +int qemuMonitorJSONSetVNCPassword(qemuMonitorPtr mon, + const char *password); +int qemuMonitorJSONSetBalloon(qemuMonitorPtr mon, + unsigned long newmem); + +int qemuMonitorJSONEjectMedia(qemuMonitorPtr mon, + const char *devname); +int qemuMonitorJSONChangeMedia(qemuMonitorPtr mon, + const char *devname, + const char *newmedia); + + +int qemuMonitorJSONSaveVirtualMemory(qemuMonitorPtr mon, + unsigned long long offset, + size_t length, + const char *path); +int qemuMonitorJSONSavePhysicalMemory(qemuMonitorPtr mon, + unsigned long long offset, + size_t length, + const char *path); + +int qemuMonitorJSONSetMigrationSpeed(qemuMonitorPtr mon, + unsigned long bandwidth); + +int qemuMonitorJSONGetMigrationStatus(qemuMonitorPtr mon, + int *status, + unsigned long long *transferred, + unsigned long long *remaining, + unsigned long long *total); + +int qemuMonitorJSONMigrateToHost(qemuMonitorPtr mon, + int background, + const char *hostname, + int port); + +int qemuMonitorJSONMigrateToCommand(qemuMonitorPtr mon, + int background, + const char * const *argv, + const char *target); + +int qemuMonitorJSONMigrateToUnix(qemuMonitorPtr mon, + int background, + const char *unixfile); + +int qemuMonitorJSONMigrateCancel(qemuMonitorPtr mon); + +int qemuMonitorJSONAddUSBDisk(qemuMonitorPtr mon, + const char *path); + +int qemuMonitorJSONAddUSBDeviceExact(qemuMonitorPtr mon, + int bus, + int dev); +int qemuMonitorJSONAddUSBDeviceMatch(qemuMonitorPtr mon, + int vendor, + int product); + + +int qemuMonitorJSONAddPCIHostDevice(qemuMonitorPtr mon, + unsigned hostDomain, + unsigned hostBus, + unsigned hostSlot, + unsigned hostFunction, + unsigned *guestDomain, + unsigned *guestBus, + unsigned *guestSlot); + +int qemuMonitorJSONAddPCIDisk(qemuMonitorPtr mon, + const char *path, + const char *bus, + unsigned *guestDomain, + unsigned *guestBus, + unsigned *guestSlot); + +int qemuMonitorJSONAddPCINetwork(qemuMonitorPtr mon, + const char *nicstr, + unsigned *guestDomain, + unsigned *guestBus, + unsigned *guestSlot); + +int qemuMonitorJSONRemovePCIDevice(qemuMonitorPtr mon, + unsigned guestDomain, + unsigned guestBus, + unsigned guestSlot); + + +int qemuMonitorJSONSendFileHandle(qemuMonitorPtr mon, + const char *fdname, + int fd); + +int qemuMonitorJSONCloseFileHandle(qemuMonitorPtr mon, + const char *fdname); + +int qemuMonitorJSONAddHostNetwork(qemuMonitorPtr mon, + const char *netstr); + +int qemuMonitorJSONRemoveHostNetwork(qemuMonitorPtr mon, + int vlan, + const char *netname); + +#endif /* QEMU_MONITOR_JSON_H */ diff --git a/src/util/json.c b/src/util/json.c new file mode 100644 index 0000000..69b4434 --- /dev/null +++ b/src/util/json.c @@ -0,0 +1,3904 @@ +/*************************************************************************** + * Copyright (C) 2007 by Rui Maciel * + * rui.maciel(a)gmail.com * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU Library General Public License as * + * published by the Free Software Foundation; either version 2 of the * + * License, or (at your option) any later version. * + * * + * This program 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 General Public License for more details. * + * * + * You should have received a copy of the GNU Library General Public * + * License along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + ***************************************************************************/ + +#include <config.h> + +#include <stdlib.h> +#include <stdio.h> + +#include "json.h" +#include "memory.h" + +enum LEX_VALUE +{ LEX_MORE = 0, + LEX_INVALID_CHARACTER, + LEX_TRUE, + LEX_FALSE, + LEX_NULL, + LEX_BEGIN_OBJECT, + LEX_END_OBJECT, + LEX_BEGIN_ARRAY, + LEX_END_ARRAY, + LEX_NAME_SEPARATOR, + LEX_VALUE_SEPARATOR, + LEX_STRING, + LEX_NUMBER, + LEX_ERROR, + LEX_MEMORY +}; + + +/* rc_string part */ + +#define RSTRING_INCSTEP 5 +#define RSTRING_DEFAULT 8 + +enum rui_string_error_codes +{ RS_MEMORY, RS_OK = 1, RS_UNKNOWN }; + +typedef enum rui_string_error_codes rstring_code; + + +static rcstring * +rcs_create (size_t length) +{ + rcstring *rcs; + if (VIR_ALLOC(rcs) < 0) + return NULL; + + rcs->max = length; + rcs->length = 0; + + if (VIR_ALLOC_N(rcs->text, rcs->max + 1) < 0) + { + VIR_FREE(rcs); + return NULL; + } + rcs->text[0] = '\0'; + + return rcs; +} + + +static void +rcs_free (rcstring ** rcs) +{ + if (*rcs != NULL) + { + VIR_FREE((*rcs)->text); + VIR_FREE(*rcs); + } + +} + + +static rstring_code +rcs_resize (rcstring * rcs, size_t length) +{ + if (VIR_REALLOC_N(rcs->text, length + 1) < 0) + { + VIR_FREE(rcs); + return RS_MEMORY; + } + rcs->max = length; + rcs->text[rcs->max] = '\0'; + return RS_OK; +} + + +static rstring_code +rcs_catcs (rcstring * pre, const char *pos, const size_t length) +{ + if (pre->max < pre->length + length) + { + if (rcs_resize (pre, pre->length + length + RSTRING_INCSTEP) != RS_OK) + return RS_MEMORY; + } + strncpy (pre->text + pre->length, pos, length); + pre->text[pre->length + length] = '\0'; + pre->length += length; + return RS_OK; +} + + +static rstring_code +rcs_catc (rcstring * pre, const char c) +{ + if (pre->max <= pre->length) + { + if (rcs_resize (pre, pre->max + RSTRING_INCSTEP) != RS_OK) + return RS_MEMORY; + } + pre->text[pre->length] = c; + pre->length++; + pre->text[pre->length] = '\0'; + return RS_OK; +} + + +static char * +rcs_unwrap (rcstring * rcs) +{ + char *out; + + if (rcs->text == NULL) + out = NULL; + else + { + if (VIR_REALLOC_N(rcs->text, strlen(rcs->text)+1) < 0) + {} /* Ignore error to shrink */ + out = rcs->text; + } + + VIR_FREE(rcs); + return out; +} + + + +static size_t +rcs_length (rcstring * rcs) +{ + /*TODO account for UTF8 */ + return rcs->length; +} + + +/* end of rc_string part */ + + +enum json_error +json_stream_parse (FILE * file, json_t ** document) +{ + char buffer[1024]; /* hard-coded value */ + unsigned int error = JSON_INCOMPLETE_DOCUMENT; + + struct json_parsing_info state; + + json_jpi_init (&state); /* initializes the json_parsing_info object */ + + while ((error == JSON_WAITING_FOR_EOF) || (error == JSON_INCOMPLETE_DOCUMENT)) + { + if (fgets (buffer, 1024, file) != NULL) + { + switch (error = json_parse_fragment (&state, buffer)) + { + case JSON_OK: + case JSON_WAITING_FOR_EOF: + case JSON_INCOMPLETE_DOCUMENT: + break; + + default: + json_free_value (&state.cursor); + return error; + break; + } + } + else + { + if (error == JSON_WAITING_FOR_EOF) + error = JSON_OK; + else + { + /*TODO refine this error code */ + error = JSON_UNKNOWN_PROBLEM; + } + } + } + + if (error == JSON_OK) + { + *document = state.cursor; + } + + return error; +} + + +json_t * +json_new_value (const enum json_value_type type) +{ + json_t *new_object; + if (VIR_ALLOC(new_object) < 0) + return NULL; + + /* initialize members */ + new_object->text = NULL; + new_object->parent = NULL; + new_object->child = NULL; + new_object->child_end = NULL; + new_object->previous = NULL; + new_object->next = NULL; + new_object->type = type; + return new_object; +} + + +json_t * +json_new_string (const char *text) +{ + json_t *new_object; + size_t length; + + if (VIR_ALLOC(new_object) < 0) + return NULL; + + /* initialize members */ + length = strlen (text) + 1; + if (VIR_ALLOC_N(new_object->text, length) < 0) + { + VIR_FREE(new_object); + return NULL; + } + strncpy (new_object->text, text, length); + new_object->parent = NULL; + new_object->child = NULL; + new_object->child_end = NULL; + new_object->previous = NULL; + new_object->next = NULL; + new_object->type = JSON_STRING; + return new_object; +} + + +json_t * +json_new_number (const char *text) +{ + json_t *new_object; + size_t length; + + /* allocate memory for the new object */ + if (VIR_ALLOC(new_object) < 0) + return NULL; + + /* initialize members */ + length = strlen (text) + 1; + if (VIR_ALLOC_N(new_object->text, length) < 0) + { + VIR_FREE(new_object); + return NULL; + } + strncpy (new_object->text, text, length); + new_object->parent = NULL; + new_object->child = NULL; + new_object->child_end = NULL; + new_object->previous = NULL; + new_object->next = NULL; + new_object->type = JSON_NUMBER; + return new_object; +} + + +json_t * +json_new_object (void) +{ + return json_new_value (JSON_OBJECT); +} + + +json_t * +json_new_array (void) +{ + return json_new_value (JSON_ARRAY); +} + + +json_t * +json_new_null (void) +{ + return json_new_value (JSON_NULL); +} + + +json_t * +json_new_true (void) +{ + return json_new_value (JSON_TRUE); +} + + +json_t * +json_new_false (void) +{ + return json_new_value (JSON_FALSE); +} + + +void +json_free_value (json_t ** value) +{ + /* free each and every child node */ + if ((*value)->child != NULL) + { + json_t *i, *j; + i = (*value)->child_end; + while (i != NULL) + { + j = i->previous; + json_free_value (&i); /*TODO replace recursive solution with an iterative one */ + i = j; + } + } + + /* fixing sibling linked list connections */ + if ((*value)->previous && (*value)->next) + { + (*value)->previous->next = (*value)->next; + (*value)->next->previous = (*value)->previous; + } + else + { + if ((*value)->previous) + { + (*value)->previous->next = NULL; + } + if ((*value)->next) + { + (*value)->next->previous = NULL; + } + } + + /*fixing parent node connections */ + if ((*value)->parent) + { + /* fix the tree connection to the first node in the children's list */ + if ((*value)->parent->child == (*value)) + { + if ((*value)->next) + { + (*value)->parent->child = (*value)->next; /* the parent node always points to the first node in the children linked list */ + } + else + { + (*value)->parent->child = NULL; + } + } + + /* fix the tree connection to the last node in the children's list */ + if ((*value)->parent->child_end == (*value)) + { + if ((*value)->previous) + { + (*value)->parent->child_end = (*value)->previous; /* the parent node always points to the last node in the children linked list */ + } + else + { + (*value)->parent->child_end = NULL; + } + } + } + + /*finally, freeing the memory allocated for this value */ + VIR_FREE((*value)->text); + VIR_FREE(*value); +} + + +enum json_error +json_insert_child (json_t * parent, json_t * child) +{ + /*TODO change the child list from FIFO to LIFO, in order to get rid of the child_end pointer */ + /* enforce tree structure correctness */ + switch (parent->type) + { + case JSON_STRING: + /* a string accepts every JSON type as a child value */ + /* therefore, the sanity check must be performed on the child node */ + switch (child->type) + { + case JSON_STRING: + case JSON_NUMBER: + case JSON_TRUE: + case JSON_FALSE: + case JSON_NULL: + if (child->child != NULL) + return JSON_BAD_TREE_STRUCTURE; + break; + + case JSON_OBJECT: + case JSON_ARRAY: + break; + + default: + return JSON_BAD_TREE_STRUCTURE; /* this part should never be reached */ + break; + } + break; + + case JSON_OBJECT: /* JSON objects may only accept JSON string objects which already have child nodes of their own */ + if (child->type != JSON_STRING) + return JSON_BAD_TREE_STRUCTURE; + break; + + case JSON_ARRAY: + switch (child->type) + { + case JSON_STRING: + case JSON_TRUE: + case JSON_FALSE: + case JSON_NULL: + case JSON_NUMBER: + if (child->child) + return JSON_BAD_TREE_STRUCTURE; + break; + + case JSON_OBJECT: + case JSON_ARRAY: + break; + + default: + return JSON_BAD_TREE_STRUCTURE; + } + break; + + default: + return JSON_BAD_TREE_STRUCTURE; + } + + child->parent = parent; + if (parent->child) + { + child->previous = parent->child_end; + parent->child_end->next = child; + parent->child_end = child; + } + else + { + parent->child = child; + parent->child_end = child; + } + + return JSON_OK; +} + + +enum json_error +json_insert_pair_into_object (json_t * parent, const char *text_label, json_t * value) +{ + enum json_error error; + json_t *label; + + /* create label json_value */ + label = json_new_string (text_label); + if (label == NULL) + return JSON_MEMORY; + + /*insert value and check for error */ + error = json_insert_child (label, value); + if (error != JSON_OK) + return error; + /*insert value and check for error */ + error = json_insert_child (parent, label); + if (error != JSON_OK) + return error; + + return JSON_OK; +} + + +enum json_error +json_tree_to_string (json_t * root, char **text) +{ + json_t *cursor; + rcstring *output; + + cursor = root; + /* set up the output and temporary rwstrings */ + output = rcs_create (RSTRING_DEFAULT); + + /* start the convoluted fun */ +state1: /* open value */ + { + if ((cursor->previous) && (cursor != root)) /*if cursor is children and not root than it is a followup sibling */ + { + /* append comma */ + if (rcs_catc (output, ',') != RS_OK) + { + return JSON_MEMORY; + } + } + switch (cursor->type) + { + case JSON_STRING: + /* append the "text"\0, which means 1 + wcslen(cursor->text) + 1 + 1 */ + /* set the new output size */ + if (rcs_catc (output, '\"') != RS_OK) + { + return JSON_MEMORY; + } + if (rcs_catcs (output, cursor->text, strlen (cursor->text)) != RS_OK) + { + return JSON_MEMORY; + } + if (rcs_catc (output, '\"') != RS_OK) + { + return JSON_MEMORY; + } + + if (cursor->parent != NULL) + { + if (cursor->parent->type == JSON_OBJECT) /* cursor is label in label:value pair */ + { + /* error checking: if parent is object and cursor is string then cursor must have a single child */ + if (cursor->child != NULL) + { + if (rcs_catc (output, ':') != RS_OK) + { + return JSON_MEMORY; + } + } + else + { + /* malformed document tree: label without value in label:value pair */ + rcs_free (&output); + text = NULL; + return JSON_BAD_TREE_STRUCTURE; + } + } + } + else /* does not have a parent */ + { + if (cursor->child != NULL) /* is root label in label:value pair */ + { + if (rcs_catc (output, ':') != RS_OK) + { + return JSON_MEMORY; + } + } + else + { + /* malformed document tree: label without value in label:value pair */ + rcs_free (&output); + text = NULL; + return JSON_BAD_TREE_STRUCTURE; + } + } + break; + + case JSON_NUMBER: + /* must not have any children */ + /* set the new size */ + if (rcs_catcs (output, cursor->text, strlen (cursor->text)) != RS_OK) + { + return JSON_MEMORY; + } + goto state2; /* close value */ + break; + + case JSON_OBJECT: + if (rcs_catc (output, '{') != RS_OK) + { + return JSON_MEMORY; + } + + if (cursor->child) + { + cursor = cursor->child; + goto state1; /* open value */ + } + else + { + goto state2; /* close value */ + } + break; + + case JSON_ARRAY: + if (rcs_catc (output, '[') != RS_OK) + { + return JSON_MEMORY; + } + + if (cursor->child != NULL) + { + cursor = cursor->child; + goto state1; + } + else + { + goto state2; /* close value */ + } + break; + + case JSON_TRUE: + /* must not have any children */ + if (rcs_catcs (output, "true", 4) != RS_OK) + { + return JSON_MEMORY; + } + goto state2; /* close value */ + break; + + case JSON_FALSE: + /* must not have any children */ + if (rcs_catcs (output, "false", 5) != RS_OK) + { + return JSON_MEMORY; + } + goto state2; /* close value */ + break; + + case JSON_NULL: + /* must not have any children */ + if (rcs_catcs (output, "null", 4) != RS_OK) + { + return JSON_MEMORY; + } + goto state2; /* close value */ + break; + + default: + goto error; + } + if (cursor->child) + { + cursor = cursor->child; + goto state1; /* open value */ + } + else + { + /* does not have any children */ + goto state2; /* close value */ + } + } + +state2: /* close value */ + { + switch (cursor->type) + { + case JSON_OBJECT: + if (rcs_catc (output, '}') != RS_OK) + { + return JSON_MEMORY; + } + break; + + case JSON_ARRAY: + if (rcs_catc (output, ']') != RS_OK) + { + return JSON_MEMORY; + } + break; + + case JSON_STRING: + break; + case JSON_NUMBER: + break; + case JSON_TRUE: + break; + case JSON_FALSE: + break; + case JSON_NULL: + break; + default: + goto error; + } + if ((cursor->parent == NULL) || (cursor == root)) + { + goto end; + } + else if (cursor->next) + { + cursor = cursor->next; + goto state1; /* open value */ + } + else + { + cursor = cursor->parent; + goto state2; /* close value */ + } + } + +error: + { + rcs_free (&output); + return JSON_UNKNOWN_PROBLEM; + } + +end: + { + *text = rcs_unwrap (output); + return JSON_OK; + } +} + + +enum json_error +json_stream_output (FILE * file, json_t * root) +{ + json_t *cursor; + + cursor = root; + /* set up the output and temporary rwstrings */ + + /* start the convoluted fun */ +state1: /* open value */ + { + if ((cursor->previous) && (cursor != root)) /*if cursor is children and not root than it is a followup sibling */ + { + /* append comma */ + fprintf (file, ","); + } + switch (cursor->type) + { + case JSON_STRING: + /* append the "text"\0, which means 1 + wcslen(cursor->text) + 1 + 1 */ + /* set the new output size */ + fprintf (file, "\"%s\"", cursor->text); + + if (cursor->parent != NULL) + { + if (cursor->parent->type == JSON_OBJECT) /* cursor is label in label:value pair */ + { + /* error checking: if parent is object and cursor is string then cursor must have a single child */ + if (cursor->child != NULL) + { + if (fprintf (file, ":") != RS_OK) + { + return JSON_MEMORY; + } + } + else + { + /* malformed document tree: label without value in label:value pair */ + return JSON_BAD_TREE_STRUCTURE; + } + } + } + else /* does not have a parent */ + { + if (cursor->child != NULL) /* is root label in label:value pair */ + { + fprintf (file, ":"); + } + else + { + /* malformed document tree: label without value in label:value pair */ + return JSON_BAD_TREE_STRUCTURE; + } + } + break; + + case JSON_NUMBER: + /* must not have any children */ + /* set the new size */ + fprintf (file, "%s", cursor->text); + goto state2; /* close value */ + break; + + case JSON_OBJECT: + fprintf (file, "{"); + + if (cursor->child) + { + cursor = cursor->child; + goto state1; /* open value */ + } + else + { + goto state2; /* close value */ + } + break; + + case JSON_ARRAY: + fprintf (file, "["); + + if (cursor->child != NULL) + { + cursor = cursor->child; + goto state1; + } + else + { + goto state2; /* close value */ + } + break; + + case JSON_TRUE: + /* must not have any children */ + fprintf (file, "true"); + goto state2; /* close value */ + break; + + case JSON_FALSE: + /* must not have any children */ + fprintf (file, "false"); + goto state2; /* close value */ + break; + + case JSON_NULL: + /* must not have any children */ + fprintf (file, "null"); + goto state2; /* close value */ + break; + + default: + goto error; + } + if (cursor->child) + { + cursor = cursor->child; + goto state1; /* open value */ + } + else + { + /* does not have any children */ + goto state2; /* close value */ + } + } + +state2: /* close value */ + { + switch (cursor->type) + { + case JSON_OBJECT: + fprintf (file, "}"); + break; + + case JSON_ARRAY: + fprintf (file, "]"); + break; + + case JSON_STRING: + break; + case JSON_NUMBER: + break; + case JSON_TRUE: + break; + case JSON_FALSE: + break; + case JSON_NULL: + break; + default: + goto error; + } + if ((cursor->parent == NULL) || (cursor == root)) + { + goto end; + } + else if (cursor->next) + { + cursor = cursor->next; + goto state1; /* open value */ + } + else + { + cursor = cursor->parent; + goto state2; /* close value */ + } + } + +error: + { + return JSON_UNKNOWN_PROBLEM; + } + +end: + { + fprintf (file, "\n"); + return JSON_OK; + } +} + + +void +json_strip_white_spaces (char *text) +{ + size_t in, out, length; + int state; + + in = 0; + out = 0; + length = strlen (text); + state = 0; /* possible states: 0 -> document, 1 -> inside a string */ + + while (in < length) + { + switch (text[in]) + { + case '\x20': /* space */ + case '\x09': /* horizontal tab */ + case '\x0A': /* line feed or new line */ + case '\x0D': /* Carriage return */ + if (state == 1) + { + text[out++] = text[in]; + } + break; + + case '\"': + switch (state) + { + case 0: /* not inside a JSON string */ + state = 1; + break; + + case 1: /* inside a JSON string */ + if (text[in - 1] != '\\') + { + state = 0; + } + break; + } + text[out++] = text[in]; + break; + + default: + text[out++] = text[in]; + } + ++in; + } + text[out] = '\0'; +} + + +char * +json_format_string (const char *text) +{ + size_t pos = 0, text_length; + unsigned int indentation = 0; /* the current indentation level */ + unsigned int i; /* loop iterator variable */ + char loop; + + rcstring *output; + text_length = strlen (text); + + output = rcs_create (text_length); + while (pos < text_length) + { + switch (text[pos]) + { + case '\x20': + case '\x09': + case '\x0A': + case '\x0D': /* JSON insignificant white spaces */ + pos++; + break; + + case '{': + indentation++; + rcs_catcs (output, "{\n", 2); + for (i = 0; i < indentation; i++) + { + rcs_catc (output, '\t'); + } + pos++; + break; + + case '}': + indentation--; + rcs_catc (output, '\n'); + for (i = 0; i < indentation; i++) + { + rcs_catc (output, '\t'); + } + rcs_catc (output, '}'); + pos++; + break; + + case ':': + rcs_catcs (output, ": ", 2); + pos++; + break; + + case ',': + rcs_catcs (output, ",\n", 2); + for (i = 0; i < indentation; i++) + { + rcs_catc (output, '\t'); + } + pos++; + break; + + case '\"': /* open string */ + rcs_catc (output, text[pos]); + pos++; + loop = 1; /* inner string loop trigger is enabled */ + while (loop) + { + if (text[pos] == '\\') /* escaped sequence */ + { + rcs_catc (output, '\\'); + pos++; + if (text[pos] == '\"') /* don't consider a \" escaped sequence as an end of string */ + { + rcs_catc (output, '\"'); + pos++; + } + } + else if (text[pos] == '\"') /* reached end of string */ + { + loop = 0; + } + + rcs_catc (output, text[pos]); + + pos++; + if (pos >= text_length) + { + loop = 0; + } + } + break; + + default: + rcs_catc (output, text[pos]); + pos++; + break; + } + } + + return rcs_unwrap (output); +} + + +char * +json_escape (char *text) +{ + rcstring *output; + size_t i, length; + char buffer[6]; + + /* defining the temporary variables */ + length = strlen (text); + output = rcs_create (length); + if (output == NULL) + return NULL; + for (i = 0; i < length; i++) + { + if (text[i] == '\\') + { + rcs_catcs (output, "\\\\", 2); + } + else if (text[i] == '\"') + { + rcs_catcs (output, "\\\"", 2); + } + else if (text[i] == '/') + { + rcs_catcs (output, "\\/", 2); + } + else if (text[i] == '\b') + { + rcs_catcs (output, "\\b", 2); + } + else if (text[i] == '\f') + { + rcs_catcs (output, "\\f", 2); + } + else if (text[i] == '\n') + { + rcs_catcs (output, "\\n", 2); + } + else if (text[i] == '\r') + { + rcs_catcs (output, "\\r", 2); + } + else if (text[i] == '\t') + { + rcs_catcs (output, "\\t", 2); + } + else if (text[i] < 0) /* non-BMP character */ + { + rcs_catc (output, text[i]); + } + else if (text[i] < 0x20) + { + sprintf (buffer, "\\u%4.4x", text[i]); + rcs_catcs (output, buffer, 6); + } + else + { + rcs_catc (output, text[i]); + } + } + return rcs_unwrap (output); +} + + +void +json_jpi_init (struct json_parsing_info *jpi) +{ + jpi->state = 0; + jpi->lex_state = 0; + jpi->lex_text = NULL; + jpi->p = NULL; + jpi->cursor = NULL; + jpi->string_length_limit_reached = 0; +} + + +static int +lexer (const char *buffer, const char **p, unsigned int *state, rcstring ** text) +{ + if (*p == NULL) + *p = buffer; + + while (**p != '\0') + { + switch (*state) + { + + case 0: /* Root document */ + { + switch (*(*p)++) + { + case '\x20': /* space */ + case '\x09': /* horizontal tab */ + case '\x0A': /* line feed or new line */ + case '\x0D': /* Carriage return */ + break; + + case '{': + return LEX_BEGIN_OBJECT; + case '}': + return LEX_END_OBJECT; + case '[': + return LEX_BEGIN_ARRAY; + case ']': + return LEX_END_ARRAY; + case ':': + return LEX_NAME_SEPARATOR; + case ',': + return LEX_VALUE_SEPARATOR; + + case '\"': + *text = rcs_create (RSTRING_DEFAULT); + if (*text == NULL) + return LEX_MEMORY; + *state = 1; /* inside a JSON string */ + break; + + case 't': + *state = 7; /* true: 1 */ + break; + + case 'f': + *state = 10; /* false: 1 */ + break; + + case 'n': + *state = 14; /* false: 1 */ + break; + + case '-': + *text = rcs_create (RSTRING_DEFAULT); + if (*text == NULL) + return LEX_MEMORY; + if (rcs_catc (*text, '-') != RS_OK) + return LEX_MEMORY; + *state = 17; /* number: '0' */ + break; + + case '0': + *text = rcs_create (RSTRING_DEFAULT); + if (*text == NULL) + return LEX_MEMORY; + if (rcs_catc (*text, '0') != RS_OK) + return LEX_MEMORY; + *state = 18; /* number: '0' */ + break; + + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + *text = rcs_create (RSTRING_DEFAULT); + if (*text == NULL) + return LEX_MEMORY; + if (rcs_catc (*text, *(*p - 1)) != RS_OK) + return LEX_MEMORY; + *state = 19; /* number: decimal followup */ + break; + + + default: + return LEX_INVALID_CHARACTER; + } + } + break; + + case 1: /* inside a JSON string */ + { + switch (**p) + { + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: /* line feed */ + case 11: + case 12: + case 13: /* carriage return */ + case 14: + case 15: + case 16: + case 17: + case 18: + case 19: + case 20: + case 21: + case 22: + case 23: + case 24: + case 25: + case 26: + case 27: + case 28: + case 29: + case 30: + case 31: + /* ASCII control characters can only be present in a JSON string if they are escaped. If not then the document is invalid */ + return LEX_INVALID_CHARACTER; + break; + + case '\"': /* close JSON string */ + /* it is expected that, in the routine that calls this function, text is set to NULL */ + *state = 0; + ++*p; + return LEX_STRING; + break; + + case '\\': + if (rcs_catc (*text, '\\') != RS_OK) + return LEX_MEMORY; + *state = 2; /* inside a JSON string: start escape sequence */ + break; + + default: + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + } + ++*p; + } + break; + + case 2: /* inside a JSON string: start escape sequence */ + { + switch (**p) + { + case '\\': + case '\"': + case '/': + case 'b': + case 'f': + case 'n': + case 'r': + case 't': + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + *state = 1; /* inside a JSON string */ + break; + + case 'u': + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + *state = 3; /* inside a JSON string: escape unicode */ + break; + + default: + return LEX_INVALID_CHARACTER; + } + ++*p; + } + break; + + case 3: /*inside a JSON string: escape unicode */ + { + if ((**p >= 'a') && (**p <= 'f')) + { + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + *state = 4; /* inside a JSON string: escape unicode */ + } + else if ((**p >= 'A') && (**p <= 'F')) + { + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + *state = 4; /* inside a JSON string: escape unicode */ + } + else if ((**p >= '0') && (**p <= '9')) + { + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + *state = 4; /* inside a JSON string: escape unicode */ + } + else + return LEX_INVALID_CHARACTER; + ++*p; + } + break; + + case 4: /* inside a JSON string: escape unicode */ + { + if ((**p >= 'a') && (**p <= 'f')) + { + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + *state = 5; /* inside a JSON string: escape unicode */ + } + else if ((**p >= 'A') && (**p <= 'F')) + { + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + *state = 5; /* inside a JSON string: escape unicode */ + } + else if ((**p >= '0') && (**p <= '9')) + { + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + *state = 5; /* inside a JSON string: escape unicode */ + } + else + return LEX_INVALID_CHARACTER; + ++*p; + } + + case 5: /* inside a JSON string: escape unicode */ + { + if ((**p >= 'a') && (**p <= 'f')) + { + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + *state = 6; /* inside a JSON string: escape unicode */ + } + else if ((**p >= 'A') && (**p <= 'F')) + { + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + *state = 6; /* inside a JSON string: escape unicode */ + } + else if ((**p >= '0') && (**p <= '9')) + { + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + *state = 6; /* inside a JSON string: escape unicode */ + } + else + return LEX_INVALID_CHARACTER; + ++*p; + } + break; + + case 6: /* inside a JSON string: escape unicode */ + { + if ((**p >= 'a') && (**p <= 'f')) + { + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + *state = 1; /* inside a JSON string: escape unicode */ + } + else if ((**p >= 'A') && (**p <= 'F')) + { + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + *state = 1; /* inside a JSON string: escape unicode */ + } + else if ((**p >= '0') && (**p <= '9')) + { + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + *state = 1; /* inside a JSON string: escape unicode */ + } + else + return LEX_INVALID_CHARACTER; + ++*p; + } + break; + + case 7: /* true: 1 */ + { + switch (*(*p)++) + { + case 'r': + *state = 8; + break; + default: + return LEX_INVALID_CHARACTER; + break; + } + } + break; + + case 8: /* true: 2 */ + { + switch (*(*p)++) + { + case 'u': + *state = 9; + break; + default: + return LEX_INVALID_CHARACTER; + break; + } + } + break; + + case 9: /* true: 3 */ + { + switch (*(*p)++) + { + case 'e': + *state = 0; + return LEX_TRUE; + break; + default: + return LEX_INVALID_CHARACTER; + break; + } + } + break; + + case 10: /* false: 1 */ + { + switch (*(*p)++) + { + case 'a': + *state = 11; + break; + default: + return LEX_INVALID_CHARACTER; + break; + } + } + break; + + case 11: /* false: 2 */ + { + switch (*(*p)++) + { + case 'l': + *state = 12; + break; + default: + return LEX_INVALID_CHARACTER; + break; + } + } + break; + + case 12: /* false: 3 */ + { + switch (*(*p)++) + { + case 's': + *state = 13; + break; + default: + return LEX_INVALID_CHARACTER; + break; + } + } + break; + + case 13: /* false: 4 */ + { + switch (*(*p)++) + { + case 'e': + *state = 0; + return LEX_FALSE; + break; + default: + return LEX_INVALID_CHARACTER; + break; + } + } + break; + + case 14: /* null: 1 */ + { + switch (*(*p)++) + { + case 'u': + *state = 15; + break; + default: + return LEX_INVALID_CHARACTER; + break; + } + } + break; + + case 15: /* null: 2 */ + { + switch (*(*p)++) + { + case 'l': + *state = 16; + break; + default: + return LEX_INVALID_CHARACTER; + break; + } + } + break; + + case 16: /* null: 3 */ + { + switch (*(*p)++) + { + case 'l': + *state = 0; + return LEX_NULL; + break; + default: + return LEX_INVALID_CHARACTER; + break; + } + } + break; + + case 17: /* number: minus sign */ + { + switch (**p) + { + case '0': + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + ++*p; + *state = 18; /* number: '0' */ + break; + + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + ++*p; + *state = 19; /* number: decimal followup */ + break; + + default: + return LEX_INVALID_CHARACTER; + break; + } + } + break; + + case 18: /* number: '0' */ + { + switch (**p) + { + case '\x20': /* space */ + case '\x09': /* horizontal tab */ + case '\x0A': /* line feed or new line */ + case '\x0D': /* Carriage return */ + ++*p; + case ']': + case '}': + case ',': + *state = 0; + return LEX_NUMBER; + break; + + case '.': + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + ++*p; + *state = 20; /* number: frac start */ + break; + + case 'e': + case 'E': + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + ++*p; + *state = 22; /* number: exp start */ + break; + + default: + return LEX_INVALID_CHARACTER; + break; + } + } + break; + + case 19: /* number: int followup */ + { + switch (**p) + { + case '\x20': /* space */ + case '\x09': /* horizontal tab */ + case '\x0A': /* line feed or new line */ + case '\x0D': /* Carriage return */ + ++*p; + case ']': + case '}': + case ',': + *state = 0; + return LEX_NUMBER; + break; + + case '.': + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + ++*p; + *state = 20; /* number: frac start */ + break; + + case 'e': + case 'E': + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + ++*p; + *state = 22; /* number: exp start */ + break; + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + ++*p; + break; + + default: + return LEX_INVALID_CHARACTER; + break; + } + } + break; + + case 20: /* number: frac start */ + { + switch (**p) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + ++*p; + *state = 21; /* number: frac continue */ + break; + + default: + return LEX_INVALID_CHARACTER; + break; + } + } + break; + + case 21: /* number: frac continue */ + { + switch (**p) + { + case '\x20': /* space */ + case '\x09': /* horizontal tab */ + case '\x0A': /* line feed or new line */ + case '\x0D': /* Carriage return */ + ++*p; + case ']': + case '}': + case ',': + *state = 0; + return LEX_NUMBER; + break; + + case 'e': + case 'E': + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + ++*p; + *state = 22; /* number: exp start */ + break; + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + ++*p; + break; + + default: + return LEX_INVALID_CHARACTER; + break; + } + } + break; + + case 22: /* number: exp start */ + { + switch (**p) + { + case '-': + case '+': + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + ++*p; + *state = 23; /* number: exp continue */ + break; + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + ++*p; + *state = 24; /* number: exp end */ + break; + + default: + return LEX_INVALID_CHARACTER; + break; + } + } + break; + + case 23: /* number: exp continue */ + { + switch (**p) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + ++*p; + *state = 24; /* number: exp end */ + break; + + default: + return LEX_INVALID_CHARACTER; + break; + } + } + break; + + case 24: /* number: exp end */ + { + switch (**p) + { + case '\x20': /* space */ + case '\x09': /* horizontal tab */ + case '\x0A': /* line feed or new line */ + case '\x0D': /* Carriage return */ + ++*p; + case ']': + case '}': + case ',': + *state = 0; + return LEX_NUMBER; + break; + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (rcs_catc (*text, **p) != RS_OK) + return LEX_MEMORY; + ++*p; + break; + + default: + return LEX_INVALID_CHARACTER; + break; + } + } + break; + + default: + printf ("*state missing: %d\n", *state); + return LEX_INVALID_CHARACTER; + } + + } + + *p = NULL; + return LEX_MORE; +} + + +enum json_error +json_parse_fragment (struct json_parsing_info *info, const char *buffer) +{ + json_t *temp = NULL; + + info->p = buffer; + while (*info->p != '\0') + { + switch (info->state) + { + case 0: /* starting point */ + { + switch (lexer (buffer, &info->p, &info->lex_state, & info->lex_text)) + { + case LEX_BEGIN_OBJECT: + info->state = 1; /* begin object */ + break; + + case LEX_BEGIN_ARRAY: + info->state = 7; /* begin array */ + break; + + case LEX_INVALID_CHARACTER: + return JSON_MALFORMED_DOCUMENT; + break; + + default: + printf ("state %d: defaulted\n", info->state); + return JSON_MALFORMED_DOCUMENT; + break; + } + } + break; + + case 1: /* open object */ + { + if (info->cursor == NULL) + { + if ((info->cursor = json_new_object ()) == NULL) + { + return JSON_MEMORY; + } + } + else + { + if ((temp = json_new_object ()) == NULL) + { + return JSON_MEMORY; + } + if (json_insert_child (info->cursor, temp) != JSON_OK) + { + return JSON_UNKNOWN_PROBLEM; + } + info->cursor = temp; + temp = NULL; + } + info->state = 2; /* just entered an object */ + } + break; + + case 2: /* opened object */ + { + switch (lexer (buffer, &info->p, &info->lex_state, & info->lex_text)) + { + case LEX_STRING: + if ((temp = json_new_value (JSON_STRING)) == NULL) + return JSON_MEMORY; + temp->text = rcs_unwrap (info->lex_text), info->lex_text = NULL; + if (json_insert_child (info->cursor, temp) != JSON_OK) + { + /*TODO return value according to the value returned from json_insert_child() */ + return JSON_UNKNOWN_PROBLEM; + } + info->cursor = temp; + temp = NULL; + info->state = 5; /* label, pre label:value separator */ + break; + + case LEX_END_OBJECT: + if (info->cursor->parent == NULL) + { + info->state = 99; /* finished document. only accept whitespaces until EOF */ + } + else + { + info->cursor = info->cursor->parent; + switch (info->cursor->type) + { + case JSON_STRING: + info->cursor = info->cursor->parent; + if (info->cursor->type != JSON_OBJECT) + { + return JSON_BAD_TREE_STRUCTURE; + } + else + { + info->state = 3; /* finished adding a field to an object */ + } + break; + + case JSON_ARRAY: + info->state = 9; + break; + + default: + return JSON_BAD_TREE_STRUCTURE; + } + } + break; + + case LEX_MORE: + return JSON_INCOMPLETE_DOCUMENT; + break; + + default: + printf ("state %d: defaulted\n", info->state); + return JSON_MALFORMED_DOCUMENT; + break; + } + } + break; + + case 3: /* finished adding a field to an object */ + { + switch (lexer (buffer, &info->p, &info->lex_state, & info->lex_text)) + { + case LEX_VALUE_SEPARATOR: + info->state = 4; /* sibling, post-object */ + break; + + case LEX_END_OBJECT: + if (info->cursor->parent == NULL) + { + info->state = 99; /* parse until EOF */ + } + else + { + info->cursor = info->cursor->parent; + switch (info->cursor->type) + { + case JSON_STRING: + info->cursor = info->cursor->parent; + if (info->cursor->type != JSON_OBJECT) + { + return JSON_BAD_TREE_STRUCTURE; + } + else + { + info->state = 3; /* finished adding a field to an object */ + } + break; + + case JSON_ARRAY: + info->state = 9; + break; + + default: + return JSON_BAD_TREE_STRUCTURE; + } + } + break; + + case LEX_MORE: + return JSON_INCOMPLETE_DOCUMENT; + break; + + default: + printf ("state %d: defaulted\n", info->state); + return JSON_MALFORMED_DOCUMENT; + break; + } + } + break; + + case 4: /* sibling, post-object */ + { + switch (lexer (buffer, &info->p, &info->lex_state, & info->lex_text)) + { + case LEX_STRING: + if ((temp = json_new_value (JSON_STRING)) == NULL) + return JSON_MEMORY; + temp->text = rcs_unwrap (info->lex_text), info->lex_text = NULL; + if (json_insert_child (info->cursor, temp) != JSON_OK) + { + return JSON_UNKNOWN_PROBLEM; + } + info->cursor = temp; + temp = NULL; + info->state = 5; + break; + + case LEX_MORE: + return JSON_INCOMPLETE_DOCUMENT; + break; + + case LEX_INVALID_CHARACTER: + return JSON_ILLEGAL_CHARACTER; + break; + + default: + printf ("state %d: defaulted\n", info->state); + return JSON_MALFORMED_DOCUMENT; + break; + } + } + break; + + case 5: /* label, pre name separator */ + { + switch (lexer (buffer, &info->p, &info->lex_state, & info->lex_text)) + { + case LEX_NAME_SEPARATOR: + info->state = 6; /* label, pos label:value separator */ + break; + + case LEX_MORE: + return JSON_INCOMPLETE_DOCUMENT; + break; + + default: + printf ("state %d: defaulted\n", info->state); + return JSON_MALFORMED_DOCUMENT; + break; + } + } + break; + + case 6: /* label, pos name separator */ + { + unsigned int value; /* to avoid redundant code */ + + switch (value = lexer (buffer, &info->p, &info->lex_state, & info->lex_text)) + { + case LEX_STRING: + if ((temp = json_new_value (JSON_STRING)) == NULL) + return JSON_MEMORY; + temp->text = rcs_unwrap (info->lex_text), info->lex_text = NULL; + if (json_insert_child (info->cursor, temp) != JSON_OK) + { + /*TODO specify the exact error message */ + return JSON_UNKNOWN_PROBLEM; + } + if (info->cursor->parent == NULL) + { + info->state = 99; /* finished document. only accepts whitespaces until EOF */ + } + else + { + info->cursor = info->cursor->parent; + } + temp = NULL; + info->state = 3; /* finished adding a field to an object */ + break; + + case LEX_NUMBER: + if ((temp = json_new_value (JSON_NUMBER)) == NULL) + return JSON_MEMORY; + temp->text = rcs_unwrap (info->lex_text), info->lex_text = NULL; + if (json_insert_child (info->cursor, temp) != JSON_OK) + { + /*TODO specify the exact error message */ + return JSON_UNKNOWN_PROBLEM; + } + if (info->cursor->parent == NULL) + { + info->state = 99; /* finished document. only accepts whitespaces until EOF */ + } + else + { + info->cursor = info->cursor->parent; + } + temp = NULL; + info->state = 3; /* finished adding a field to an object */ + break; + + case LEX_TRUE: + if ((temp = json_new_value (JSON_TRUE)) == NULL) + return JSON_MEMORY; + if (json_insert_child (info->cursor, temp) != JSON_OK) + { + /*TODO specify the exact error message */ + return JSON_UNKNOWN_PROBLEM; + } + if (info->cursor->parent == NULL) + { + info->state = 99; /* finished document. only accepts whitespaces until EOF */ + } + else + { + info->cursor = info->cursor->parent; + } + temp = NULL; + info->state = 3; /* finished adding a field to an object */ + break; + + case LEX_FALSE: + if ((temp = json_new_value (JSON_FALSE)) == NULL) + return JSON_MEMORY; + if (json_insert_child (info->cursor, temp) != JSON_OK) + { + /*TODO specify the exact error message */ + return JSON_UNKNOWN_PROBLEM; + } + if (info->cursor->parent == NULL) + { + info->state = 99; /* finished document. only accepts whitespaces until EOF */ + } + else + { + info->cursor = info->cursor->parent; + } + temp = NULL; + info->state = 3; /* finished adding a field to an object */ + break; + + case LEX_NULL: + if ((temp = json_new_value (JSON_NULL)) == NULL) + return JSON_MEMORY; + if (json_insert_child (info->cursor, temp) != JSON_OK) + { + /*TODO specify the exact error message */ + return JSON_UNKNOWN_PROBLEM; + } + if (info->cursor->parent == NULL) + { + info->state = 99; /* finished document. only accepts whitespaces until EOF */ + } + else + { + info->cursor = info->cursor->parent; + } + temp = NULL; + info->state = 3; /* finished adding a field to an object */ + break; + + case LEX_BEGIN_OBJECT: + info->state = 1; + break; + + case LEX_BEGIN_ARRAY: + info->state = 7; + break; + + case LEX_MORE: + return JSON_INCOMPLETE_DOCUMENT; + break; + + case LEX_MEMORY: + return JSON_MEMORY; + break; + + case LEX_INVALID_CHARACTER: + return JSON_ILLEGAL_CHARACTER; + break; + + default: + printf ("state %d: defaulted\n", info->state); + return JSON_MALFORMED_DOCUMENT; + break; + } + } + break; + + case 7: /* open array */ + { + if (info->cursor == NULL) + { + if ((info->cursor = json_new_array ()) == NULL) + { + return JSON_MEMORY; + } + } + else + { + if ((temp = json_new_array ()) == NULL) + { + return JSON_MEMORY; + } + if (json_insert_child (info->cursor, temp) != JSON_OK) + { + return JSON_UNKNOWN_PROBLEM; + } + info->cursor = temp; + temp = NULL; + } + info->state = 8; /* just entered an array */ + } + break; + + case 8: /* just entered an array */ + { + switch (lexer (buffer, &info->p, &info->lex_state, & info->lex_text)) + { + case LEX_STRING: + if ((temp = json_new_value (JSON_STRING)) == NULL) + return JSON_MEMORY; + temp->text = rcs_unwrap (info->lex_text), info->lex_text = NULL; + if (json_insert_child (info->cursor, temp) != JSON_OK) + { + return JSON_UNKNOWN_PROBLEM; + } + temp = NULL; + info->state = 9; /* label, pre label:value separator */ + break; + + case LEX_NUMBER: + if ((temp = json_new_value (JSON_NUMBER)) == NULL) + return JSON_MEMORY; + temp->text = rcs_unwrap (info->lex_text), info->lex_text = NULL; + if (json_insert_child (info->cursor, temp) != JSON_OK) + { + return JSON_UNKNOWN_PROBLEM; + } + temp = NULL; + info->state = 9; /* label, pre label:value separator */ + break; + + case LEX_TRUE: + if ((temp = json_new_value (JSON_TRUE)) == NULL) + return JSON_MEMORY; + if (json_insert_child (info->cursor, temp) != JSON_OK) + { + return JSON_UNKNOWN_PROBLEM; + } + info->state = 9; /* label, pre label:value separator */ + break; + + case LEX_FALSE: + if ((temp = json_new_value (JSON_FALSE)) == NULL) + return JSON_MEMORY; + if (json_insert_child (info->cursor, temp) != JSON_OK) + { + return JSON_UNKNOWN_PROBLEM; + } + info->state = 9; /* label, pre label:value separator */ + break; + + case LEX_NULL: + if ((temp = json_new_value (JSON_NULL)) == NULL) + return JSON_MEMORY; + if (json_insert_child (info->cursor, temp) != JSON_OK) + { + return JSON_UNKNOWN_PROBLEM; + } + info->state = 9; /* label, pre label:value separator */ + break; + + case LEX_BEGIN_ARRAY: + info->state = 7; /* open array */ + break; + + case LEX_END_ARRAY: + if (info->cursor->parent == NULL) + { + /*TODO implement this */ + info->state = 99; /* finished document. only accept whitespaces until EOF */ + } + else + { + info->cursor = info->cursor->parent; + switch (info->cursor->type) + { + case JSON_STRING: + if (info->cursor->parent == NULL) + return JSON_BAD_TREE_STRUCTURE; + else + { + info->cursor = info->cursor->parent; + if (info->cursor->type != JSON_OBJECT) + { + return JSON_BAD_TREE_STRUCTURE; + } + + info->state = 3; /* followup to adding child to array */ + } + break; + + case JSON_ARRAY: + info->state = 9; /* followup to adding child to array */ + break; + + default: + return JSON_BAD_TREE_STRUCTURE; + } + } + break; + + case LEX_BEGIN_OBJECT: + info->state = 1; /* open object */ + break; + + case LEX_MORE: + return JSON_INCOMPLETE_DOCUMENT; + break; + + case LEX_INVALID_CHARACTER: + return JSON_ILLEGAL_CHARACTER; + break; + + default: + printf ("state %d: defaulted\n", info->state); + return JSON_MALFORMED_DOCUMENT; + break; + } + } + break; + + case 9: /* followup to adding child to array */ + { + switch (lexer (buffer, &info->p, &info->lex_state, & info->lex_text)) + { + case LEX_VALUE_SEPARATOR: + info->state = 8; + break; + + case LEX_END_ARRAY: + if (info->cursor->parent == NULL) + { + info->state = 99; /* finished document. only accept whitespaces until EOF */ + } + else + { + info->cursor = info->cursor->parent; + switch (info->cursor->type) + { + case JSON_STRING: + if (info->cursor->parent == NULL) + { + info->state = 99; /* finished document. only accept whitespaces until EOF */ + } + else + { + info->cursor = info->cursor->parent; + if (info->cursor->type != JSON_OBJECT) + { + return JSON_BAD_TREE_STRUCTURE; + } + else + { + info->state = 3; /* followup to adding child to array */ + } + } + break; + + case JSON_ARRAY: + info->state = 9; /* followup to adding child to array */ + break; + + default: + return JSON_BAD_TREE_STRUCTURE; + } + } + break; + + case LEX_MORE: + return JSON_INCOMPLETE_DOCUMENT; + break; + + default: + printf ("state %d: defaulted\n", info->state); + return JSON_MALFORMED_DOCUMENT; + break; + } + } + break; + + case 99: /* finished document. only accept whitespaces until EOF */ + { + switch (lexer (buffer, &info->p, &info->lex_state, & info->lex_text)) + { + case LEX_MORE: + return JSON_WAITING_FOR_EOF; + break; + + case LEX_MEMORY: + return JSON_MEMORY; + break; + + default: + return JSON_MALFORMED_DOCUMENT; + break; + } + } + break; + + default: + printf ("invalid parser state %d: defaulted\n", info->state); + return JSON_UNKNOWN_PROBLEM; + } + } + info->p = NULL; + if (info->state == 99) + return JSON_WAITING_FOR_EOF; + else + return JSON_INCOMPLETE_DOCUMENT; +} + + + +enum json_error +json_parse_document (json_t ** root, const char *text) +{ + enum json_error error; + struct json_parsing_info *jpi; + + /* initialize the parsing structure */ + if (VIR_ALLOC(jpi) < 0) + { + return JSON_MEMORY; + } + json_jpi_init (jpi); + + error = json_parse_fragment (jpi, text); + if ((error == JSON_WAITING_FOR_EOF) || (error == JSON_OK)) + { + *root = jpi->cursor; + VIR_FREE(jpi); + return JSON_OK; + } + else + { + VIR_FREE(jpi); + return error; + } +} + + +enum json_error +json_saxy_parse (struct json_saxy_parser_status *jsps, struct json_saxy_functions *jsf, char c) +{ + /*TODO handle a string instead of a single char */ + /* temp variables */ + rcstring *temp; + + temp = NULL; + + /* goto where we left off */ + switch (jsps->state) + { + case 0: /* general state. everything goes. */ + goto state0; + break; + case 1: /* parse string */ + goto state1; + break; + case 2: /* parse string: escaped character */ + goto state2; + break; + case 3: /* parse string: escaped unicode 1 */ + goto state3; + break; + case 4: /* parse string: escaped unicode 2 */ + goto state4; + break; + case 5: /* parse string: escaped unicode 3 */ + goto state5; + break; + case 6: /* parse string: escaped unicode 4 */ + goto state6; + break; + case 7: /* parse true: tr */ + goto state7; + break; + case 8: /* parse true: tru */ + goto state8; + break; + case 9: /* parse true: true */ + goto state9; + break; + case 10: /* parse false: fa */ + goto state10; + break; + case 11: /* parse false: fal */ + goto state11; + break; + case 12: /* parse false: fals */ + goto state12; + break; + case 13: /* parse false: false */ + goto state13; + break; + case 14: /* parse null: nu */ + goto state14; + break; + case 15: /* parse null: nul */ + goto state15; + break; + case 16: /* parse null: null */ + goto state16; + break; + case 17: /* parse number: 0 */ + goto state17; + break; + case 18: /* parse number: start fraccional part */ + goto state18; + break; + case 19: /* parse number: fraccional part */ + goto state19; + break; + case 20: /* parse number: start exponent part */ + goto state20; + break; + case 21: /* parse number: exponent part */ + goto state21; + break; + case 22: /* parse number: exponent sign part */ + goto state22; + break; + case 23: /* parse number: start negative */ + goto state23; + break; + case 24: /* parse number: decimal part */ + goto state24; + break; + case 25: /* open object */ + goto state25; + break; + case 26: /* close object/array */ + goto state26; + break; + case 27: /* sibling followup */ + goto state27; + break; + + default: /* oops... this should never be reached */ + return JSON_UNKNOWN_PROBLEM; + } + +state0: /* starting point */ + { + switch (c) + { + case '\x20': + case '\x09': + case '\x0A': + case '\x0D': /* JSON insignificant white spaces */ + break; + + case '\"': /* starting a string */ + jsps->string_length_limit_reached = 0; + jsps->state = 1; + break; + + case '{': + if (jsf->open_object != NULL) + jsf->open_object (); + jsps->state = 25; /*open object */ + break; + + case '}': + if (jsf->close_object != NULL) + jsf->close_object (); + jsps->state = 26; /* close object/array */ + break; + + case '[': + if (jsf->open_array != NULL) + jsf->open_array (); +/* jsps->state = 0; // redundant*/ + break; + + case ']': + if (jsf->close_array != NULL) + jsf->close_array (); + jsps->state = 26; /* close object/array */ + break; + + case 't': + jsps->state = 7; /* parse true: tr */ + break; + + case 'f': + jsps->state = 10; /* parse false: fa */ + break; + + case 'n': + jsps->state = 14; /* parse null: nu */ + break; + + case ':': + if (jsf->label_value_separator != NULL) + jsf->label_value_separator (); +/* jsps->state = 0; // redundant*/ + break; + + case ',': + if (jsf->sibling_separator != NULL) + jsf->sibling_separator (); + jsps->state = 27; /* sibling followup */ + break; + + case '0': + jsps->string_length_limit_reached = 0; + jsps->state = 17; /* parse number: 0 */ + if ((jsps->temp = rcs_create (5)) == NULL) + { + return JSON_MEMORY; + } + if (rcs_catc ((jsps->temp), '0') != RS_OK) + { + return JSON_MEMORY; + } + break; + + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + jsps->string_length_limit_reached = 0; + jsps->state = 24; /* parse number: decimal */ + if ((jsps->temp = rcs_create (5)) == NULL) + { + return JSON_MEMORY; + } + if (rcs_catc ((jsps->temp), c) != RS_OK) + { + return JSON_MEMORY; + } + break; + + case '-': + jsps->string_length_limit_reached = 0; + jsps->state = 23; /* number: */ + jsps->temp = NULL; + if ((jsps->temp = rcs_create (5)) == NULL) + { + return JSON_MEMORY; + } + if (rcs_catc ((jsps->temp), '-') != RS_OK) + { + return JSON_MEMORY; + } + + break; + + default: + return JSON_ILLEGAL_CHARACTER; + break; + } + return JSON_OK; + } + +state1: /* parse string */ + { + switch (c) + { + case '\\': + if (!jsps->string_length_limit_reached) + { + if (rcs_length ((jsps->temp)) < JSON_MAX_STRING_LENGTH - 1) /* check if there is space for a two character escape sequence */ + { + if (rcs_catc ((jsps->temp), '\\') != RS_OK) + { + return JSON_MEMORY; + } + } + else + { + jsps->string_length_limit_reached = 1; + } + } + jsps->state = 2; /* parse string: escaped character */ + break; + + case '\"': /* end of string */ + if ((jsps->temp) != NULL) + { + jsps->state = 0; /* starting point */ + if (jsf->new_string != NULL) + jsf->new_string (((jsps->temp))->text); /*copied or integral? */ + rcs_free (& jsps->temp); + } + else + return JSON_UNKNOWN_PROBLEM; + break; + + default: + if (!jsps->string_length_limit_reached) + { + if (rcs_length ((jsps->temp)) < JSON_MAX_STRING_LENGTH) /* check if there is space for a two character escape sequence */ + { + if (rcs_catc ((jsps->temp), c) != RS_OK) + { + return JSON_MEMORY; + } + } + else + { + jsps->string_length_limit_reached = 1; + } + } + break; + } + return JSON_OK; + } + +state2: /* parse string: escaped character */ + { + switch (c) + { + case '\"': + case '\\': + case '/': + case 'b': + case 'f': + case 'n': + case 'r': + case 't': + if (!jsps->string_length_limit_reached) + { + if (rcs_length ((jsps->temp)) < JSON_MAX_STRING_LENGTH) + { + if (rcs_catc ((jsps->temp), c) != RS_OK) + { + return JSON_MEMORY; + } + } + else + { + jsps->string_length_limit_reached = 1; + } + } + break; + + case 'u': + if (!jsps->string_length_limit_reached) + { + if (rcs_length ((jsps->temp)) < JSON_MAX_STRING_LENGTH - 4) + { + if (rcs_catc ((jsps->temp), 'u') != RS_OK) + { + return JSON_MEMORY; + } + } + else + { + jsps->string_length_limit_reached = 1; + } + } + jsps->state = 3; /* parse string: escaped unicode 1; */ + break; + + default: + return JSON_ILLEGAL_CHARACTER; + break; + } + return JSON_OK; + } + +state3: /* parse string: escaped unicode 1 */ + { + switch (c) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + if (!jsps->string_length_limit_reached) + { + if (rcs_length ((jsps->temp)) < JSON_MAX_STRING_LENGTH - 3) + { + if (rcs_catc ((jsps->temp), 'u') != RS_OK) + { + return JSON_MEMORY; + } + } + else + { + jsps->string_length_limit_reached = 1; + } + } + jsps->state = 4; /* parse string. escaped unicode 2 */ + break; + + default: + return JSON_ILLEGAL_CHARACTER; + } + return JSON_OK; + } + +state4: /* parse string: escaped unicode 2 */ + { + switch (c) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + if (!jsps->string_length_limit_reached) + { + if (rcs_length ((jsps->temp)) < JSON_MAX_STRING_LENGTH - 2) + { + if (rcs_catc ((jsps->temp), c) != RS_OK) + { + return JSON_MEMORY; + } + } + else + { + jsps->string_length_limit_reached = 1; + } + } + jsps->state = 5; /* parse string. escaped unicode 3 */ + break; + + default: + return JSON_ILLEGAL_CHARACTER; + } + return JSON_OK; + } + +state5: /* parse string: escaped unicode 3 */ + { + switch (c) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + if (!jsps->string_length_limit_reached) + { + if (rcs_length ((jsps->temp)) < JSON_MAX_STRING_LENGTH - 1) + { + if (rcs_catc ((jsps->temp), c) != RS_OK) + { + return JSON_MEMORY; + } + } + else + { + jsps->string_length_limit_reached = 1; + } + } + jsps->state = 6; /* parse string. escaped unicode 4 */ + break; + + default: + return JSON_ILLEGAL_CHARACTER; + } + return JSON_OK; + } + +state6: /* parse string: escaped unicode 4 */ + { + switch (c) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + if (!jsps->string_length_limit_reached) + { + if (rcs_length ((jsps->temp)) < JSON_MAX_STRING_LENGTH) + { + if (rcs_catc ((jsps->temp), c) != RS_OK) + { + return JSON_MEMORY; + } + } + else + { + jsps->string_length_limit_reached = 1; + } + } + jsps->state = 1; /* parse string */ + break; + + default: + return JSON_ILLEGAL_CHARACTER; + } + return JSON_OK; + } + +state7: /* parse true: tr */ + { + if (c != 'r') + { + return JSON_ILLEGAL_CHARACTER; + } + + jsps->state = 8; /* parse true: tru */ + return JSON_OK; + } + +state8: /* parse true: tru */ + { + if (c != 'u') + { + return JSON_ILLEGAL_CHARACTER; + } + + jsps->state = 9; /* parse true: true */ + return JSON_OK; + } + +state9: /* parse true: true */ + { + if (c != 'e') + { + return JSON_ILLEGAL_CHARACTER; + } + + jsps->state = 0; /* back to general state. */ + if (jsf->new_true != NULL) + jsf->new_true (); + return JSON_OK; + } + +state10: /* parse false: fa */ + { + if (c != 'a') + { + return JSON_ILLEGAL_CHARACTER; + } + + jsps->state = 11; /* parse true: fal */ + return JSON_OK; + } + +state11: /* parse false: fal */ + { + if (c != 'l') + { + return JSON_ILLEGAL_CHARACTER; + } + + jsps->state = 12; /* parse true: fals */ + return JSON_OK; + } + +state12: /* parse false: fals */ + { + if (c != 's') + { + return JSON_ILLEGAL_CHARACTER; + } + + jsps->state = 13; /* parse true: false */ + return JSON_OK; + } + +state13: /* parse false: false */ + { + if (c != 'e') + { + return JSON_ILLEGAL_CHARACTER; + } + + jsps->state = 0; /* general state. everything goes. */ + if (jsf->new_false != NULL) + jsf->new_false (); + return JSON_OK; + } + +state14: /* parse null: nu */ + { + if (c != 'u') + { + return JSON_ILLEGAL_CHARACTER; + } + + jsps->state = 15; /* parse null: nul */ + return JSON_OK; + } + +state15: /* parse null: nul */ + { + if (c != 'l') + { + return JSON_ILLEGAL_CHARACTER; + } + + jsps->state = 16; /* parse null: null */ + return JSON_OK; + } + +state16: /* parse null: null */ + { + if (c != 'l') + { + return JSON_ILLEGAL_CHARACTER; + } + + jsps->state = 0; /* general state. everything goes. */ + if (jsf->new_null != NULL) + jsf->new_null (); + return JSON_OK; + } + +state17: /* parse number: 0 */ + { + switch (c) + { + case '.': + if ((jsps->temp = rcs_create (5)) == NULL) + { + return JSON_MEMORY; + } + if (rcs_catc ((jsps->temp), '.') != RS_OK) + { + return JSON_MEMORY; + } + jsps->state = 18; /* parse number: fraccional part */ + break; + + case '\x20': + case '\x09': + case '\x0A': + case '\x0D': /* JSON insignificant white spaces */ + if ((jsps->temp) == NULL) + return JSON_MEMORY; + if (jsf->new_number != NULL) + { + jsf->new_number ((jsps->temp)->text); + } + rcs_free (& jsps->temp); + + jsps->state = 0; + break; + + case '}': + if ((jsps->temp) == NULL) + return JSON_MEMORY; + if (jsf->new_number != NULL) + { + jsf->new_number ((jsps->temp)->text); + } + rcs_free (& jsps->temp); + + if (jsf->open_object != NULL) + jsf->close_object (); + jsps->state = 26; /* close object/array */ + break; + + case ']': + + if ((jsps->temp) == NULL) + return JSON_MEMORY; + if (jsf->new_number != NULL) + { + jsf->new_number ((jsps->temp)->text); + } + rcs_free (& jsps->temp); + + if (jsf->open_object != NULL) + jsf->close_array (); + jsps->state = 26; /* close object/array */ + break; + + case ',': + + if ((jsps->temp) == NULL) + return JSON_MEMORY; + if (jsf->new_number != NULL) + { + jsf->new_number ((jsps->temp)->text); + } + rcs_free (& jsps->temp); + + if (jsf->open_object != NULL) + jsf->label_value_separator (); + jsps->state = 27; /* sibling followup */ + break; + + default: + return JSON_ILLEGAL_CHARACTER; + break; + } + + return JSON_OK; + } + +state18: /* parse number: start fraccional part */ + { + switch (c) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (!jsps->string_length_limit_reached) + { + if (rcs_length ((jsps->temp)) < JSON_MAX_STRING_LENGTH / 2) + { + if (rcs_catc ((jsps->temp), c) != RS_OK) + { + return JSON_MEMORY; + } + } + else + { + jsps->string_length_limit_reached = 1; + } + } + jsps->state = 19; /* parse number: fractional part */ + break; + + default: + return JSON_ILLEGAL_CHARACTER; + break; + } + return JSON_OK; + } + +state19: /* parse number: fraccional part */ + { + switch (c) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (!jsps->string_length_limit_reached) + { + if (rcs_length ((jsps->temp)) < JSON_MAX_STRING_LENGTH / 2) + { + if (rcs_catc ((jsps->temp), c) != RS_OK) + { + return JSON_MEMORY; + } + } + else + { + jsps->string_length_limit_reached = 1; + } + } +/* jsps->state = 19; // parse number: fractional part*/ + break; + + case 'e': + case 'E': + if (rcs_catc ((jsps->temp), c) != RS_OK) + { + return JSON_MEMORY; + } + + jsps->state = 20; /* parse number: start exponent part */ + break; + + + case '\x20': + case '\x09': + case '\x0A': + case '\x0D': /* JSON insignificant white spaces */ + + if ((jsps->temp) == NULL) + return JSON_MEMORY; + if (jsf->new_number != NULL) + { + jsf->new_number ((jsps->temp)->text); + } + rcs_free (& jsps->temp); + + jsps->state = 0; + break; + + case '}': + + if ((jsps->temp) == NULL) + return JSON_MEMORY; + if (jsf->new_number != NULL) + { + jsf->new_number ((jsps->temp)->text); + } + rcs_free (& jsps->temp); + + if (jsf->open_object != NULL) + jsf->close_object (); + jsps->state = 26; /* close object/array */ + break; + + case ']': + if (jsf->new_number != NULL) + { + if ((jsps->temp) == NULL) + return JSON_MEMORY; + jsf->new_number ((jsps->temp)->text); + rcs_free (& jsps->temp); + } + else + { + rcs_free (& jsps->temp); + jsps->temp = NULL; + } + if (jsf->open_object != NULL) + jsf->close_array (); + jsps->state = 26; /* close object/array */ + break; + + case ',': + + if ((jsps->temp) == NULL) + return JSON_MEMORY; + if (jsf->new_number != NULL) + { + jsf->new_number ((jsps->temp)->text); + } + rcs_free (& jsps->temp); + + if (jsf->label_value_separator != NULL) + jsf->label_value_separator (); + jsps->state = 27; /* sibling followup */ + break; + + + default: + return JSON_ILLEGAL_CHARACTER; + break; + } + return JSON_OK; + } + +state20: /* parse number: start exponent part */ + { + switch (c) + { + case '+': + case '-': + jsps->string_length_limit_reached = 0; + if (rcs_catc ((jsps->temp), c) != RS_OK) + { + return JSON_MEMORY; + } + + jsps->state = 22; /* parse number: exponent sign part */ + break; + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (!jsps->string_length_limit_reached) + { + if (rcs_length ((jsps->temp)) < JSON_MAX_STRING_LENGTH) + { + if (rcs_catc ((jsps->temp), c) != RS_OK) + { + return JSON_MEMORY; + } + + } + else + { + jsps->string_length_limit_reached = 1; + } + } + jsps->state = 21; /* parse number: exponent part */ + break; + + default: + return JSON_ILLEGAL_CHARACTER; + break; + } + return JSON_OK; + } + +state21: /* parse number: exponent part */ + { + switch (c) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (!jsps->string_length_limit_reached) + { + if (rcs_length ((jsps->temp)) < JSON_MAX_STRING_LENGTH) + { + if (rcs_catc ((jsps->temp), c) != RS_OK) + { + return JSON_MEMORY; + } + } + else + { + jsps->string_length_limit_reached = 1; + } + } +/* jsps->state = 21; // parse number: exponent part*/ + break; + + case '\x20': + case '\x09': + case '\x0A': + case '\x0D': /* JSON insignificant white spaces */ + + if ((jsps->temp) == NULL) + return JSON_MEMORY; + if (jsf->new_number != NULL) + { + jsf->new_number ((jsps->temp)->text); + } + rcs_free (& jsps->temp); + + jsps->state = 0; + break; + + case '}': + if ((jsps->temp) == NULL) + return JSON_MEMORY; + if (jsf->new_number != NULL) + { + jsf->new_number ((jsps->temp)->text); + } + rcs_free (& jsps->temp); + + if (jsf->open_object != NULL) + jsf->close_object (); + jsps->state = 26; /* close object */ + break; + + case ']': + if (jsf->new_number != NULL) + { + if ((jsps->temp) == NULL) + return JSON_MEMORY; + jsf->new_number ((jsps->temp)->text); + free (jsps->temp); + jsps->temp = NULL; + } + else + { + free ((jsps->temp)); + jsps->temp = NULL; + } + if (jsf->open_object != NULL) + jsf->close_array (); + jsps->state = 26; /* close object/array */ + break; + + case ',': + if (jsf->new_number != NULL) + { + if ((jsps->temp) == NULL) + return JSON_MEMORY; + jsf->new_number ((jsps->temp)->text); + free ((jsps->temp)); + jsps->temp = NULL; + } + else + { + free (jsps->temp); + jsps->temp = NULL; + } + if (jsf->label_value_separator != NULL) + jsf->label_value_separator (); + jsps->state = 27; /* sibling followup */ + break; + + default: + return JSON_ILLEGAL_CHARACTER; + break; + } + return JSON_OK; + } + +state22: /* parse number: start exponent part */ + { + switch (c) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (!jsps->string_length_limit_reached) + { + if (rcs_length ((jsps->temp)) < JSON_MAX_STRING_LENGTH) + { + rcs_catc ((jsps->temp), c); + } + else + { + jsps->string_length_limit_reached = 1; + } + } + jsps->state = 21; /* parse number: exponent part */ + break; + + default: + return JSON_ILLEGAL_CHARACTER; + break; + } + return JSON_OK; + } + +state23: /* parse number: start negative */ + { + switch (c) + { + case '0': + rcs_catc ((jsps->temp), c); + jsps->state = 17; /* parse number: 0 */ + break; + + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (!jsps->string_length_limit_reached) + { + if (rcs_length ((jsps->temp)) < JSON_MAX_STRING_LENGTH / 2) + { + if ((jsps->temp = rcs_create (5)) == NULL) + { + return JSON_MEMORY; + } + if (rcs_catc ((jsps->temp), c) != RS_OK) + { + return JSON_MEMORY; + } + else + { + jsps->string_length_limit_reached = 1; + } + } + } + jsps->state = 24; /* parse number: start decimal part */ + break; + + default: + return JSON_ILLEGAL_CHARACTER; + break; + } + return JSON_OK; + } + +state24: /* parse number: decimal part */ + { + switch (c) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (!jsps->string_length_limit_reached) + { + if (rcs_length ((jsps->temp)) < JSON_MAX_STRING_LENGTH / 2) + { + if ((jsps->temp = rcs_create (5)) == NULL) + { + return JSON_MEMORY; + } + if (rcs_catc ((jsps->temp), c) != RS_OK) + { + return JSON_MEMORY; + } + } + else + { + jsps->string_length_limit_reached = 1; + } + } +/* jsps->state = 24; // parse number: decimal part*/ + break; + + case '.': + if ((jsps->temp = rcs_create (5)) == NULL) + { + return JSON_MEMORY; + } + if (rcs_catc ((jsps->temp), '.') != RS_OK) + { + return JSON_MEMORY; + } + + jsps->state = 18; /* parse number: start exponent part */ + break; + + case 'e': + case 'E': + if ((jsps->temp = rcs_create (5)) == NULL) + { + return JSON_MEMORY; + } + if (rcs_catc ((jsps->temp), c) != RS_OK) + { + return JSON_MEMORY; + } + + jsps->string_length_limit_reached = 0; /* reset to accept the exponential part */ + jsps->state = 20; /* parse number: start exponent part */ + break; + + case '\x20': + case '\x09': + case '\x0A': + case '\x0D': /* JSON insignificant white spaces */ + if ((jsps->temp) == NULL) + return JSON_MEMORY; + if (jsf->new_number != NULL) + { + jsf->new_number ((jsps->temp)->text); + } + rcs_free (& jsps->temp); + + jsps->state = 0; + break; + + case '}': + if ((jsps->temp) == NULL) + return JSON_MEMORY; + if (jsf->new_number != NULL) + { + jsf->new_number ((jsps->temp)->text); + } + rcs_free (& jsps->temp); + + if (jsf->open_object != NULL) + jsf->close_object (); + jsps->state = 26; /* close object/array */ + break; + + case ']': + if ((jsps->temp) == NULL) + return JSON_MEMORY; + if (jsf->new_number != NULL) + { + jsf->new_number ((jsps->temp)->text); + } + rcs_free (& jsps->temp); + + if (jsf->open_object != NULL) + jsf->close_array (); + jsps->state = 26; /* close object/array */ + break; + + case ',': + if ((jsps->temp) == NULL) + return JSON_MEMORY; + if (jsf->new_number != NULL) + { + jsf->new_number ((jsps->temp)->text); + } + rcs_free (& jsps->temp); + + if (jsf->label_value_separator != NULL) + jsf->label_value_separator (); + jsps->state = 27; /* sibling followup */ + break; + + default: + return JSON_ILLEGAL_CHARACTER; + break; + } + return JSON_OK; + } + +state25: /* open object */ + { + switch (c) + { + case '\x20': + case '\x09': + case '\x0A': + case '\x0D': /* JSON insignificant white spaces */ + break; + + case '\"': + jsps->temp = NULL; + jsps->state = 1; + break; + + case '}': + if (jsf->close_object != NULL) + jsf->close_object (); + jsps->state = 26; /* close object */ + break; + + default: + return JSON_ILLEGAL_CHARACTER; + break; + } + return JSON_OK; + } + +state26: /* close object/array */ + { + switch (c) + { + case '\x20': + case '\x09': + case '\x0A': + case '\x0D': /* JSON insignificant white spaces */ + break; + + case '}': + if (jsf->close_object != NULL) + jsf->close_object (); +/* jsp->state = 26; // close object*/ + break; + + case ']': + if (jsf->close_array != NULL) + jsf->close_array (); +/* jsps->state = 26; // close object/array*/ + break; + + case ',': + if (jsf->sibling_separator != NULL) + jsf->sibling_separator (); + jsps->state = 27; /* sibling followup */ + break; + + default: + return JSON_ILLEGAL_CHARACTER; + break; + } + return JSON_OK; + } + +state27: /* sibling followup */ + { + switch (c) + { + case '\x20': + case '\x09': + case '\x0A': + case '\x0D': /* JSON insignificant white spaces */ + break; + + case '\"': + jsps->state = 1; + jsps->temp = NULL; + break; + + case '{': + if (jsf->open_object != NULL) + jsf->open_object (); + jsps->state = 25; /*open object */ + break; + + case '[': + if (jsf->open_array != NULL) + jsf->open_array (); +/* jsps->state = 0; // redundant*/ + break; + + case 't': + jsps->state = 7; /* parse true: tr */ + break; + + case 'f': + jsps->state = 10; /* parse false: fa */ + break; + + case 'n': + jsps->state = 14; /* parse null: nu */ + break; + + case '0': + jsps->state = 17; /* parse number: 0 */ + if ((jsps->temp = rcs_create (5)) == NULL) + { + return JSON_MEMORY; + } + if (rcs_catc ((jsps->temp), '0') != RS_OK) + { + return JSON_MEMORY; + } + break; + + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + jsps->state = 24; /* parse number: decimal */ + if ((jsps->temp = rcs_create (5)) == NULL) + { + return JSON_MEMORY; + } + if (rcs_catc ((jsps->temp), c) != RS_OK) + { + return JSON_MEMORY; + } + break; + + case '-': + jsps->state = 23; /* number: */ + if ((jsps->temp = rcs_create (RSTRING_DEFAULT)) == NULL) + { + return JSON_MEMORY; + } + if (rcs_catc ((jsps->temp), '-') != RS_OK) + { + return JSON_MEMORY; + } + break; + + default: + return JSON_ILLEGAL_CHARACTER; + break; + } + return JSON_OK; + } + + return JSON_UNKNOWN_PROBLEM; +} + + +enum json_error +json_find_first_label (const json_t * object, const char *text_label, json_t **value) +{ + json_t *cursor; + + for (cursor = object->child; cursor != NULL; cursor = cursor->next) + { + if (strcmp (cursor->text, text_label) == 0) { + *value = cursor; + return JSON_OK; + } + } + *value = NULL; + return JSON_UNKNOWN_PROBLEM; +} + diff --git a/src/util/json.h b/src/util/json.h new file mode 100644 index 0000000..c093816 --- /dev/null +++ b/src/util/json.h @@ -0,0 +1,311 @@ +/*************************************************************************** + * Copyright (C) 2007 by Rui Maciel * + * rui.maciel(a)gmail.com * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU Library General Public License as * + * published by the Free Software Foundation; either version 2 of the * + * License, or (at your option) any later version. * + * * + * This program 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 General Public License for more details. * + * * + * You should have received a copy of the GNU Library General Public * + * License along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + ***************************************************************************/ + +/** @file json.h A small library that helps deal with JSON-encoded information + \ingroup JSON + + \note error handling is only in a very rudimentary form. + \author Rui Maciel rui_maciel(a)users.sourceforge.net + \version v1.1 +*/ + +#include <stdint.h> +#include <stdio.h> + +#ifndef JSON_H +#define JSON_H + +#define JSON_MAX_STRING_LENGTH SIZE_MAX-1 + +struct rui_cstring +{ + char *text; /*<! char c-string */ + size_t length; /*<! put in place to avoid strlen() calls */ + size_t max; /*<! usable memory allocated to text minus the space for the nul character */ +}; + +typedef struct rui_cstring rcstring; + +/** + The descriptions of the json_value node type +**/ + enum json_value_type + { JSON_STRING = 0, JSON_NUMBER, JSON_OBJECT, JSON_ARRAY, JSON_TRUE, JSON_FALSE, JSON_NULL }; + +/** + The error messages produced by the JSON parsers +**/ + enum json_error + { + JSON_OK = 1, /*!< everything went smoothly */ + JSON_INCOMPLETE_DOCUMENT, /*!< the parsed document didn't ended */ + JSON_WAITING_FOR_EOF, /*!< A complete JSON document tree was already finished but needs to get to EOF. Other characters beyond whitespaces produce errors */ + JSON_MALFORMED_DOCUMENT, /* the JSON document which was fed to this parser is malformed */ + JSON_INCOMPATIBLE_TYPE, /*!< the currently parsed type does not belong here */ + JSON_MEMORY, /*!< an error occurred when allocating memory */ + JSON_ILLEGAL_CHARACTER, /*!< the currently parsed character does not belong here */ + JSON_BAD_TREE_STRUCTURE, /*!< the document tree structure is malformed */ + JSON_MAXIMUM_LENGTH, /*!< the parsed string reached the maximum allowed size */ + JSON_UNKNOWN_PROBLEM /*!< some random, unaccounted problem occurred */ + }; + + +/** + The JSON document tree node, which is a basic JSON type +**/ + typedef struct json_value + { + enum json_value_type type; /*!< the type of node */ + char *text; /*!< The text stored by the node. It stores UTF-8 strings and is used exclusively by the JSON_STRING and JSON_NUMBER node types */ + + /* FIFO queue data */ + struct json_value *next; /*!< The pointer pointing to the next element in the FIFO sibling list */ + struct json_value *previous; /*!< The pointer pointing to the previous element in the FIFO sibling list */ + struct json_value *parent; /*!< The pointer pointing to the parent node in the document tree */ + struct json_value *child; /*!< The pointer pointing to the first child node in the document tree */ + struct json_value *child_end; /*!< The pointer pointing to the last child node in the document tree */ + } json_t; + + +/** + The structure holding all information needed to resume parsing +**/ + struct json_parsing_info + { + unsigned int state; /*!< the state where the parsing was left on the last parser run */ + unsigned int lex_state; + rcstring *lex_text; + const char *p; + int string_length_limit_reached; /*!< flag informing if the string limit length defined by JSON_MAX_STRING_LENGTH was reached */ + json_t *cursor; /*!< pointers to nodes belonging to the document tree which aid the document parsing */ + }; + + +/** + The structure which holds the pointers to the functions that will be called by the saxy parser whenever their evens are triggered +**/ + struct json_saxy_functions + { + int (*open_object) (void); + int (*close_object) (void); + int (*open_array) (void); + int (*close_array) (void); + int (*new_string) (char *text); + int (*new_number) (char *text); + int (*new_true) (void); + int (*new_false) (void); + int (*new_null) (void); + int (*label_value_separator) (void); + int (*sibling_separator) (void); + }; + + +/** + The structure holding the information needed for json_saxy_parse to resume parsing +**/ + struct json_saxy_parser_status + { + unsigned int state; /*!< current parser state */ + int string_length_limit_reached; /*!< flag informing if the string limit length defined by JSON_MAX_STRING_LENGTH was reached */ + rcstring *temp; /*!< temporary string which will be used to build up parsed strings between parser runs. */ + }; + + +/** + Buils a json_t document by parsing an open file + @param file a pointer to an object controlling a stream, returned by fopen() + @param document a reference to a json_t pointer, set to NULL, which will store the parsed document + @return a json_error error code according to how the parsing operation went. +**/ + enum json_error json_stream_parse (FILE * file, json_t ** document); + + +/** + Creates a new JSON value and defines it's type + @param type the value's type + @return a pointer to the newly created value structure +**/ + json_t *json_new_value (const enum json_value_type type); + + +/** + Creates a new JSON string and defines it's text + @param text the value's text + @return a pointer to the newly created JSON string value +**/ + json_t *json_new_string (const char *text); + + +/** + Creates a new JSON number and defines it's text. The user is responsible for the number string's correctness + @param text the value's number + @return a pointer to the newly created JSON string value +**/ + json_t *json_new_number (const char *text); + + +/** + Creates a new JSON object + @return a pointer to the newly created JSON object value +**/ + json_t *json_new_object (void); + + +/** + Creates a new JSON array + @return a pointer to the newly created JSON array value +**/ + json_t *json_new_array (void); + + +/** + Creates a new JSON null + @return a pointer to the newly created JSON null value +**/ + json_t *json_new_null (void); + + +/** + Creates a new JSON true + @return a pointer to the newly created JSON true value +**/ + json_t *json_new_true (void); + + +/** + Creates a new JSON false + @return a pointer to the newly created JSON false value +**/ + json_t *json_new_false (void); + + +/** + Frees the memory appointed to the value fed as the parameter, as well as all the child nodes + @param value the root node of the tree being freed +**/ + void json_free_value (json_t ** value); + + +/** + Inserts a child node into a parent node, as well as performs some document tree integrity checks. + @param parent the parent node + @param child the node being added as a child to parent + @return the error code corresponding to the operation result +**/ + enum json_error json_insert_child (json_t * parent, json_t * child); + + +/** + Inserts a label:value pair into a parent node, as well as performs some document tree integrity checks. + @param parent the parent node + @param text_label a char string which serves as the label in the label:value pair + @param value the value in the label:value pair + @return the error code corresponding to the operation result +**/ + enum json_error json_insert_pair_into_object (json_t * parent, const char *text_label, json_t * value); + + +/** + Produces a JSON markup text document from a document tree + @param root The document's root node + @param text a pointer to a char string that will hold the JSON document text. + @return a json_error code describing how the operation went +**/ + enum json_error json_tree_to_string (json_t * root, char **text); + + +/** + Produces a JSON markup text document from a json_t document tree to a text stream + @param file a opened file stream + @param root The document's root node + @return a json_error code describing how the operation went +**/ + enum json_error json_stream_output (FILE * file, json_t * root); + + +/** + Strips all JSON white spaces from the text string + @param text a char string holding a JSON document or document snippet +**/ + void json_strip_white_spaces (char *text); + + +/** + Formats a JSON markup text contained in the given string + @param text a JSON formatted document + @return a pointer to a char string holding the formated document +**/ + char *json_format_string (const char *text); + + +/** + Outputs a new UTF8 c-string which replaces all characters that must be escaped with their respective escaped versions + @param text an UTF8 char text string + @return an UTF-8 c-string holding the same text string but with escaped characters +**/ + char *json_escape (char *text); + + +/** + This function takes care of the tedious task of initializing any instance of + struct json_parsing_info + @param jpi a pointer to a struct json_parsing_info instance +**/ + void json_jpi_init (struct json_parsing_info *jpi); + + +/** + Produces a document tree sequentially from a JSON markup text fragment + @param info the information necessary to resume parsing any incomplete document + @param buffer a null-terminated c-string containing a JSON document fragment + @return a code describing how the operation ended up +**/ + enum json_error json_parse_fragment (struct json_parsing_info *info, const char *buffer); + + +/** + Produces a document tree from a JSON markup text string that contains a complete document + @param root a reference to a pointer to a json_t type. The function allocates memory to the passed pointer and sets up the value + @param text a c-string containing a complete JSON text document + @return a pointer to the new document tree or NULL if some error occurred +**/ + enum json_error json_parse_document (json_t ** root, const char *text); + + +/** + Function to perform a SAX-like parsing of any JSON document or document fragment that is passed to it + @param jsps a structure holding the status information of the current parser + @param jsf a structure holding the function pointers to the event functions + @param c the character to be parsed + @return a json_error code informing how the parsing went +**/ + enum json_error json_saxy_parse (struct json_saxy_parser_status *jsps, struct json_saxy_functions *jsf, char c); + + +/** + Searches through the object's children for a label holding the text text_label + @param object a json_value of type JSON_OBJECT + @param text_label the c-string to search for through the object's child labels + @return a pointer to the first label holding a text equal to text_label or NULL if there is no such label or if object has no children +**/ + enum json_error json_find_first_label (const json_t * object, const char *text_label, json_t **value); + + +#endif -- 1.6.2.5