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 #include "perflib.h"
  28 #include "winternl.h"
  29
  30 #include "wine/debug.h"
  31 #include "kernelbase.h"
  32 #include "wine/heap.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(kernelbase);
  35
  36
  37 BOOL is_wow64 = FALSE;
  38
  39 /***********************************************************************
  40  *           DllMain
  41  */
  42 BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
  43 {
  44     if (reason == DLL_PROCESS_ATTACH)
  45     {
  46         DisableThreadLibraryCalls( hinst );
  47         IsWow64Process( GetCurrentProcess(), &is_wow64 );
  48         init_locale();
  49         init_startup_info( NtCurrentTeb()->Peb->ProcessParameters );
  50         init_console();
  51     }
  52     return TRUE;
  53 }
  54
  55
  56 /*************************************************************
  57  *            DllMainCRTStartup
  58  */
  59 BOOL WINAPI DllMainCRTStartup( HANDLE inst, DWORD reason, LPVOID reserved )
  60 {
  61     return DllMain( inst, reason, reserved );
  62 }
  63
  64
  65 /***********************************************************************
  66  *           MulDiv   (kernelbase.@)
  67  */
  68 INT WINAPI MulDiv( INT a, INT b, INT c )
  69 {
  70     LONGLONG ret;
  71
  72     if (!c) return -1;
  73
  74     /* We want to deal with a positive divisor to simplify the logic. */
  75     if (c < 0)
  76     {
  77         a = -a;
  78         c = -c;
  79     }
  80
  81     /* If the result is positive, we "add" to round. else, we subtract to round. */
  82     if ((a < 0 && b < 0) || (a >= 0 && b >= 0))
  83         ret = (((LONGLONG)a * b) + (c / 2)) / c;
  84     else
  85         ret = (((LONGLONG)a * b) - (c / 2)) / c;
  86
  87     if (ret > 2147483647 || ret < -2147483647) return -1;
  88     return ret;
  89 }
  90
  91 /***********************************************************************
  92  *          AppPolicyGetProcessTerminationMethod (KERNELBASE.@)
  93  */
  94 LONG WINAPI AppPolicyGetProcessTerminationMethod(HANDLE token, AppPolicyProcessTerminationMethod *policy)
  95 {
  96     FIXME("%p, %p\n", token, policy);
  97
  98     if(policy)
  99         *policy = AppPolicyProcessTerminationMethod_ExitProcess;
 100
 101     return ERROR_SUCCESS;
 102 }
 103
 104 /***********************************************************************
 105  *          AppPolicyGetThreadInitializationType (KERNELBASE.@)
 106  */
 107 LONG WINAPI AppPolicyGetThreadInitializationType(HANDLE token, AppPolicyThreadInitializationType *policy)
 108 {
 109     FIXME("%p, %p\n", token, policy);
 110
 111     if(policy)
 112         *policy = AppPolicyThreadInitializationType_None;
 113
 114     return ERROR_SUCCESS;
 115 }
 116
 117 /***********************************************************************
 118  *          AppPolicyGetShowDeveloperDiagnostic (KERNELBASE.@)
 119  */
 120 LONG WINAPI AppPolicyGetShowDeveloperDiagnostic(HANDLE token, AppPolicyShowDeveloperDiagnostic *policy)
 121 {
 122     FIXME("%p, %p\n", token, policy);
 123
 124     if(policy)
 125         *policy = AppPolicyShowDeveloperDiagnostic_ShowUI;
 126
 127     return ERROR_SUCCESS;
 128 }
 129
 130 /***********************************************************************
 131  *          AppPolicyGetWindowingModel (KERNELBASE.@)
 132  */
 133 LONG WINAPI AppPolicyGetWindowingModel(HANDLE token, AppPolicyWindowingModel *policy)
 134 {
 135     FIXME("%p, %p\n", token, policy);
 136
 137     if(policy)
 138         *policy = AppPolicyWindowingModel_ClassicDesktop;
 139
 140     return ERROR_SUCCESS;
 141 }
 142
 143 /***********************************************************************
 144  *           PerfCreateInstance   (KERNELBASE.@)
 145  */
 146 PPERF_COUNTERSET_INSTANCE WINAPI PerfCreateInstance(HANDLE handle, LPCGUID guid,
 147                                                     const WCHAR *name, ULONG id)
 148 {
 149     FIXME("%p %s %s %u: stub\n", handle, debugstr_guid(guid), debugstr_w(name), id);
 150     return NULL;
 151 }
 152
 153 /***********************************************************************
 154  *           PerfDeleteInstance   (KERNELBASE.@)
 155  */
 156 ULONG WINAPI PerfDeleteInstance(HANDLE provider, PPERF_COUNTERSET_INSTANCE block)
 157 {
 158     FIXME("%p %p: stub\n", provider, block);
 159     return ERROR_CALL_NOT_IMPLEMENTED;
 160 }
 161
 162 /***********************************************************************
 163  *           PerfSetCounterSetInfo   (KERNELBASE.@)
 164  */
 165 ULONG WINAPI PerfSetCounterSetInfo(HANDLE handle, PPERF_COUNTERSET_INFO template, ULONG size)
 166 {
 167     FIXME("%p %p %u: stub\n", handle, template, size);
 168     return ERROR_CALL_NOT_IMPLEMENTED;
 169 }
 170
 171 /***********************************************************************
 172  *           PerfSetCounterRefValue   (KERNELBASE.@)
 173  */
 174 ULONG WINAPI PerfSetCounterRefValue(HANDLE provider, PPERF_COUNTERSET_INSTANCE instance,
 175                                     ULONG counterid, void *address)
 176 {
 177     FIXME("%p %p %u %p: stub\n", provider, instance, counterid, address);
 178     return ERROR_CALL_NOT_IMPLEMENTED;
 179 }
 180
 181 /***********************************************************************
 182  *           PerfStartProvider   (KERNELBASE.@)
 183  */
 184 ULONG WINAPI PerfStartProvider(GUID *guid, PERFLIBREQUEST callback, HANDLE *provider)
 185 {
 186     FIXME("%s %p %p: stub\n", debugstr_guid(guid), callback, provider);
 187     return ERROR_CALL_NOT_IMPLEMENTED;
 188 }
 189
 190 /***********************************************************************
 191  *           PerfStartProviderEx   (KERNELBASE.@)
 192  */
 193 ULONG WINAPI PerfStartProviderEx(GUID *guid, PPERF_PROVIDER_CONTEXT context, HANDLE *provider)
 194 {
 195     FIXME("%s %p %p: stub\n", debugstr_guid(guid), context, provider);
 196     return ERROR_CALL_NOT_IMPLEMENTED;
 197 }
 198
 199 /***********************************************************************
 200  *           PerfStopProvider   (KERNELBASE.@)
 201  */
 202 ULONG WINAPI PerfStopProvider(HANDLE handle)
 203 {
 204     FIXME("%p: stub\n", handle);
 205     return ERROR_CALL_NOT_IMPLEMENTED;
 206 }
 207
 208 /***********************************************************************
 209  *           QuirkIsEnabled   (KERNELBASE.@)
 210  */
 211 BOOL WINAPI QuirkIsEnabled(void *arg)
 212 {
 213     FIXME("(%p): stub\n", arg);
 214     return FALSE;
 215 }
 216
 217 /***********************************************************************
 218  *          QuirkIsEnabled3 (KERNELBASE.@)
 219  */
 220 BOOL WINAPI QuirkIsEnabled3(void *unk1, void *unk2)
 221 {
 222     static int once;
 223
 224     if (!once++)
 225         FIXME("(%p, %p) stub!\n", unk1, unk2);
 226
 227     return FALSE;
 228 }
 229
 230 HRESULT WINAPI QISearch(void *base, const QITAB *table, REFIID riid, void **obj)
 231 {
 232     const QITAB *ptr;
 233     IUnknown *unk;
 234
 235     TRACE("%p, %p, %s, %p\n", base, table, debugstr_guid(riid), obj);
 236
 237     if (!obj)
 238         return E_POINTER;
 239
 240     for (ptr = table; ptr->piid; ++ptr)
 241     {
 242         TRACE("trying (offset %d) %s\n", ptr->dwOffset, debugstr_guid(ptr->piid));
 243         if (IsEqualIID(riid, ptr->piid))
 244         {
 245             unk = (IUnknown *)((BYTE *)base + ptr->dwOffset);
 246             TRACE("matched, returning (%p)\n", unk);
 247             *obj = unk;
 248             IUnknown_AddRef(unk);
 249             return S_OK;
 250         }
 251     }
 252
 253     if (IsEqualIID(riid, &IID_IUnknown))
 254     {
 255         unk = (IUnknown *)((BYTE *)base + table->dwOffset);
 256         TRACE("returning first for IUnknown (%p)\n", unk);
 257         *obj = unk;
 258         IUnknown_AddRef(unk);
 259         return S_OK;
 260     }
 261
 262     WARN("Not found %s.\n", debugstr_guid(riid));
 263     *obj = NULL;
 264     return E_NOINTERFACE;
 265 }
 266
 267 HRESULT WINAPI GetAcceptLanguagesA(LPSTR langbuf, DWORD *buflen)
 268 {
 269     DWORD buflenW, convlen;
 270     WCHAR *langbufW;
 271     HRESULT hr;
 272
 273     TRACE("%p, %p, *%p: %d\n", langbuf, buflen, buflen, buflen ? *buflen : -1);
 274
 275     if (!langbuf || !buflen || !*buflen)
 276         return E_FAIL;
 277
 278     buflenW = *buflen;
 279     langbufW = heap_alloc(sizeof(WCHAR) * buflenW);
 280     hr = GetAcceptLanguagesW(langbufW, &buflenW);
 281
 282     if (hr == S_OK)
 283     {
 284         convlen = WideCharToMultiByte(CP_ACP, 0, langbufW, -1, langbuf, *buflen, NULL, NULL);
 285         convlen--;  /* do not count the terminating 0 */
 286     }
 287     else  /* copy partial string anyway */
 288     {
 289         convlen = WideCharToMultiByte(CP_ACP, 0, langbufW, *buflen, langbuf, *buflen, NULL, NULL);
 290         if (convlen < *buflen)
 291         {
 292             langbuf[convlen] = 0;
 293             convlen--;  /* do not count the terminating 0 */
 294         }
 295         else
 296         {
 297             convlen = *buflen;
 298         }
 299     }
 300     *buflen = buflenW ? convlen : 0;
 301
 302     heap_free(langbufW);
 303     return hr;
 304 }
 305
 306 static HRESULT lcid_to_rfc1766(LCID lcid, WCHAR *rfc1766, INT len)
 307 {
 308     WCHAR buffer[6 /* MAX_RFC1766_NAME */];
 309     INT n = GetLocaleInfoW(lcid, LOCALE_SISO639LANGNAME, buffer, ARRAY_SIZE(buffer));
 310     INT i;
 311
 312     if (n)
 313     {
 314         i = PRIMARYLANGID(lcid);
 315         if ((((i == LANG_ENGLISH) || (i == LANG_CHINESE) || (i == LANG_ARABIC)) &&
 316             (SUBLANGID(lcid) == SUBLANG_DEFAULT)) ||
 317             (SUBLANGID(lcid) > SUBLANG_DEFAULT)) {
 318
 319             buffer[n - 1] = '-';
 320             i = GetLocaleInfoW(lcid, LOCALE_SISO3166CTRYNAME, buffer + n, ARRAY_SIZE(buffer) - n);
 321             if (!i)
 322                 buffer[n - 1] = '\0';
 323         }
 324         else
 325             i = 0;
 326
 327         LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE, buffer, n + i, rfc1766, len);
 328         return ((n + i) > len) ? E_INVALIDARG : S_OK;
 329     }
 330     return E_FAIL;
 331 }
 332
 333 HRESULT WINAPI GetAcceptLanguagesW(WCHAR *langbuf, DWORD *buflen)
 334 {
 335     DWORD mystrlen, mytype;
 336     WCHAR *mystr;
 337     LCID mylcid;
 338     HKEY mykey;
 339     LONG lres;
 340     DWORD len;
 341
 342     TRACE("%p, %p, *%p: %d\n", langbuf, buflen, buflen, buflen ? *buflen : -1);
 343
 344     if (!langbuf || !buflen || !*buflen)
 345         return E_FAIL;
 346
 347     mystrlen = (*buflen > 20) ? *buflen : 20 ;
 348     len = mystrlen * sizeof(WCHAR);
 349     mystr = heap_alloc(len);
 350     mystr[0] = 0;
 351     RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Internet Explorer\\International",
 352                   0, KEY_QUERY_VALUE, &mykey);
 353     lres = RegQueryValueExW(mykey, L"AcceptLanguage", 0, &mytype, (PBYTE)mystr, &len);
 354     RegCloseKey(mykey);
 355     len = lstrlenW(mystr);
 356
 357     if (!lres && (*buflen > len))
 358     {
 359         lstrcpyW(langbuf, mystr);
 360         *buflen = len;
 361         heap_free(mystr);
 362         return S_OK;
 363     }
 364
 365     /* Did not find a value in the registry or the user buffer is too small */
 366     mylcid = GetUserDefaultLCID();
 367     lcid_to_rfc1766(mylcid, mystr, mystrlen);
 368     len = lstrlenW(mystr);
 369
 370     memcpy(langbuf, mystr, min(*buflen, len + 1)*sizeof(WCHAR));
 371     heap_free(mystr);
 372
 373     if (*buflen > len)
 374     {
 375         *buflen = len;
 376         return S_OK;
 377     }
 378
 379     *buflen = 0;
 380     return E_NOT_SUFFICIENT_BUFFER;
 381 }