cmd-dump-backup.c

/*
 * Copyright (c) 2018 Tim van der Molen <tim@kariliq.nl>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <err.h>
#include <inttypes.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "sigbak.h"

static enum cmd_status cmd_dump_backup(int, char **);

const struct cmd_entry cmd_dump_backup_entry = {
	.name = "dump-backup",
	.alias = "dump",
	.usage = "[-p passfile] backup",
	.exec = cmd_dump_backup
};

static void
dump_var(unsigned int ind, const char *name, const char *type, const char *fmt,
    ...)
{
	va_list ap;

	va_start(ap, fmt);
	while (ind-- > 0)
		putchar('\t');
	printf("%s (%s):", name, type);
	if (fmt != NULL) {
		putchar(' ');
		vprintf(fmt, ap);
	}
	putchar('\n');
	va_end(ap);
}

static void
dump_bool(unsigned int ind, const char *name, int val)
{
	dump_var(ind, name, "bool", "%d", val);
}

static void
dump_int32(unsigned int ind, const char *name, int32_t val)
{
	dump_var(ind, name, "int32", "%" PRId32, val);
}

static void
dump_uint32(unsigned int ind, const char *name, uint32_t val)
{
	dump_var(ind, name, "uint32", "%" PRIu32, val);
}

static void
dump_int64(unsigned int ind, const char *name, int64_t val)
{
	dump_var(ind, name, "int64", "%" PRId64, val);
}

static void
dump_uint64(unsigned int ind, const char *name, uint64_t val)
{
	dump_var(ind, name, "uint64", "%" PRIu64, val);
}

static void
dump_float(unsigned int ind, const char *name, float val)
{
	dump_var(ind, name, "float", "%g", val);
}

static void
dump_double(unsigned int ind, const char *name, double val)
{
	dump_var(ind, name, "double", "%g", val);
}

static void
dump_string(unsigned int ind, const char *name, const char *val)
{
	dump_var(ind, name, "string", "%s", val);
}

static void
dump_binary(unsigned int ind, const char *name, ProtobufCBinaryData *bin)
{
	char	*hex;
	size_t	 i;

	if (bin->len == SIZE_MAX) {
		warnx("Binary data too large");
		return;
	}

	if ((hex = reallocarray(NULL, bin->len + 1, 2)) == NULL) {
		warn(NULL);
		return;
	}

	if (bin->len == 0)
		hex[0] = '\0';
	else
		for (i = 0; i < bin->len; i++)
			snprintf(hex + (i * 2), 3, "%02" PRIx8, bin->data[i]);

	dump_var(ind, name, "bytes", "%s", hex);
	free(hex);
}

static void
dump_attachment(unsigned int ind, const char *name, Signal__Attachment *att)
{
	dump_var(ind++, name, "Attachment", NULL);
	if (att->has_rowid)
		dump_uint64(ind, "rowId", att->rowid);
	if (att->has_attachmentid)
		dump_uint64(ind, "attachmentId", att->attachmentid);
	if (att->has_length)
		dump_uint32(ind, "length", att->length);
}

static void
dump_avatar(unsigned int ind, const char *name, Signal__Avatar *avt)
{
	dump_var(ind++, name, "Avatar", NULL);
	if (avt->name != NULL)
		dump_string(ind, "name", avt->name);
	if (avt->has_length)
		dump_uint32(ind, "length", avt->length);
	if (avt->recipientid != NULL)
		dump_string(ind, "recipientId", avt->recipientid);
}

static void
dump_header(unsigned int ind, const char *name, Signal__Header *hdr)
{
	dump_var(ind++, name, "Header", NULL);
	if (hdr->has_iv)
		dump_binary(ind, "iv", &hdr->iv);
	if (hdr->has_salt)
		dump_binary(ind, "salt", &hdr->salt);
	if (hdr->has_version)
		dump_uint32(ind, "version", hdr->version);
}

static void
dump_preference(unsigned int ind, const char *name,
    Signal__SharedPreference *prf)
{
	size_t i;

	dump_var(ind++, name, "SharedPreference", NULL);
	if (prf->file != NULL)
		dump_string(ind, "file", prf->file);
	if (prf->key != NULL)
		dump_string(ind, "key", prf->key);
	if (prf->value != NULL)
		dump_string(ind, "value", prf->value);
	if (prf->has_booleanvalue)
		dump_bool(ind, "booleanValue", prf->booleanvalue);
	for (i = 0; i < prf->n_stringsetvalue; i++)
		dump_string(ind, "stringSetValue", prf->stringsetvalue[i]);
	if (prf->has_isstringsetvalue)
		dump_bool(ind, "isStringSetValue", prf->isstringsetvalue);
}

static void
dump_parameter(unsigned int ind, const char *name,
    Signal__SqlStatement__SqlParameter *par)
{
	dump_var(ind++, name, "SqlParameter", NULL);
	if (par->stringparamter != NULL)
		dump_string(ind, "stringParamter", par->stringparamter);
	if (par->has_integerparameter)
		dump_uint64(ind, "integerParameter", par->integerparameter);
	if (par->has_doubleparameter)
		dump_double(ind, "doubleParameter", par->doubleparameter);
	if (par->has_blobparameter)
		dump_binary(ind, "blobParameter", &par->blobparameter);
	if (par->has_nullparameter)
		dump_bool(ind, "nullparameter", par->nullparameter);
}

static void
dump_statement(unsigned int ind, const char *name, Signal__SqlStatement *stm)
{
	size_t i;

	dump_var(ind++, name, "SqlStatement", NULL);
	if (stm->statement != NULL)
		dump_string(ind, "statement", stm->statement);
	for (i = 0; i < stm->n_parameters; i++)
		dump_parameter(ind, "parameters", stm->parameters[i]);
}

static void
dump_sticker(unsigned int ind, const char *name, Signal__Sticker *stk)
{
	dump_var(ind++, name, "Sticker", NULL);
	if (stk->has_rowid)
		dump_uint64(ind, "rowId", stk->rowid);
	if (stk->has_length)
		dump_uint32(ind, "length", stk->length);
}

static void
dump_version(unsigned int ind, const char *name, Signal__DatabaseVersion *ver)
{
	dump_var(ind++, name, "DatabaseVersion", NULL);
	if (ver->has_version)
		dump_uint32(ind, "version", ver->version);
}

static void
dump_keyvalue(unsigned int ind, const char *name, Signal__KeyValue *key)
{
	dump_var(ind++, name, "KeyValue", NULL);
	if (key->key != NULL)
		dump_string(ind, "key", key->key);
	if (key->has_blobvalue)
		dump_binary(ind, "blobValue", &key->blobvalue);
	if (key->has_booleanvalue)
		dump_bool(ind, "booleanValue", key->booleanvalue);
	if (key->has_floatvalue)
		dump_float(ind, "floatValue", key->floatvalue);
	if (key->has_integervalue)
		dump_int32(ind, "integerValue", key->integervalue);
	if (key->has_longvalue)
		dump_int64(ind, "longValue", key->longvalue);
	if (key->stringvalue != NULL)
		dump_string(ind, "stringValue", key->stringvalue);
}

static void
dump_frame(Signal__BackupFrame *frm)
{
	dump_var(0, "frame", "BackupFrame", NULL);
	if (frm->header != NULL)
		dump_header(1, "header", frm->header);
	if (frm->statement != NULL)
		dump_statement(1, "statement", frm->statement);
	if (frm->preference != NULL)
		dump_preference(1, "preference", frm->preference);
	if (frm->attachment != NULL)
		dump_attachment(1, "attachment", frm->attachment);
	if (frm->version != NULL)
		dump_version(1, "version", frm->version);
	if (frm->has_end)
		dump_bool(1, "end", frm->end);
	if (frm->avatar != NULL)
		dump_avatar(1, "avatar", frm->avatar);
	if (frm->sticker != NULL)
		dump_sticker(1, "sticker", frm->sticker);
	if (frm->keyvalue != NULL)
		dump_keyvalue(1, "keyValue", frm->keyvalue);
}

static enum cmd_status
cmd_dump_backup(int argc, char **argv)
{
	struct sbk_ctx		*ctx;
	Signal__BackupFrame	*frm;
	char			*backup, *passfile, passphr[128];
	int			 c, ret;

	passfile = NULL;

	while ((c = getopt(argc, argv, "p:")) != -1)
		switch (c) {
		case 'p':
			passfile = optarg;
			break;
		default:
			return CMD_USAGE;
		}

	argc -= optind;
	argv += optind;

	if (argc != 1)
		return CMD_USAGE;

	backup = argv[0];

	if (unveil(backup, "r") == -1)
		err(1, "unveil: %s", backup);

	if (passfile == NULL) {
		if (pledge("stdio rpath tty", NULL) == -1)
			err(1, "pledge");
	} else {
		if (strcmp(passfile, "-") != 0 && unveil(passfile, "r") == -1)
			err(1, "unveil: %s", passfile);

		if (pledge("stdio rpath", NULL) == -1)
			err(1, "pledge");
	}

	if ((ctx = sbk_ctx_new()) == NULL)
		return CMD_ERROR;

	if (get_passphrase(passfile, passphr, sizeof passphr) == -1) {
		sbk_ctx_free(ctx);
		return CMD_ERROR;
	}

	if (sbk_open(ctx, backup, passphr) == -1) {
		explicit_bzero(passphr, sizeof passphr);
		sbk_ctx_free(ctx);
		return CMD_ERROR;
	}

	explicit_bzero(passphr, sizeof passphr);

	if (pledge("stdio", NULL) == -1)
		err(1, "pledge");

	while ((frm = sbk_get_frame(ctx, NULL)) != NULL) {
		dump_frame(frm);
		sbk_free_frame(frm);
	}

	ret = sbk_eof(ctx) ? CMD_OK : CMD_ERROR;
	sbk_close(ctx);
	sbk_ctx_free(ctx);
	return ret;
}