VirtualBox

儲存庫 vbox 的更動 50408


忽略:
時間撮記:
2014-2-11 上午02:21:39 (11 年 以前)
作者:
vboxsync
訊息:

RTEnv: Use the unicode CRT APIs on windows to avoid lost-in-translation issues.

位置:
trunk
檔案:
修改 5 筆資料
複製 1 筆資料

圖例:

未更動
新增
刪除

  • trunk/include/iprt/env.h

    r44528 r50408  
    9090 *
    9191 * @param   Env     Environment block handle.
     92 * @todo    This needs to change to return a copy of the env vars like
     93 *          RTEnvQueryUtf16Block does!
    9294 */
    9395RTDECL(char const * const *) RTEnvGetExecEnvP(RTENV Env);
    … …  
    121123 */
    122124RTDECL(bool) RTEnvExist(const char *pszVar);
     125RTDECL(bool) RTEnvExistsBad(const char *pszVar);
     126RTDECL(bool) RTEnvExistsUtf8(const char *pszVar);
    123127
    124128/**
    … …  
    146150 */
    147151RTDECL(const char *) RTEnvGet(const char *pszVar);
     152RTDECL(const char *) RTEnvGetBad(const char *pszVar);
     153RTDECL(int) RTEnvGetUtf8(const char *pszVar, char *pszValue, size_t cbValue, size_t *pcchActual);
    148154
    149155/**
    … …  
    174180 */
    175181RTDECL(int) RTEnvPut(const char *pszVarEqualValue);
     182RTDECL(int) RTEnvPutBad(const char *pszVarEqualValue);
     183RTDECL(int) RTEnvPutUtf8(const char *pszVarEqualValue);
    176184
    177185/**
    … …  
    198206 */
    199207RTDECL(int) RTEnvSet(const char *pszVar, const char *pszValue);
     208RTDECL(int) RTEnvSetBad(const char *pszVar, const char *pszValue);
     209RTDECL(int) RTEnvSetUtf8(const char *pszVar, const char *pszValue);
    200210
    201211/**
    … …  
    222232 */
    223233RTDECL(int) RTEnvUnset(const char *pszVar);
     234RTDECL(int) RTEnvUnsetBad(const char *pszVar);
     235RTDECL(int) RTEnvUnsetUtf8(const char *pszVar);
    224236
    225237/**

  • trunk/include/iprt/mangling.h

    r50205 r50408  
    495495# define RTEnvDupEx                                     RT_MANGLER(RTEnvDupEx)
    496496# define RTEnvExist                                     RT_MANGLER(RTEnvExist)
     497# define RTEnvExistsBad                                 RT_MANGLER(RTEnvExistsBad)
     498# define RTEnvExistsUtf8                                RT_MANGLER(RTEnvExistsUtf8)
    497499# define RTEnvExistEx                                   RT_MANGLER(RTEnvExistEx)
    498500# define RTEnvFreeUtf16Block                            RT_MANGLER(RTEnvFreeUtf16Block)
    499501# define RTEnvGet                                       RT_MANGLER(RTEnvGet)
     502# define RTEnvGetBad                                    RT_MANGLER(RTEnvGetBad)
     503# define RTEnvGetUtf8                                   RT_MANGLER(RTEnvGetUtf8)
    500504# define RTEnvGetEx                                     RT_MANGLER(RTEnvGetEx)
    501505# define RTEnvGetExecEnvP                               RT_MANGLER(RTEnvGetExecEnvP)
    502506# define RTEnvPut                                       RT_MANGLER(RTEnvPut)
     507# define RTEnvPutBad                                    RT_MANGLER(RTEnvPutBad)
     508# define RTEnvPutUtf8                                   RT_MANGLER(RTEnvPutUtf8)
    503509# define RTEnvPutEx                                     RT_MANGLER(RTEnvPutEx)
    504510# define RTEnvQueryUtf16Block                           RT_MANGLER(RTEnvQueryUtf16Block)
    505511# define RTEnvSet                                       RT_MANGLER(RTEnvSet)
     512# define RTEnvSetBad                                    RT_MANGLER(RTEnvSetBad)
     513# define RTEnvSetUtf8                                   RT_MANGLER(RTEnvSetUtf8)
    506514# define RTEnvSetEx                                     RT_MANGLER(RTEnvSetEx)
    507515# define RTEnvUnset                                     RT_MANGLER(RTEnvUnset)
     516# define RTEnvUnsetBad                                  RT_MANGLER(RTEnvUnsetBad)
     517# define RTEnvUnsetUtf8                                 RT_MANGLER(RTEnvUnsetUtf8)
    508518# define RTEnvUnsetEx                                   RT_MANGLER(RTEnvUnsetEx)
    509519# define RTErrCOMGet                                    RT_MANGLER(RTErrCOMGet)

  • trunk/src/VBox/Runtime/Makefile.kmk

    r49845 r50408  
    604604        r3/nt/fs-nt.cpp \
    605605        r3/nt/pathint-nt.cpp \
    606         r3/posix/env-posix.cpp \
     606        r3/win/env-win.cpp \
    607607        r3/win/RTHandleGetStandard-win.cpp \
    608608        r3/win/RTSystemQueryOSInfo-win.cpp \

  • trunk/src/VBox/Runtime/generic/env-generic.cpp

    r46035 r50408  
    5757*   Defined Constants And Macros                                               *
    5858*******************************************************************************/
     59/** The allocation granularity of the RTENVINTERNAL::papszEnv memory. */
     60#define RTENV_GROW_SIZE     16
     61
    5962/** Macro that unlocks the specified environment block. */
    6063#define RTENV_LOCK(pEnvInt)     do { } while (0)
    6164/** Macro that unlocks the specified environment block. */
    6265#define RTENV_UNLOCK(pEnvInt)   do { } while (0)
     66
     67/** @def RTENV_HAVE_WENVIRON
     68 * Indicates that we have a _wenviron variable with UTF-16 strings that we
     69 * better use instead of the current-cp strings in environ. */
     70#if defined(RT_OS_WINDOWS) || defined(DOXYGEN_RUNNING)
     71# define RTENV_HAVE_WENVIRON 1
     72#endif
     73
     74/** @def RTENV_IMPLEMENTS_UTF8_DEFAULT_ENV_API
     75 * Indicates the RTEnv*Utf8 APIs are implemented. */
     76#if defined(RT_OS_WINDOWS) || defined(DOXYGEN_RUNNING)
     77# define RTENV_IMPLEMENTS_UTF8_DEFAULT_ENV_API 1
     78#endif
    6379
    6480
    … …  
    85101     * This get (re-)constructed when RTEnvGetExecEnvP method is called. */
    86102    char      **papszEnvOtherCP;
     103
     104    /** The compare function we're using. */
     105    DECLCALLBACKMEMBER(int, pfnCompare)(const char *psz1, const char *psz2, size_t cchMax);
    87106} RTENVINTERNAL, *PRTENVINTERNAL;
    88 
    89 /** The allocation granularity of the RTENVINTERNAL::papszEnv memory. */
    90 #define RTENV_GROW_SIZE     16
    91107
    92108
    … …  
    112128 *
    113129 * @returns IPRT status code.
    114  * @param   ppIntEnv    Where to store the result.
    115  * @param   cAllocated  The initial array size.
     130 * @param   ppIntEnv        Where to store the result.
     131 * @param   cAllocated      The initial array size.
     132 * @param   fCaseSensitive  Whether the environment block is case sensitive or
     133 *                          not.
    116134 */
    117 static int rtEnvCreate(PRTENVINTERNAL *ppIntEnv, size_t cAllocated)
     135static int rtEnvCreate(PRTENVINTERNAL *ppIntEnv, size_t cAllocated, bool fCaseSensitive)
    118136{
    119137    /*
    … …  
    127145         */
    128146        pIntEnv->u32Magic = RTENV_MAGIC;
     147        pIntEnv->pfnCompare = fCaseSensitive ? RTStrNCmp : RTStrNICmp;
    129148        pIntEnv->papszEnvOtherCP = NULL;
    130149        pIntEnv->cVars = 0;
    … …  
    147166{
    148167    AssertPtrReturn(pEnv, VERR_INVALID_POINTER);
    149     return rtEnvCreate(pEnv, RTENV_GROW_SIZE);
     168    return rtEnvCreate(pEnv, RTENV_GROW_SIZE, false /*fCaseSensitive*/);
    150169}
    151170RT_EXPORT_SYMBOL(RTEnvCreate);
    … …  
    201220     * Validate input and figure out how many variable to clone and where to get them.
    202221     */
     222    bool fCaseSensitive = true;
    203223    size_t cVars;
    204224    const char * const *papszEnv;
     225#ifdef RTENV_HAVE_WENVIRON
     226    PCRTUTF16 const * papwszEnv;
     227#endif
    205228    PRTENVINTERNAL pIntEnvToClone;
    206229    AssertPtrReturn(pEnv, VERR_INVALID_POINTER);
    207230    if (EnvToClone == RTENV_DEFAULT)
    208231    {
     232        cVars = 0;
    209233        pIntEnvToClone = NULL;
     234#ifdef RTENV_HAVE_WENVIRON
     235        papszEnv  = NULL;
     236        papwszEnv = (PCRTUTF16 * const )_wenviron;
     237        if (papwszEnv)
     238            while (papwszEnv[cVars])
     239                cVars++;
     240#else
    210241        papszEnv = rtEnvDefault();
    211         cVars = 0;
    212242        if (papszEnv)
    213243            while (papszEnv[cVars])
    214244                cVars++;
     245#endif
     246
     247#if defined(RT_OS_OS2) || defined(RT_OS_WINDOWS)
     248        /* DOS systems was case insensitive.  A prime example is the 'Path'
     249           variable on windows which turns into the 'PATH' variable. */
     250        fCaseSensitive = false;
     251#endif
    215252    }
    216253    else
    … …  
    229266     */
    230267    PRTENVINTERNAL pIntEnv;
    231     int rc = rtEnvCreate(&pIntEnv, cVars + 1 /* NULL */);
     268    int rc = rtEnvCreate(&pIntEnv, cVars + 1 /* NULL */, fCaseSensitive);
    232269    if (RT_SUCCESS(rc))
    233270    {
    … …  
    240277            for (size_t iSrc = 0; iSrc < cVars; iSrc++)
    241278            {
     279#ifdef RTENV_HAVE_WENVIRON
     280                int rc2 = RTUtf16ToUtf8(papwszEnv[iSrc], &pIntEnv->papszEnv[iDst]);
     281#else
    242282                int rc2 = RTStrCurrentCPToUtf8(&pIntEnv->papszEnv[iDst], papszEnv[iSrc]);
     283#endif
    243284                if (RT_SUCCESS(rc2))
    244285                    iDst++;
    … …  
    319360    if (Env == RTENV_DEFAULT)
    320361    {
     362#ifdef RT_OS_WINDOWS
     363        rc = RTEnvSetUtf8(pszVar, pszValue);
     364#else
    321365        /*
    322366         * Since RTEnvPut isn't UTF-8 clean and actually expects the strings
    … …  
    337381            RTStrFree(pszVarOtherCP);
    338382        }
     383#endif
    339384    }
    340385    else
    … …  
    364409            size_t iVar;
    365410            for (iVar = 0; iVar < pIntEnv->cVars; iVar++)
    366                 if (    !strncmp(pIntEnv->papszEnv[iVar], pszVar, cchVar)
     411                if (    !pIntEnv->pfnCompare(pIntEnv->papszEnv[iVar], pszVar, cchVar)
    367412                    &&  pIntEnv->papszEnv[iVar][cchVar] == '=')
    368413                    break;
    … …  
    424469    if (Env == RTENV_DEFAULT)
    425470    {
     471#ifdef RTENV_IMPLEMENTS_UTF8_DEFAULT_ENV_API
     472        rc = RTEnvUnsetUtf8(pszVar);
     473#else
    426474        /*
    427475         * Since RTEnvUnset isn't UTF-8 clean and actually expects the strings
    … …  
    436484            RTStrFree(pszVarOtherCP);
    437485        }
     486#endif
    438487    }
    439488    else
    … …  
    452501        size_t iVar;
    453502        for (iVar = 0; iVar < pIntEnv->cVars; iVar++)
    454             if (    !strncmp(pIntEnv->papszEnv[iVar], pszVar, cchVar)
     503            if (    !pIntEnv->pfnCompare(pIntEnv->papszEnv[iVar], pszVar, cchVar)
    455504                &&  pIntEnv->papszEnv[iVar][cchVar] == '=')
    456505            {
    … …  
    484533    if (Env == RTENV_DEFAULT)
    485534    {
     535#ifdef RTENV_IMPLEMENTS_UTF8_DEFAULT_ENV_API
     536        rc = RTEnvGetUtf8(pszVar, pszValue, cbValue, pcchActual);
     537#else
    486538        /*
    487539         * Since RTEnvGet isn't UTF-8 clean and actually expects the strings
    … …  
    518570                rc = VERR_ENV_VAR_NOT_FOUND;
    519571        }
     572#endif
    520573    }
    521574    else
    … …  
    534587        size_t iVar;
    535588        for (iVar = 0; iVar < pIntEnv->cVars; iVar++)
    536             if (    !strncmp(pIntEnv->papszEnv[iVar], pszVar, cchVar)
     589            if (    !pIntEnv->pfnCompare(pIntEnv->papszEnv[iVar], pszVar, cchVar)
    537590                &&  pIntEnv->papszEnv[iVar][cchVar] == '=')
    538591            {
    … …  
    555608    }
    556609    return rc;
    557 
    558610}
    559611RT_EXPORT_SYMBOL(RTEnvGetEx);
    … …  
    564616    AssertPtrReturn(pszVar, false);
    565617
    566     bool fExist = false;
     618    bool fExists = false;
    567619    if (Env == RTENV_DEFAULT)
    568620    {
     621#ifdef RTENV_IMPLEMENTS_UTF8_DEFAULT_ENV_API
     622        fExists = RTEnvExistsUtf8(pszVar);
     623#else
    569624        /*
    570625         * Since RTEnvExist isn't UTF-8 clean and actually expects the strings
    … …  
    576631        if (RT_SUCCESS(rc))
    577632        {
    578             fExist = RTEnvExist(pszVarOtherCP);
     633            fExists = RTEnvExist(pszVarOtherCP);
    579634            RTStrFree(pszVarOtherCP);
    580635        }
     636#endif
    581637    }
    582638    else
    … …  
    593649        const size_t cchVar = strlen(pszVar);
    594650        for (size_t iVar = 0; iVar < pIntEnv->cVars; iVar++)
    595             if (    !strncmp(pIntEnv->papszEnv[iVar], pszVar, cchVar)
     651            if (    !pIntEnv->pfnCompare(pIntEnv->papszEnv[iVar], pszVar, cchVar)
    596652                &&  pIntEnv->papszEnv[iVar][cchVar] == '=')
    597653            {
    598                 fExist = true;
     654                fExists = true;
    599655                break;
    600656            }
    … …  
    602658        RTENV_UNLOCK(pIntEnv);
    603659    }
    604     return fExist;
     660    return fExists;
    605661}
    606662RT_EXPORT_SYMBOL(RTEnvExistEx);
    … …  
    612668    if (Env == RTENV_DEFAULT)
    613669    {
     670        /** @todo fix this API it's fundamentally wrong! */
    614671        papszRet = rtEnvDefault();
    615672        if (!papszRet)

  • trunk/src/VBox/Runtime/r3/posix/env-posix.cpp

    r48935 r50408  
    55
    66/*
    7  * Copyright (C) 2006-2010 Oracle Corporation
     7 * Copyright (C) 2006-2014 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    4747
    4848
    49 RTDECL(bool) RTEnvExist(const char *pszVar)
     49RTDECL(bool) RTEnvExistsBad(const char *pszVar)
    5050{
    51     return RTEnvGet(pszVar) != NULL;
     51    return RTEnvGetBad(pszVar) != NULL;
    5252}
    5353
    5454
    55 RTDECL(const char *) RTEnvGet(const char *pszVar)
     55RTDECL(bool) RTEnvExist(const char *pszVar)
     56{
     57    return RTEnvExistsBad(pszVar);
     58}
     59
     60
     61RTDECL(const char *) RTEnvGetBad(const char *pszVar)
    5662{
    5763    IPRT_ALIGNMENT_CHECKS_DISABLE(); /* glibc causes trouble */
    … …  
    6268
    6369
    64 RTDECL(int) RTEnvPut(const char *pszVarEqualValue)
     70RTDECL(const char *) RTEnvGet(const char *pszVar)
     71{
     72    return RTEnvGetBad(pszVar);
     73}
     74
     75
     76RTDECL(int) RTEnvPutBad(const char *pszVarEqualValue)
    6577{
    6678    /** @todo putenv is a source memory leaks. deal with this on a per system basis. */
    … …  
    7082}
    7183
    72 RTDECL(int) RTEnvSet(const char *pszVar, const char *pszValue)
     84
     85RTDECL(int) RTEnvPut(const char *pszVarEqualValue)
     86{
     87    return RTEnvPutBad(pszVarEqualValue);
     88}
     89
     90
     91RTDECL(int) RTEnvSetBad(const char *pszVar, const char *pszValue)
    7392{
    7493#if defined(_MSC_VER)
    … …  
    99118
    100119
    101 RTDECL(int) RTEnvUnset(const char *pszVar)
     120RTDECL(int) RTEnvSet(const char *pszVar, const char *pszValue)
     121{
     122    return RTEnvSetBad(pszVar, pszValue);
     123}
     124
     125RTDECL(int) RTEnvUnsetBad(const char *pszVar)
    102126{
    103127    AssertReturn(!strchr(pszVar, '='), VERR_INVALID_PARAMETER);
    … …  
    132156}
    133157
     158RTDECL(int) RTEnvUnset(const char *pszVar)
     159{
     160    return RTEnvUnsetBad(pszVar);
     161}
     162

  • trunk/src/VBox/Runtime/r3/win/env-win.cpp

    r50388 r50408  
    55
    66/*
    7  * Copyright (C) 2006-2010 Oracle Corporation
     7 * Copyright (C) 2006-2014 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2929*   Header Files                                                               *
    3030*******************************************************************************/
    31 #ifdef RT_OS_DARWIN
    32 /* pick the correct prototype for unsetenv. */
    33 # define _POSIX_C_SOURCE 1
    34 #endif
    3531#include <iprt/env.h>
    36 #include <iprt/string.h>
     32
    3733#include <iprt/alloca.h>
    3834#include <iprt/assert.h>
    39 #if defined(DEBUG) && defined(RT_OS_LINUX)
    40 # include <iprt/asm.h>
    41 #endif
     35#include <iprt/string.h>
     36#include <iprt/mem.h>
    4237
    4338#include <stdlib.h>
    4439#include <errno.h>
    4540
    46 #include "internal/alignmentchecks.h"
     41
     42RTDECL(bool) RTEnvExistsBad(const char *pszVar)
     43{
     44    return RTEnvGetBad(pszVar) != NULL;
     45}
    4746
    4847
    4948RTDECL(bool) RTEnvExist(const char *pszVar)
    5049{
    51     return RTEnvGet(pszVar) != NULL;
     50    return RTEnvExistsBad(pszVar);
     51}
     52
     53
     54RTDECL(bool) RTEnvExistsUtf8(const char *pszVar)
     55{
     56    PRTUTF16 pwszVar;
     57    int rc = RTStrToUtf16(pszVar, &pwszVar);
     58    AssertRCReturn(rc, false);
     59    bool fRet = _wgetenv(pwszVar) != NULL;
     60    RTUtf16Free(pwszVar);
     61    return fRet;
     62}
     63
     64
     65RTDECL(const char *) RTEnvGetBad(const char *pszVar)
     66{
     67    return getenv(pszVar);
    5268}
    5369
    … …  
    5571RTDECL(const char *) RTEnvGet(const char *pszVar)
    5672{
    57     IPRT_ALIGNMENT_CHECKS_DISABLE(); /* glibc causes trouble */
    58     const char *pszValue = getenv(pszVar);
    59     IPRT_ALIGNMENT_CHECKS_ENABLE();
    60     return pszValue;
    61 }
    62 
    63 
    64 RTDECL(int) RTEnvPut(const char *pszVarEqualValue)
     73    return RTEnvGetBad(pszVar);
     74}
     75
     76RTDECL(int) RTEnvGetUtf8(const char *pszVar, char *pszValue, size_t cbValue, size_t *pcchActual)
     77{
     78    AssertPtrReturn(pszVar, VERR_INVALID_POINTER);
     79    AssertPtrNullReturn(pszValue, VERR_INVALID_POINTER);
     80    AssertReturn(pszValue || !cbValue, VERR_INVALID_PARAMETER);
     81    AssertPtrNullReturn(pcchActual, VERR_INVALID_POINTER);
     82    AssertReturn(pcchActual || (pszValue && cbValue), VERR_INVALID_PARAMETER);
     83
     84    if (pcchActual)
     85        *pcchActual = 0;
     86
     87    PRTUTF16 pwszVar;
     88    int rc = RTStrToUtf16(pszVar, &pwszVar);
     89    AssertRCReturn(rc, false);
     90
     91    /** @todo Consider _wgetenv_s or GetEnvironmentVariableW here to avoid the
     92     *        potential race with a concurrent _wputenv/_putenv. */
     93    PCRTUTF16 pwszValue = _wgetenv(pwszVar);
     94    RTUtf16Free(pwszVar);
     95    if (pwszValue)
     96    {
     97        if (cbValue)
     98            rc = RTUtf16ToUtf8Ex(pwszValue, RTSTR_MAX, &pszValue, cbValue, pcchActual);
     99        else
     100            rc = RTUtf16CalcUtf8LenEx(pwszValue, RTSTR_MAX, pcchActual);
     101    }
     102    else
     103        rc = VERR_ENV_VAR_NOT_FOUND;
     104    return rc;
     105}
     106
     107
     108RTDECL(int) RTEnvPutBad(const char *pszVarEqualValue)
    65109{
    66110    /** @todo putenv is a source memory leaks. deal with this on a per system basis. */
    … …  
    70114}
    71115
    72 RTDECL(int) RTEnvSet(const char *pszVar, const char *pszValue)
    73 {
    74 #if defined(_MSC_VER)
     116
     117RTDECL(int) RTEnvPut(const char *pszVarEqualValue)
     118{
     119    return RTEnvPutBad(pszVarEqualValue);
     120}
     121
     122
     123RTDECL(int) RTEnvPutUtf8(const char *pszVarEqualValue)
     124{
     125    PRTUTF16 pwszVarEqualValue;
     126    int rc = RTStrToUtf16(pszVarEqualValue, &pwszVarEqualValue);
     127    if (RT_SUCCESS(rc))
     128    {
     129        if (!_wputenv(pwszVarEqualValue))
     130            rc = VINF_SUCCESS;
     131        else
     132            rc = RTErrConvertFromErrno(errno);
     133        RTUtf16Free(pwszVarEqualValue);
     134    }
     135    return rc;
     136}
     137
     138
     139
     140RTDECL(int) RTEnvSetBad(const char *pszVar, const char *pszValue)
     141{
    75142    /* make a local copy and feed it to putenv. */
    76143    const size_t cchVar = strlen(pszVar);
    … …  
    90157        return 0;
    91158    return RTErrConvertFromErrno(errno);
    92 
    93 #else
    94     if (!setenv(pszVar, pszValue, 1))
    95         return VINF_SUCCESS;
    96     return RTErrConvertFromErrno(errno);
    97 #endif
    98 }
    99 
    100 
    101 RTDECL(int) RTEnvUnset(const char *pszVar)
     159}
     160
     161
     162RTDECL(int) RTEnvSet(const char *pszVar, const char *pszValue)
     163{
     164    return RTEnvSetBad(pszVar, pszValue);
     165}
     166
     167RTDECL(int) RTEnvSetUtf8(const char *pszVar, const char *pszValue)
     168{
     169    size_t cwcVar;
     170    int rc = RTStrCalcUtf16LenEx(pszVar, RTSTR_MAX, &cwcVar);
     171    if (RT_SUCCESS(rc))
     172    {
     173        size_t cwcValue;
     174        rc = RTStrCalcUtf16LenEx(pszVar, RTSTR_MAX, &cwcValue);
     175        if (RT_SUCCESS(rc))
     176        {
     177            PRTUTF16 pwszTmp = (PRTUTF16)RTMemTmpAlloc((cwcVar + 1 + cwcValue + 1) * sizeof(RTUTF16));
     178            if (pwszTmp)
     179            {
     180                rc = RTStrToUtf16Ex(pszVar, RTSTR_MAX, &pwszTmp, cwcVar + 1, NULL);
     181                if (RT_SUCCESS(rc))
     182                {
     183                    PRTUTF16 pwszTmpValue = &pwszTmp[cwcVar];
     184                    *pwszTmpValue++ = '=';
     185                    rc = RTStrToUtf16Ex(pszValue, RTSTR_MAX, &pwszTmpValue, cwcValue + 1, NULL);
     186                    if (RT_SUCCESS(rc))
     187                    {
     188                        if (!_wputenv(pwszTmp))
     189                            rc = VINF_SUCCESS;
     190                        else
     191                            rc = RTErrConvertFromErrno(errno);
     192                    }
     193                }
     194                RTMemTmpFree(pwszTmp);
     195            }
     196            else
     197                rc = VERR_NO_TMP_MEMORY;
     198        }
     199    }
     200    return rc;
     201}
     202
     203
     204RTDECL(int) RTEnvUnsetBad(const char *pszVar)
    102205{
    103206    AssertReturn(!strchr(pszVar, '='), VERR_INVALID_PARAMETER);
    … …  
    132235}
    133236
     237
     238RTDECL(int) RTEnvUnset(const char *pszVar)
     239{
     240    return RTEnvUnsetBad(pszVar);
     241}
     242
     243
     244RTDECL(int) RTEnvUnsetUtf8(const char *pszVar)
     245{
     246    size_t cwcVar;
     247    int rc = RTStrCalcUtf16LenEx(pszVar, RTSTR_MAX, &cwcVar);
     248    if (RT_SUCCESS(rc))
     249    {
     250        PRTUTF16 pwszTmp = (PRTUTF16)RTMemTmpAlloc((cwcVar + 1 + 1) * sizeof(RTUTF16));
     251        if (pwszTmp)
     252        {
     253            rc = RTStrToUtf16Ex(pszVar, RTSTR_MAX, &pwszTmp, cwcVar + 1, NULL);
     254            if (RT_SUCCESS(rc))
     255            {
     256                pwszTmp[cwcVar] = '=';
     257                pwszTmp[cwcVar + 1] = '\0';
     258                if (!_wputenv(pwszTmp))
     259                    rc = VINF_SUCCESS;
     260                else
     261                    rc = RTErrConvertFromErrno(errno);
     262            }
     263            RTMemTmpFree(pwszTmp);
     264        }
     265    }
     266    return rc;
     267}
     268
注意: 瀏覽 TracChangeset 來幫助您使用更動檢視器

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette