path: root/contrib/libs/openssl/apps/win32_init.c

/* 
 * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved. 
 * 
 * Licensed under the OpenSSL license (the "License").  You may not use 
 * this file except in compliance with the License.  You can obtain a copy 
 * in the file LICENSE in the source distribution or at 
 * https://www.openssl.org/source/license.html 
 */ 
 
#include <windows.h> 
#include <stdlib.h> 
#include <string.h> 
#include <malloc.h> 
 
#if defined(CP_UTF8) 
 
static UINT saved_cp; 
static int newargc; 
static char **newargv; 
 
static void cleanup(void) 
{ 
    int i; 
 
    SetConsoleOutputCP(saved_cp); 
 
    for (i = 0; i < newargc; i++) 
        free(newargv[i]); 
 
    free(newargv); 
} 
 
/* 
 * Incrementally [re]allocate newargv and keep it NULL-terminated. 
 */ 
static int validate_argv(int argc) 
{ 
    static int size = 0; 
 
    if (argc >= size) { 
        char **ptr; 
 
        while (argc >= size) 
            size += 64; 
 
        ptr = realloc(newargv, size * sizeof(newargv[0])); 
        if (ptr == NULL) 
            return 0; 
 
        (newargv = ptr)[argc] = NULL; 
    } else { 
        newargv[argc] = NULL; 
    } 
 
    return 1; 
} 
 
static int process_glob(WCHAR *wstr, int wlen) 
{ 
    int i, slash, udlen; 
    WCHAR saved_char; 
    WIN32_FIND_DATAW data; 
    HANDLE h; 
 
    /* 
     * Note that we support wildcard characters only in filename part 
     * of the path, and not in directories. Windows users are used to 
     * this, that's why recursive glob processing is not implemented. 
     */ 
    /* 
     * Start by looking for last slash or backslash, ... 
     */ 
    for (slash = 0, i = 0; i < wlen; i++) 
        if (wstr[i] == L'/' || wstr[i] == L'\\') 
            slash = i + 1; 
    /* 
     * ... then look for asterisk or question mark in the file name. 
     */ 
    for (i = slash; i < wlen; i++) 
        if (wstr[i] == L'*' || wstr[i] == L'?') 
            break; 
 
    if (i == wlen) 
        return 0;   /* definitely not a glob */ 
 
    saved_char = wstr[wlen]; 
    wstr[wlen] = L'\0'; 
    h = FindFirstFileW(wstr, &data); 
    wstr[wlen] = saved_char; 
    if (h == INVALID_HANDLE_VALUE) 
        return 0;   /* not a valid glob, just pass... */ 
 
    if (slash) 
        udlen = WideCharToMultiByte(CP_UTF8, 0, wstr, slash, 
                                    NULL, 0, NULL, NULL); 
    else 
        udlen = 0; 
 
    do { 
        int uflen; 
        char *arg; 
 
        /* 
         * skip over . and .. 
         */ 
        if (data.cFileName[0] == L'.') { 
            if ((data.cFileName[1] == L'\0') || 
                (data.cFileName[1] == L'.' && data.cFileName[2] == L'\0')) 
                continue; 
        } 
 
        if (!validate_argv(newargc + 1)) 
            break; 
 
        /* 
         * -1 below means "scan for trailing '\0' *and* count it", 
         * so that |uflen| covers even trailing '\0'. 
         */ 
        uflen = WideCharToMultiByte(CP_UTF8, 0, data.cFileName, -1, 
                                    NULL, 0, NULL, NULL); 
 
        arg = malloc(udlen + uflen); 
        if (arg == NULL) 
            break; 
 
        if (udlen) 
            WideCharToMultiByte(CP_UTF8, 0, wstr, slash, 
                                arg, udlen, NULL, NULL); 
 
        WideCharToMultiByte(CP_UTF8, 0, data.cFileName, -1, 
                            arg + udlen, uflen, NULL, NULL); 
 
        newargv[newargc++] = arg; 
    } while (FindNextFileW(h, &data)); 
 
    CloseHandle(h); 
 
    return 1; 
} 
 
void win32_utf8argv(int *argc, char **argv[]) 
{ 
    const WCHAR *wcmdline; 
    WCHAR *warg, *wend, *p; 
    int wlen, ulen, valid = 1; 
    char *arg; 
 
    if (GetEnvironmentVariableW(L"OPENSSL_WIN32_UTF8", NULL, 0) == 0) 
        return; 
 
    newargc = 0; 
    newargv = NULL; 
    if (!validate_argv(newargc)) 
        return; 
 
    wcmdline = GetCommandLineW(); 
    if (wcmdline == NULL) return; 
 
    /* 
     * make a copy of the command line, since we might have to modify it... 
     */ 
    wlen = wcslen(wcmdline); 
    p = _alloca((wlen + 1) * sizeof(WCHAR)); 
    wcscpy(p, wcmdline); 
 
    while (*p != L'\0') { 
        int in_quote = 0; 
 
        if (*p == L' ' || *p == L'\t') { 
            p++; /* skip over white spaces */ 
            continue; 
        } 
 
        /* 
         * Note: because we may need to fiddle with the number of backslashes, 
         * the argument string is copied into itself.  This is safe because 
         * the number of characters will never expand. 
         */ 
        warg = wend = p; 
        while (*p != L'\0' 
               && (in_quote || (*p != L' ' && *p != L'\t'))) { 
            switch (*p) { 
            case L'\\': 
                /* 
                 * Microsoft documentation on how backslashes are treated 
                 * is: 
                 * 
                 * + Backslashes are interpreted literally, unless they 
                 *   immediately precede a double quotation mark. 
                 * + If an even number of backslashes is followed by a double 
                 *   quotation mark, one backslash is placed in the argv array 
                 *   for every pair of backslashes, and the double quotation 
                 *   mark is interpreted as a string delimiter. 
                 * + If an odd number of backslashes is followed by a double 
                 *   quotation mark, one backslash is placed in the argv array 
                 *   for every pair of backslashes, and the double quotation 
                 *   mark is "escaped" by the remaining backslash, causing a 
                 *   literal double quotation mark (") to be placed in argv. 
                 * 
                 * Ref: https://msdn.microsoft.com/en-us/library/17w5ykft.aspx 
                 * 
                 * Though referred page doesn't mention it, multiple qouble 
                 * quotes are also special. Pair of double quotes in quoted 
                 * string is counted as single double quote. 
                 */ 
                { 
                    const WCHAR *q = p; 
                    int i; 
 
                    while (*p == L'\\') 
                        p++; 
 
                    if (*p == L'"') { 
                        int i; 
 
                        for (i = (p - q) / 2; i > 0; i--) 
                            *wend++ = L'\\'; 
 
                        /* 
                         * if odd amount of backslashes before the quote, 
                         * said quote is part of the argument, not a delimiter 
                         */ 
                        if ((p - q) % 2 == 1) 
                            *wend++ = *p++; 
                    } else { 
                        for (i = p - q; i > 0; i--) 
                            *wend++ = L'\\'; 
                    } 
                } 
                break; 
            case L'"': 
                /* 
                 * Without the preceding backslash (or when preceded with an 
                 * even number of backslashes), the double quote is a simple 
                 * string delimiter and just slightly change the parsing state 
                 */ 
                if (in_quote && p[1] == L'"') 
                    *wend++ = *p++; 
                else 
                    in_quote = !in_quote; 
                p++; 
                break; 
            default: 
                /* 
                 * Any other non-delimiter character is just taken verbatim 
                 */ 
                *wend++ = *p++; 
            } 
        } 
 
        wlen = wend - warg; 
 
        if (wlen == 0 || !process_glob(warg, wlen)) { 
            if (!validate_argv(newargc + 1)) { 
                valid = 0; 
                break; 
            } 
 
            ulen = 0; 
            if (wlen > 0) { 
                ulen = WideCharToMultiByte(CP_UTF8, 0, warg, wlen, 
                                           NULL, 0, NULL, NULL); 
                if (ulen <= 0) 
                    continue; 
            } 
 
            arg = malloc(ulen + 1); 
            if (arg == NULL) { 
                valid = 0; 
                break; 
            } 
 
            if (wlen > 0) 
                WideCharToMultiByte(CP_UTF8, 0, warg, wlen, 
                                    arg, ulen, NULL, NULL); 
            arg[ulen] = '\0'; 
 
            newargv[newargc++] = arg; 
        } 
    } 
 
    if (valid) { 
        saved_cp = GetConsoleOutputCP(); 
        SetConsoleOutputCP(CP_UTF8); 
 
        *argc = newargc; 
        *argv = newargv; 
 
        atexit(cleanup); 
    } else if (newargv != NULL) { 
        int i; 
 
        for (i = 0; i < newargc; i++) 
            free(newargv[i]); 
 
        free(newargv); 
 
        newargc = 0; 
        newargv = NULL; 
    } 
 
    return; 
} 
#else 
void win32_utf8argv(int *argc, char **argv[]) 
{   return;   } 
#endif