dlls/kernelbase/main.c

   1 /*
   2  * Copyright 2016 Michael Müller
   3  * Copyright 2017 Andrey Gusev
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #define COBJMACROS
  21
  22 #include "ntstatus.h"
  23 #define WIN32_NO_STATUS
  24 #include "windows.h"
  25 #include "appmodel.h"
  26 #include "shlwapi.h"
  27
  28 #include "wine/debug.h"
  29 #include "wine/heap.h"
  30 #include "winternl.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(kernelbase);
  33
  34
  35 /*************************************************************
  36  *            DllMainCRTStartup
  37  */
  38 BOOL WINAPI DllMainCRTStartup( HANDLE inst, DWORD reason, LPVOID reserved )
  39 {
  40     return TRUE;
  41 }
  42
  43
  44 /***********************************************************************
  45  *          AppPolicyGetProcessTerminationMethod (KERNELBASE.@)
  46  */
  47 LONG WINAPI AppPolicyGetProcessTerminationMethod(HANDLE token, AppPolicyProcessTerminationMethod *policy)
  48 {
  49     FIXME("%p, %p\n", token, policy);
  50
  51     if(policy)
  52         *policy = AppPolicyProcessTerminationMethod_ExitProcess;
  53
  54     return ERROR_SUCCESS;
  55 }
  56
  57 /***********************************************************************
  58  *          AppPolicyGetThreadInitializationType (KERNELBASE.@)
  59  */
  60 LONG WINAPI AppPolicyGetThreadInitializationType(HANDLE token, AppPolicyThreadInitializationType *policy)
  61 {
  62     FIXME("%p, %p\n", token, policy);
  63
  64     if(policy)
  65         *policy = AppPolicyThreadInitializationType_None;
  66
  67     return ERROR_SUCCESS;
  68 }
  69
  70 /***********************************************************************
  71  *          AppPolicyGetShowDeveloperDiagnostic (KERNELBASE.@)
  72  */
  73 LONG WINAPI AppPolicyGetShowDeveloperDiagnostic(HANDLE token, AppPolicyShowDeveloperDiagnostic *policy)
  74 {
  75     FIXME("%p, %p\n", token, policy);
  76
  77     if(policy)
  78         *policy = AppPolicyShowDeveloperDiagnostic_ShowUI;
  79
  80     return ERROR_SUCCESS;
  81 }
  82
  83 /***********************************************************************
  84  *          AppPolicyGetWindowingModel (KERNELBASE.@)
  85  */
  86 LONG WINAPI AppPolicyGetWindowingModel(HANDLE token, AppPolicyWindowingModel *policy)
  87 {
  88     FIXME("%p, %p\n", token, policy);
  89
  90     if(policy)
  91         *policy = AppPolicyWindowingModel_ClassicDesktop;
  92
  93     return ERROR_SUCCESS;
  94 }
  95
  96 /***********************************************************************
  97  *           QuirkIsEnabled   (KERNELBASE.@)
  98  */
  99 BOOL WINAPI QuirkIsEnabled(void *arg)
 100 {
 101     FIXME("(%p): stub\n", arg);
 102     return FALSE;
 103 }
 104
 105 /***********************************************************************
 106  *          QuirkIsEnabled3 (KERNELBASE.@)
 107  */
 108 BOOL WINAPI QuirkIsEnabled3(void *unk1, void *unk2)
 109 {
 110     static int once;
 111
 112     if (!once++)
 113         FIXME("(%p, %p) stub!\n", unk1, unk2);
 114
 115     return FALSE;
 116 }
 117
 118 /***********************************************************************
 119  *           WaitOnAddress   (KERNELBASE.@)
 120  */
 121 BOOL WINAPI WaitOnAddress(volatile void *addr, void *cmp, SIZE_T size, DWORD timeout)
 122 {
 123     LARGE_INTEGER to;
 124     NTSTATUS status;
 125
 126     if (timeout != INFINITE)
 127     {
 128         to.QuadPart = -(LONGLONG)timeout * 10000;
 129         status = RtlWaitOnAddress((const void *)addr, cmp, size, &to);
 130     }
 131     else
 132         status = RtlWaitOnAddress((const void *)addr, cmp, size, NULL);
 133
 134     if (status != STATUS_SUCCESS)
 135     {
 136         SetLastError( RtlNtStatusToDosError(status) );
 137         return FALSE;
 138     }
 139
 140     return TRUE;
 141 }
 142
 143 HRESULT WINAPI QISearch(void *base, const QITAB *table, REFIID riid, void **obj)
 144 {
 145     const QITAB *ptr;
 146     IUnknown *unk;
 147
 148     TRACE("%p, %p, %s, %p\n", base, table, debugstr_guid(riid), obj);
 149
 150     if (!obj)
 151         return E_POINTER;
 152
 153     for (ptr = table; ptr->piid; ++ptr)
 154     {
 155         TRACE("trying (offset %d) %s\n", ptr->dwOffset, debugstr_guid(ptr->piid));
 156         if (IsEqualIID(riid, ptr->piid))
 157         {
 158             unk = (IUnknown *)((BYTE *)base + ptr->dwOffset);
 159             TRACE("matched, returning (%p)\n", unk);
 160             *obj = unk;
 161             IUnknown_AddRef(unk);
 162             return S_OK;
 163         }
 164     }
 165
 166     if (IsEqualIID(riid, &IID_IUnknown))
 167     {
 168         unk = (IUnknown *)((BYTE *)base + table->dwOffset);
 169         TRACE("returning first for IUnknown (%p)\n", unk);
 170         *obj = unk;
 171         IUnknown_AddRef(unk);
 172         return S_OK;
 173     }
 174
 175     WARN("Not found %s.\n", debugstr_guid(riid));
 176     *obj = NULL;
 177     return E_NOINTERFACE;
 178 }
 179
 180 HRESULT WINAPI GetAcceptLanguagesA(LPSTR langbuf, DWORD *buflen)
 181 {
 182     DWORD buflenW, convlen;
 183     WCHAR *langbufW;
 184     HRESULT hr;
 185
 186     TRACE("%p, %p, *%p: %d\n", langbuf, buflen, buflen, buflen ? *buflen : -1);
 187
 188     if (!langbuf || !buflen || !*buflen)
 189         return E_FAIL;
 190
 191     buflenW = *buflen;
 192     langbufW = heap_alloc(sizeof(WCHAR) * buflenW);
 193     hr = GetAcceptLanguagesW(langbufW, &buflenW);
 194
 195     if (hr == S_OK)
 196     {
 197         convlen = WideCharToMultiByte(CP_ACP, 0, langbufW, -1, langbuf, *buflen, NULL, NULL);
 198         convlen--;  /* do not count the terminating 0 */
 199     }
 200     else  /* copy partial string anyway */
 201     {
 202         convlen = WideCharToMultiByte(CP_ACP, 0, langbufW, *buflen, langbuf, *buflen, NULL, NULL);
 203         if (convlen < *buflen)
 204         {
 205             langbuf[convlen] = 0;
 206             convlen--;  /* do not count the terminating 0 */
 207         }
 208         else
 209         {
 210             convlen = *buflen;
 211         }
 212     }
 213     *buflen = buflenW ? convlen : 0;
 214
 215     heap_free(langbufW);
 216     return hr;
 217 }
 218
 219 static HRESULT lcid_to_rfc1766(LCID lcid, WCHAR *rfc1766, INT len)
 220 {
 221     WCHAR buffer[6 /* MAX_RFC1766_NAME */];
 222     INT n = GetLocaleInfoW(lcid, LOCALE_SISO639LANGNAME, buffer, ARRAY_SIZE(buffer));
 223     INT i;
 224
 225     if (n)
 226     {
 227         i = PRIMARYLANGID(lcid);
 228         if ((((i == LANG_ENGLISH) || (i == LANG_CHINESE) || (i == LANG_ARABIC)) &&
 229             (SUBLANGID(lcid) == SUBLANG_DEFAULT)) ||
 230             (SUBLANGID(lcid) > SUBLANG_DEFAULT)) {
 231
 232             buffer[n - 1] = '-';
 233             i = GetLocaleInfoW(lcid, LOCALE_SISO3166CTRYNAME, buffer + n, ARRAY_SIZE(buffer) - n);
 234             if (!i)
 235                 buffer[n - 1] = '\0';
 236         }
 237         else
 238             i = 0;
 239
 240         LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE, buffer, n + i, rfc1766, len);
 241         return ((n + i) > len) ? E_INVALIDARG : S_OK;
 242     }
 243     return E_FAIL;
 244 }
 245
 246 HRESULT WINAPI GetAcceptLanguagesW(WCHAR *langbuf, DWORD *buflen)
 247 {
 248     static const WCHAR keyW[] = {
 249         'S','o','f','t','w','a','r','e','\\',
 250         'M','i','c','r','o','s','o','f','t','\\',
 251         'I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r','\\',
 252         'I','n','t','e','r','n','a','t','i','o','n','a','l',0};
 253     static const WCHAR valueW[] = {'A','c','c','e','p','t','L','a','n','g','u','a','g','e',0};
 254     DWORD mystrlen, mytype;
 255     WCHAR *mystr;
 256     LCID mylcid;
 257     HKEY mykey;
 258     LONG lres;
 259     DWORD len;
 260
 261     TRACE("%p, %p, *%p: %d\n", langbuf, buflen, buflen, buflen ? *buflen : -1);
 262
 263     if (!langbuf || !buflen || !*buflen)
 264         return E_FAIL;
 265
 266     mystrlen = (*buflen > 20) ? *buflen : 20 ;
 267     len = mystrlen * sizeof(WCHAR);
 268     mystr = heap_alloc(len);
 269     mystr[0] = 0;
 270     RegOpenKeyW(HKEY_CURRENT_USER, keyW, &mykey);
 271     lres = RegQueryValueExW(mykey, valueW, 0, &mytype, (PBYTE)mystr, &len);
 272     RegCloseKey(mykey);
 273     len = lstrlenW(mystr);
 274
 275     if (!lres && (*buflen > len))
 276     {
 277         lstrcpyW(langbuf, mystr);
 278         *buflen = len;
 279         heap_free(mystr);
 280         return S_OK;
 281     }
 282
 283     /* Did not find a value in the registry or the user buffer is too small */
 284     mylcid = GetUserDefaultLCID();
 285     lcid_to_rfc1766(mylcid, mystr, mystrlen);
 286     len = lstrlenW(mystr);
 287
 288     memcpy(langbuf, mystr, min(*buflen, len + 1)*sizeof(WCHAR));
 289     heap_free(mystr);
 290
 291     if (*buflen > len)
 292     {
 293         *buflen = len;
 294         return S_OK;
 295     }
 296
 297     *buflen = 0;
 298     return E_NOT_SUFFICIENT_BUFFER;
 299 }