tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

MyWindows.cpp (3688B)

      1 // MyWindows.cpp
      2 
      3 #include "StdAfx.h"
      4 
      5 #ifndef _WIN32
      6 
      7 #include <stdlib.h>
      8 
      9 #include "MyWindows.h"
     10 
     11 static inline void *AllocateForBSTR(size_t cb) { return ::malloc(cb); }
     12 static inline void FreeForBSTR(void *pv) { ::free(pv);}
     13 
     14 /* Win32 uses DWORD (32-bit) type to store size of string before (OLECHAR *) string.
     15  We must select CBstrSizeType for another systems (not Win32):
     16 
     17    if (CBstrSizeType is UINT32),
     18          then we support only strings smaller than 4 GB.
     19          Win32 version always has that limitation.
     20  
     21    if (CBstrSizeType is UINT),
     22          (UINT can be 16/32/64-bit)
     23          We can support strings larger than 4 GB (if UINT is 64-bit),
     24          but sizeof(UINT) can be different in parts compiled by
     25          different compilers/settings,
     26          and we can't send such BSTR strings between such parts.
     27 */
     28 
     29 typedef UINT32 CBstrSizeType;
     30 // typedef UINT CBstrSizeType;
     31 
     32 #define k_BstrSize_Max 0xFFFFFFFF
     33 // #define k_BstrSize_Max UINT_MAX
     34 // #define k_BstrSize_Max ((UINT)(INT)-1)
     35 
     36 BSTR SysAllocStringByteLen(LPCSTR s, UINT len)
     37 {
     38  /* Original SysAllocStringByteLen in Win32 maybe fills only unaligned null OLECHAR at the end.
     39     We provide also aligned null OLECHAR at the end. */
     40 
     41  if (len >= (k_BstrSize_Max - sizeof(OLECHAR) - sizeof(OLECHAR) - sizeof(CBstrSizeType)))
     42    return NULL;
     43 
     44  UINT size = (len + sizeof(OLECHAR) + sizeof(OLECHAR) - 1) & ~(sizeof(OLECHAR) - 1);
     45  void *p = AllocateForBSTR(size + sizeof(CBstrSizeType));
     46  if (!p)
     47    return NULL;
     48  *(CBstrSizeType *)p = (CBstrSizeType)len;
     49  BSTR bstr = (BSTR)((CBstrSizeType *)p + 1);
     50  if (s)
     51    memcpy(bstr, s, len);
     52  for (; len < size; len++)
     53    ((Byte *)bstr)[len] = 0;
     54  return bstr;
     55 }
     56 
     57 BSTR SysAllocStringLen(const OLECHAR *s, UINT len)
     58 {
     59  if (len >= (k_BstrSize_Max - sizeof(OLECHAR) - sizeof(CBstrSizeType)) / sizeof(OLECHAR))
     60    return NULL;
     61 
     62  UINT size = len * sizeof(OLECHAR);
     63  void *p = AllocateForBSTR(size + sizeof(CBstrSizeType) + sizeof(OLECHAR));
     64  if (!p)
     65    return NULL;
     66  *(CBstrSizeType *)p = (CBstrSizeType)size;
     67  BSTR bstr = (BSTR)((CBstrSizeType *)p + 1);
     68  if (s)
     69    memcpy(bstr, s, size);
     70  bstr[len] = 0;
     71  return bstr;
     72 }
     73 
     74 BSTR SysAllocString(const OLECHAR *s)
     75 {
     76  if (!s)
     77    return 0;
     78  const OLECHAR *s2 = s;
     79  while (*s2 != 0)
     80    s2++;
     81  return SysAllocStringLen(s, (UINT)(s2 - s));
     82 }
     83 
     84 void SysFreeString(BSTR bstr)
     85 {
     86  if (bstr)
     87    FreeForBSTR((CBstrSizeType *)bstr - 1);
     88 }
     89 
     90 UINT SysStringByteLen(BSTR bstr)
     91 {
     92  if (!bstr)
     93    return 0;
     94  return *((CBstrSizeType *)bstr - 1);
     95 }
     96 
     97 UINT SysStringLen(BSTR bstr)
     98 {
     99  if (!bstr)
    100    return 0;
    101  return *((CBstrSizeType *)bstr - 1) / sizeof(OLECHAR);
    102 }
    103 
    104 
    105 HRESULT VariantClear(VARIANTARG *prop)
    106 {
    107  if (prop->vt == VT_BSTR)
    108    SysFreeString(prop->bstrVal);
    109  prop->vt = VT_EMPTY;
    110  return S_OK;
    111 }
    112 
    113 HRESULT VariantCopy(VARIANTARG *dest, const VARIANTARG *src)
    114 {
    115  HRESULT res = ::VariantClear(dest);
    116  if (res != S_OK)
    117    return res;
    118  if (src->vt == VT_BSTR)
    119  {
    120    dest->bstrVal = SysAllocStringByteLen((LPCSTR)src->bstrVal,
    121        SysStringByteLen(src->bstrVal));
    122    if (!dest->bstrVal)
    123      return E_OUTOFMEMORY;
    124    dest->vt = VT_BSTR;
    125  }
    126  else
    127    *dest = *src;
    128  return S_OK;
    129 }
    130 
    131 LONG CompareFileTime(const FILETIME* ft1, const FILETIME* ft2)
    132 {
    133  if (ft1->dwHighDateTime < ft2->dwHighDateTime) return -1;
    134  if (ft1->dwHighDateTime > ft2->dwHighDateTime) return 1;
    135  if (ft1->dwLowDateTime < ft2->dwLowDateTime) return -1;
    136  if (ft1->dwLowDateTime > ft2->dwLowDateTime) return 1;
    137  return 0;
    138 }
    139 
    140 DWORD GetLastError()
    141 {
    142  return 0;
    143 }
    144 
    145 #endif