/* -*- Mode: c; tab-width: 8; indent-tabs-mode: 1; c-basic-offset: 8; -*- */
/*
 * Copyright (c) 1993, 1994, 1995, 1996, 1997
 *	The Regents of the University of California.  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.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the Computer Systems
 *	Engineering Group at Lawrence Berkeley Laboratory.
 * 4. Neither the name of the University nor of the Laboratory may be used
 *    to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
 */

#ifdef _WIN32
#include <stdio.h>

#include <pcap/pcap.h>	/* Needed for PCAP_ERRBUF_SIZE */

#include "charconv.h"

wchar_t *
cp_to_utf_16le(UINT codepage, const char *cp_string, DWORD flags)
{
	int utf16le_len;
	wchar_t *utf16le_string;

	/*
	 * Map from the specified code page to UTF-16LE.
	 * First, find out how big a buffer we'll need.
	 */
	utf16le_len = MultiByteToWideChar(codepage, flags, cp_string, -1,
	    NULL, 0);
	if (utf16le_len == 0) {
		/*
		 * Error.  Fail with EINVAL.
		 */
		errno = EINVAL;
		return (NULL);
	}

	/*
	 * Now attempt to allocate a buffer for that.
	 */
	utf16le_string = malloc(utf16le_len * sizeof (wchar_t));
	if (utf16le_string == NULL) {
		/*
		 * Not enough memory; assume errno has been
		 * set, and fail.
		 */
		return (NULL);
	}

	/*
	 * Now convert.
	 */
	utf16le_len = MultiByteToWideChar(codepage, flags, cp_string, -1,
	    utf16le_string, utf16le_len);
	if (utf16le_len == 0) {
		/*
		 * Error.  Fail with EINVAL.
		 * XXX - should this ever happen, given that
		 * we already ran the string through
		 * MultiByteToWideChar() to find out how big
		 * a buffer we needed?
		 */
		free(utf16le_string);
		errno = EINVAL;
		return (NULL);
	}
	return (utf16le_string);
}

char *
utf_16le_to_cp(UINT codepage, const wchar_t *utf16le_string)
{
	int cp_len;
	char *cp_string;

	/*
	 * Map from UTF-16LE to the specified code page.
	 * First, find out how big a buffer we'll need.
	 * We convert composite characters to precomposed characters,
	 * as that's what Windows expects.
	 */
	cp_len = WideCharToMultiByte(codepage, WC_COMPOSITECHECK,
	    utf16le_string, -1, NULL, 0, NULL, NULL);
	if (cp_len == 0) {
		/*
		 * Error.  Fail with EINVAL.
		 */
		errno = EINVAL;
		return (NULL);
	}

	/*
	 * Now attempt to allocate a buffer for that.
	 */
	cp_string = malloc(cp_len * sizeof (char));
	if (cp_string == NULL) {
		/*
		 * Not enough memory; assume errno has been
		 * set, and fail.
		 */
		return (NULL);
	}

	/*
	 * Now convert.
	 */
	cp_len = WideCharToMultiByte(codepage, WC_COMPOSITECHECK,
	    utf16le_string, -1, cp_string, cp_len, NULL, NULL);
	if (cp_len == 0) {
		/*
		 * Error.  Fail with EINVAL.
		 * XXX - should this ever happen, given that
		 * we already ran the string through
		 * WideCharToMultiByte() to find out how big
		 * a buffer we needed?
		 */
		free(cp_string);
		errno = EINVAL;
		return (NULL);
	}
	return (cp_string);
}

/*
 * Convert an error message string from UTF-8 to the local code page, as
 * best we can.
 *
 * The buffer is assumed to be PCAP_ERRBUF_SIZE bytes long; we truncate
 * if it doesn't fit.
 */
void
utf_8_to_acp_truncated(char *errbuf)
{
	wchar_t *utf_16_errbuf;
	int retval;
	DWORD err;

	/*
	 * Do this by converting to UTF-16LE and then to the local
	 * code page.  That means we get to use Microsoft's
	 * conversion routines, rather than having to understand
	 * all the code pages ourselves, *and* that this routine
	 * can convert in place.
	 */

	/*
	 * Map from UTF-8 to UTF-16LE.
	 * First, find out how big a buffer we'll need.
	 * Convert any invalid characters to REPLACEMENT CHARACTER.
	 */
	utf_16_errbuf = cp_to_utf_16le(CP_UTF8, errbuf, 0);
	if (utf_16_errbuf == NULL) {
		/*
		 * Error.  Give up.
		 */
		snprintf(errbuf, PCAP_ERRBUF_SIZE,
		    "Can't convert error string to the local code page");
		return;
	}

	/*
	 * Now, convert that to the local code page.
	 * Use the current thread's code page.  For unconvertable
	 * characters, let it pick the "best fit" character.
	 *
	 * XXX - we'd like some way to do what utf_16le_to_utf_8_truncated()
	 * does if the buffer isn't big enough, but we don't want to have
	 * to handle all local code pages ourselves; doing so requires
	 * knowledge of all those code pages, including knowledge of how
	 * characters are formed in thoe code pages so that we can avoid
	 * cutting a multi-byte character into pieces.
	 *
	 * Converting to an un-truncated string using Windows APIs, and
	 * then copying to the buffer, still requires knowledge of how
	 * characters are formed in the target code page.
	 */
	retval = WideCharToMultiByte(CP_THREAD_ACP, 0, utf_16_errbuf, -1,
	    errbuf, PCAP_ERRBUF_SIZE, NULL, NULL);
	if (retval == 0) {
		err = GetLastError();
		free(utf_16_errbuf);
		if (err == ERROR_INSUFFICIENT_BUFFER)
			snprintf(errbuf, PCAP_ERRBUF_SIZE,
			    "The error string, in the local code page, didn't fit in the buffer");
		else
			snprintf(errbuf, PCAP_ERRBUF_SIZE,
			    "Can't convert error string to the local code page");
		return;
	}
	free(utf_16_errbuf);
}
#endif