The Tor Browser: other-licenses/nsis/Contrib/ExDLL/exdllutil.cpp@97036ab72558

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

     1 // Unicode support by Jim Park -- 08/23/2007

     3 #include <windows.h>

     4 #include "exdllutil.h"

     6 // utility functions (not required but often useful)

     7 static int __stdcall popstring(TCHAR *str)

8 {

     9   stack_t *th;

    10   if (!g_stacktop || !*g_stacktop) return 1;

    11   th=(*g_stacktop);

    12   lstrcpy(str,th->text);

    13   *g_stacktop = th->next;

    14   GlobalFree((HGLOBAL)th);

    15   return 0;

    16 }

    18 static void __stdcall pushstring(const TCHAR *str)

    19 {

    20   stack_t *th;

    21   if (!g_stacktop) return;

    22   th=(stack_t*)GlobalAlloc(GPTR,(sizeof(stack_t)+(g_stringsize)*sizeof(TCHAR)));

    23   lstrcpyn(th->text,str,g_stringsize);

    24   th->next=*g_stacktop;

    25   *g_stacktop=th;

    26 }

    28 static TCHAR * __stdcall getuservariable(const int varnum)

    29 {

    30   if (varnum < 0 || varnum >= __INST_LAST) return NULL;

    31   return g_variables+varnum*g_stringsize;

    32 }

    34 static void __stdcall setuservariable(const int varnum, const TCHAR *var)

    35 {

    36 	if (var != NULL && varnum >= 0 && varnum < __INST_LAST)

    37 		lstrcpy(g_variables + varnum*g_stringsize, var);

    38 }

    40 #ifdef _UNICODE

    41 static int __stdcall PopStringA(char* ansiStr)

    42 {

    43    wchar_t* wideStr = (wchar_t*) GlobalAlloc(GPTR, g_stringsize*sizeof(wchar_t));

    44    int rval = popstring(wideStr);

    45    WideCharToMultiByte(CP_ACP, 0, wideStr, -1, ansiStr, g_stringsize, NULL, NULL);

    46    GlobalFree((HGLOBAL)wideStr);

    47    return rval;

    48 }

    50 static void __stdcall PushStringA(const char* ansiStr)

    51 {

    52    wchar_t* wideStr = (wchar_t*) GlobalAlloc(GPTR, g_stringsize*sizeof(wchar_t));

    53    MultiByteToWideChar(CP_ACP, 0, ansiStr, -1, wideStr, g_stringsize);

    54    pushtring(wideStr);

    55    GlobalFree((HGLOBAL)wideStr);

    56    return;

    57 }

    59 static void __stdcall GetUserVariableW(const int varnum, wchar_t* wideStr)

    60 {

    61    lstrcpyW(wideStr, getuservariable(varnum));

    62 }

    64 static void __stdcall GetUserVariableA(const int varnum, char* ansiStr)

    65 {

    66    wchar_t* wideStr = getuservariable(varnum);

    67    WideCharToMultiByte(CP_ACP, 0, wideStr, -1, ansiStr, g_stringsize, NULL, NULL);

    68 }

    70 static void __stdcall SetUserVariableA(const int varnum, const char* ansiStr)

    71 {

    72    if (ansiStr != NULL && varnum >= 0 && varnum < __INST_LAST)

    73    {

    74       wchar_t* wideStr = g_variables + varnum * g_stringsize;

    75       MultiByteToWideChar(CP_ACP, 0, ansiStr, -1, wideStr, g_stringsize);

    76    }

    77 }

    79 #else

    80 // ANSI defs

    81 static int __stdcall PopStringW(wchar_t* wideStr)

    82 {

    83    char* ansiStr = (char*) GlobalAlloc(GPTR, g_stringsize);

    84    int rval = popstring(ansiStr);

    85    MultiByteToWideChar(CP_ACP, 0, ansiStr, -1, wideStr, g_stringsize);

    86    GlobalFree((HGLOBAL)ansiStr);

    87    return rval;

    88 }

    90 static void __stdcall PushStringW(wchar_t* wideStr)

    91 {

    92    char* ansiStr = (char*) GlobalAlloc(GPTR, g_stringsize);

    93    WideCharToMultiByte(CP_ACP, 0, wideStr, -1, ansiStr, g_stringsize, NULL, NULL);

    94    pushstring(ansiStr);

    95    GlobalFree((HGLOBAL)ansiStr);

    96 }

    98 static void __stdcall GetUserVariableW(const int varnum, wchar_t* wideStr)

    99 {

   100    char* ansiStr = getuservariable(varnum);

   101    MultiByteToWideChar(CP_ACP, 0, ansiStr, -1, wideStr, g_stringsize);

   102 }

   104 static void __stdcall GetUserVariableA(const int varnum, char* ansiStr)

   105 {

   106    lstrcpyA(ansiStr, getuservariable(varnum));

   107 }

   109 static void __stdcall SetUserVariableW(const int varnum, const wchar_t* wideStr)

   110 {

   111    if (wideStr != NULL && varnum >= 0 && varnum < __INST_LAST)

   112    {

   113       char* ansiStr = g_variables + varnum * g_stringsize;

   114       WideCharToMultiByte(CP_ACP, 0, wideStr, -1, ansiStr, g_stringsize, NULL, NULL);

   115    }

   116 }

   117 #endif

   119 static BOOL __stdcall IsUnicode(void)

   120 {

   121 #ifdef _UNICODE

   122    return TRUE;

   123 #else

   124    return FALSE;

   125 #endif

   126 }

   128 static TCHAR* __stdcall AllocString()

   129 {

   130    return (TCHAR*) GlobalAlloc(GPTR, g_stringsize*sizeof(TCHAR));

   131 }

The Tor Browser / file revision

other-licenses/nsis/Contrib/ExDLL/exdllutil.cpp@97036ab72558

other-licenses/nsis/Contrib/ExDLL/exdllutil.cpp