/* -*- 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 <errno.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 unconvertible
        * 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 those 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

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.