/*
 * Unix SMB/CIFS implementation.
 * Registry helper routines
 * Copyright (C) Volker Lendecke 2006
 * 
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 3 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 General Public License along with
 * this program; if not, see <http://www.gnu.org/licenses/>.
 */

#include "includes.h"

#undef DBGC_CLASS
#define DBGC_CLASS DBGC_REGISTRY

WERROR registry_pull_value(TALLOC_CTX *mem_ctx,
			   struct registry_value **pvalue,
			   enum winreg_Type type, uint8 *data,
			   uint32 size, uint32 length)
{
	struct registry_value *value;
	WERROR err;

	if (!(value = TALLOC_ZERO_P(mem_ctx, struct registry_value))) {
		return WERR_NOMEM;
	}

	value->type = type;

	switch (type) {
	case REG_DWORD:
		if ((size != 4) || (length != 4)) {
			err = WERR_INVALID_PARAM;
			goto error;
		}
		value->v.dword = IVAL(data, 0);
		break;
	case REG_SZ:
	case REG_EXPAND_SZ:
	{
		/*
		 * Make sure we get a NULL terminated string for
		 * convert_string_talloc().
		 */

		smb_ucs2_t *tmp;

		if (length == 1) {
			/* win2k regedit gives us a string of 1 byte when
			 * creating a new value of type REG_SZ. this workaround
			 * replaces the input by using the same string as
			 * winxp delivers. */
			length = 2;
			if (!(tmp = SMB_MALLOC_ARRAY(smb_ucs2_t, 2))) {
				err = WERR_NOMEM;
				goto error;
			}
			tmp[0] = 0;
			tmp[1] = 0;
			DEBUG(10, ("got REG_SZ value of length 1 - workaround "
				   "activated.\n"));
		}
		else if ((length % 2) != 0) {
			err = WERR_INVALID_PARAM;
			goto error;
		}
		else {
			uint32 num_ucs2 = length / 2;
			if (!(tmp = SMB_MALLOC_ARRAY(smb_ucs2_t, num_ucs2+1))) {
				err = WERR_NOMEM;
				goto error;
			}

			memcpy((void *)tmp, (const void *)data, length);
			tmp[num_ucs2] = 0;
		}

		if (length + 2 < length) {
			/* Integer wrap. */
			SAFE_FREE(tmp);
			err = WERR_INVALID_PARAM;
			goto error;
		}

		value->v.sz.len = convert_string_talloc(
			value, CH_UTF16LE, CH_UNIX, tmp, length+2,
			&value->v.sz.str, False);

		SAFE_FREE(tmp);

		if (value->v.sz.len == (size_t)-1) {
			err = WERR_INVALID_PARAM;
			goto error;
		}
		break;
	}
	case REG_MULTI_SZ:
		err = reg_pull_multi_sz(value, (void *)data, length,
					&value->v.multi_sz.num_strings,
					&value->v.multi_sz.strings);
		if (!(W_ERROR_IS_OK(err))) {
			goto error;
		}
		break;
	case REG_BINARY:
		value->v.binary = data_blob_talloc(mem_ctx, data, length);
		break;
	default:
		err = WERR_INVALID_PARAM;
		goto error;
	}

	*pvalue = value;
	return WERR_OK;

 error:
	TALLOC_FREE(value);
	return err;
}

WERROR registry_push_value(TALLOC_CTX *mem_ctx,
			   const struct registry_value *value,
			   DATA_BLOB *presult)
{
	switch (value->type) {
	case REG_DWORD: {
		char buf[4];
		SIVAL(buf, 0, value->v.dword);
		*presult = data_blob_talloc(mem_ctx, (void *)buf, 4);
		if (presult->data == NULL) {
			return WERR_NOMEM;
		}
		break;
	}
	case REG_SZ:
	case REG_EXPAND_SZ: {
		presult->length = convert_string_talloc(
			mem_ctx, CH_UNIX, CH_UTF16LE, value->v.sz.str,
			MIN(value->v.sz.len, strlen(value->v.sz.str)+1),
			(void *)&(presult->data), False);
		if (presult->length == (size_t)-1) {
			return WERR_NOMEM;
		}
		break;
	}
	case REG_MULTI_SZ: {
		uint32_t count;
		size_t len = 0;
		char **strings;
		size_t *string_lengths;
		uint32_t ofs;
		TALLOC_CTX *tmp_ctx = talloc_stackframe();

		strings = TALLOC_ARRAY(tmp_ctx, char *,
				       value->v.multi_sz.num_strings);
		if (strings == NULL) {
			return WERR_NOMEM;
		}

		string_lengths = TALLOC_ARRAY(tmp_ctx, size_t,
					      value->v.multi_sz.num_strings);
		if (string_lengths == NULL) {
			TALLOC_FREE(tmp_ctx);
			return WERR_NOMEM;
		}

		/* convert the single strings */
		for (count = 0; count < value->v.multi_sz.num_strings; count++)
		{
			string_lengths[count] = convert_string_talloc(
				strings, CH_UNIX, CH_UTF16LE,
				value->v.multi_sz.strings[count],
				strlen(value->v.multi_sz.strings[count])+1,
				(void *)&strings[count], false);
			if (string_lengths[count] == (size_t)-1) {
				TALLOC_FREE(tmp_ctx);
				return WERR_NOMEM;
			}
			len += string_lengths[count];
		}

		/* now concatenate all into the data blob */
		presult->data = TALLOC_ARRAY(mem_ctx, uint8_t, len);
		if (presult->data == NULL) {
			TALLOC_FREE(tmp_ctx);
			return WERR_NOMEM;
		}
		for (count = 0, ofs = 0;
		     count < value->v.multi_sz.num_strings;
		     count++)
		{
			memcpy(presult->data + ofs, strings[count],
			       string_lengths[count]);
			ofs += string_lengths[count];
		}
		presult->length = len;

		TALLOC_FREE(tmp_ctx);

		break;
	}
	case REG_BINARY:
		*presult = data_blob_talloc(mem_ctx,
					    value->v.binary.data,
					    value->v.binary.length);
		break;
	default:
		return WERR_INVALID_PARAM;
	}

	return WERR_OK;
}
