/*
 * dhcpcd - DHCP client daemon
 * Copyright (c) 2006-2015 Roy Marples <roy@marples.name>
 * All rights reserved

 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <arpa/inet.h>

#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <syslog.h>

#include <dbus/dbus.h>

#include "../config.h"
#include "dbus-dict.h"

static dbus_bool_t
append_sanitized_string(DBusMessageIter *iter, const char *value)
{
	dbus_bool_t ret;
	int len = strlen(value);
	char *sanitized_value = NULL;
	int i;

	for (i = 0; i < len; i++) {
		if (isascii(value[i]) || isprint(value[i])) {
			if (sanitized_value)
				sanitized_value[i] = value[i];
		} else {
			if (sanitized_value == NULL) {
				sanitized_value = malloc(len + 1);
				if (sanitized_value == NULL) {
					syslog(LOG_ERR, "DBus string parameter "
					       "sanitization failed due to "
					       "malloc failure");
					return FALSE;
				}
				memcpy(sanitized_value, value, i);
			}
			sanitized_value[i] = '?';
		}
	}
	if (sanitized_value) {
		syslog(LOG_ERR, "DBus string parameter sanitization"
                       " was invoked");
		sanitized_value[i] = '\0';
		ret = dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
	            &sanitized_value);

		free(sanitized_value);
	} else {
		ret = dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
	            &value);
	}

	return ret;
}

static int
append_config_value(DBusMessageIter *entry, int type,
    const char *data)
{
	int retval;
	DBusMessageIter var;
	unsigned char byte;
	dbus_uint16_t u16;
	dbus_uint32_t u32;
	dbus_int16_t i16;
	dbus_int32_t i32;
	struct in_addr in;

	retval = -1;
	switch (type) {
	case DBUS_TYPE_BOOLEAN:
		if (*data == '0' || *data == '\0')
			u32 = 0;
		else
			u32 = 1;
		dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
		    DBUS_TYPE_BOOLEAN_AS_STRING, &var);
		if (dbus_message_iter_append_basic(&var,
			DBUS_TYPE_BOOLEAN, &u32))
			retval = 0;
		break;
	case DBUS_TYPE_BYTE:
		byte = strtoul(data, NULL, 0);
		dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
		    DBUS_TYPE_BYTE_AS_STRING, &var);
		if (dbus_message_iter_append_basic(&var, DBUS_TYPE_BYTE,
			&byte))
			retval = 0;
		break;
	case DBUS_TYPE_STRING:
		dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
		    DBUS_TYPE_STRING_AS_STRING, &var);
		if (append_sanitized_string(&var, data))
			retval = 0;
		break;
	case DBUS_TYPE_INT16:
		i16 = strtol(data, NULL, 0);
		dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
		    DBUS_TYPE_INT16_AS_STRING, &var);
		if (dbus_message_iter_append_basic(&var,
			DBUS_TYPE_INT16, &i16))
			retval = 0;
		break;
	case DBUS_TYPE_UINT16:
		u16 = strtoul(data, NULL, 0);
		dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
		    DBUS_TYPE_UINT16_AS_STRING, &var);
		if (dbus_message_iter_append_basic(&var,
			DBUS_TYPE_UINT16, &u16))
			retval = 0;
		break;
	case DBUS_TYPE_INT32:
		i32 = strtol(data, NULL, 0);
		dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
		    DBUS_TYPE_INT32_AS_STRING, &var);
		if (dbus_message_iter_append_basic(&var,
			DBUS_TYPE_INT32, &i32))
			retval = 0;
		break;
	case DBUS_TYPE_UINT32:
		if (strchr(data, '.') != NULL && inet_aton(data, &in) == 1)
			u32 = in.s_addr;
		else
			u32 = strtoul(data, NULL, 0);
		dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
		    DBUS_TYPE_UINT32_AS_STRING, &var);
		if (dbus_message_iter_append_basic(&var,
			DBUS_TYPE_UINT32, &u32))
			retval = 0;
		break;
	default:
		retval = 1;
		break;
	}
	if (retval == 0)
		dbus_message_iter_close_container(entry, &var);
	else if (retval == 1)
		retval = 0;

	return retval;
}

static int
append_config_byte_array(DBusMessageIter *entry, const char *data)
{
	DBusMessageIter var, array;
	dbus_bool_t ok = TRUE;
	uint8_t u8, u8_2;
	size_t len;
	const char *it, *end;
	const char *tsa, *ts;

	tsa = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING;
	ts = DBUS_TYPE_BYTE_AS_STRING;

	dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT, tsa, &var);
	dbus_message_iter_open_container(&var, DBUS_TYPE_ARRAY, ts, &array);

	len = strlen(data);
	it = data;
	end = data + len;

	/* "a12" is treated as "0a12" */
	if (len & 1) {
		ok = (sscanf(it++, "%1hhx", &u8) == 1) &&
			dbus_message_iter_append_basic(&array, DBUS_TYPE_BYTE,
						       &u8);
	}

	while (ok && it < end) {
		/* sscanf("1z", "%2hhx", &u8) will store 0x01 in u8 and
		 * will return 1 */
		ok = (sscanf(it++, "%1hhx", &u8) == 1) &&
			(sscanf(it++, "%1hhx", &u8_2) == 1);
		if (!ok)
			break;

		u8 = (u8 << 4) | u8_2;
		ok = dbus_message_iter_append_basic(&array, DBUS_TYPE_BYTE, &u8);
	}

	dbus_message_iter_close_container(&var, &array);
	dbus_message_iter_close_container(entry, &var);
	return ok ? 0 : -1;
}

static int
append_config_array(DBusMessageIter *entry, int type, const char *data)
{
	int retval;
	char *ns, *p, *tok;
	const char *tsa, *ts;
	DBusMessageIter var, array;
	dbus_bool_t ok;
	dbus_uint32_t u32;
	struct in_addr in;

	if (type == DBUS_TYPE_BYTE)
		return append_config_byte_array(entry, data);

	switch (type) {
	case DBUS_TYPE_STRING:
		tsa = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING;
		ts = DBUS_TYPE_STRING_AS_STRING;
		break;
	case DBUS_TYPE_UINT32:
		tsa = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_UINT32_AS_STRING;
		ts = DBUS_TYPE_UINT32_AS_STRING;
		break;
	default:
		return -1;
	}

	ns = p = strdup(data);
	if (ns == NULL)
		return -1;
	retval = 0;

	dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT, tsa, &var);
	dbus_message_iter_open_container(&var, DBUS_TYPE_ARRAY, ts, &array);
	while ((tok = strsep(&p, " ")) != NULL) {
		if (*tok == '\0')
			continue;
		switch(type) {
		case DBUS_TYPE_STRING:
			ok = append_sanitized_string(&array, tok);
			break;
		case DBUS_TYPE_UINT32:
			if (strchr(tok, '.') != NULL &&
			    inet_aton(tok, &in) == 1)
				u32 = in.s_addr;
			else
				u32 = strtoul(tok, NULL, 0);
			ok = dbus_message_iter_append_basic(&array,
			    DBUS_TYPE_UINT32, &u32);
			break;
		default:
			ok = FALSE;
			break;
		}
		if (!ok)
			break;
	}
	dbus_message_iter_close_container(&var, &array);
	dbus_message_iter_close_container(entry, &var);
	free(ns);
	return retval;
}

int
dict_append_config_item(DBusMessageIter *iter, const struct o_dbus *op,
    const char *data)
{
	int retval;
	DBusMessageIter entry;

	retval = 0;
	if (*data == '\0')
		return retval;
	dbus_message_iter_open_container(iter,
	    DBUS_TYPE_DICT_ENTRY,
	    NULL,
	    &entry);
	append_sanitized_string(&entry, op->name);
	if (op->type == DBUS_TYPE_ARRAY)
		retval = append_config_array(&entry, op->sub_type, data);
	else
		retval = append_config_value(&entry, op->type, data);
	dbus_message_iter_close_container(iter, &entry);
	return retval;
}