dlls/kernelbase/loader.c

   1 /*
   2  * Module loader
   3  *
   4  * Copyright 1993 Robert J. Amstadt
   5  * Copyright 2006 Mike McCormack
   6  * Copyright 1995, 2003, 2019 Alexandre Julliard
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include <stdarg.h>
  24
  25 #define NONAMELESSUNION
  26 #define NONAMELESSSTRUCT
  27 #include "ntstatus.h"
  28 #define WIN32_NO_STATUS
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winnls.h"
  32 #include "winternl.h"
  33 #include "kernelbase.h"
  34 #include "wine/list.h"
  35 #include "wine/asm.h"
  36 #include "wine/debug.h"
  37 #include "wine/exception.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(module);
  40
  41
  42 /* to keep track of LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE file handles */
  43 struct exclusive_datafile
  44 {
  45     struct list entry;
  46     HMODULE     module;
  47     HANDLE      file;
  48 };
  49 static struct list exclusive_datafile_list = LIST_INIT( exclusive_datafile_list );
  50
  51 static CRITICAL_SECTION exclusive_datafile_list_section;
  52 static CRITICAL_SECTION_DEBUG critsect_debug =
  53 {
  54     0, 0, &exclusive_datafile_list_section,
  55     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  56       0, 0, { (DWORD_PTR)(__FILE__ ": exclusive_datafile_list_section") }
  57 };
  58 static CRITICAL_SECTION exclusive_datafile_list_section = { &critsect_debug, -1, 0, 0, 0, 0 };
  59
  60 /***********************************************************************
  61  * Modules
  62  ***********************************************************************/
  63
  64
  65 /******************************************************************
  66  *      get_proc_address
  67  */
  68 FARPROC WINAPI get_proc_address( HMODULE module, LPCSTR function )
  69 {
  70     FARPROC proc;
  71     ANSI_STRING str;
  72
  73     if (!module) module = NtCurrentTeb()->Peb->ImageBaseAddress;
  74
  75     if ((ULONG_PTR)function >> 16)
  76     {
  77         RtlInitAnsiString( &str, function );
  78         if (!set_ntstatus( LdrGetProcedureAddress( module, &str, 0, (void**)&proc ))) return NULL;
  79     }
  80     else if (!set_ntstatus( LdrGetProcedureAddress( module, NULL, LOWORD(function), (void**)&proc )))
  81         return NULL;
  82
  83     return proc;
  84 }
  85
  86
  87 /******************************************************************
  88  *      load_library_as_datafile
  89  */
  90 static BOOL load_library_as_datafile( LPCWSTR load_path, DWORD flags, LPCWSTR name, HMODULE *mod_ret )
  91 {
  92     WCHAR filenameW[MAX_PATH];
  93     HANDLE mapping, file = INVALID_HANDLE_VALUE;
  94     HMODULE module = 0;
  95     DWORD protect = PAGE_READONLY;
  96
  97     *mod_ret = 0;
  98
  99     if (flags & LOAD_LIBRARY_AS_IMAGE_RESOURCE) protect |= SEC_IMAGE;
 100
 101     if (SearchPathW( NULL, name, L".dll", ARRAY_SIZE( filenameW ), filenameW, NULL ))
 102     {
 103         file = CreateFileW( filenameW, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_DELETE,
 104                             NULL, OPEN_EXISTING, 0, 0 );
 105     }
 106     if (file == INVALID_HANDLE_VALUE) return FALSE;
 107
 108     mapping = CreateFileMappingW( file, NULL, protect, 0, 0, NULL );
 109     if (!mapping) goto failed;
 110
 111     module = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
 112     CloseHandle( mapping );
 113     if (!module) goto failed;
 114
 115     if (!(flags & LOAD_LIBRARY_AS_IMAGE_RESOURCE))
 116     {
 117         /* make sure it's a valid PE file */
 118         if (!RtlImageNtHeader( module ))
 119         {
 120             SetLastError( ERROR_BAD_EXE_FORMAT );
 121             goto failed;
 122         }
 123         *mod_ret = (HMODULE)((char *)module + 1); /* set bit 0 for data file module */
 124
 125         if (flags & LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE)
 126         {
 127             struct exclusive_datafile *datafile = HeapAlloc( GetProcessHeap(), 0, sizeof(*datafile) );
 128             if (!datafile) goto failed;
 129             datafile->module = *mod_ret;
 130             datafile->file   = file;
 131             RtlEnterCriticalSection( &exclusive_datafile_list_section );
 132             list_add_head( &exclusive_datafile_list, &datafile->entry );
 133             RtlLeaveCriticalSection( &exclusive_datafile_list_section );
 134             TRACE( "delaying close %p for module %p\n", datafile->file, datafile->module );
 135             return TRUE;
 136         }
 137     }
 138     else *mod_ret = (HMODULE)((char *)module + 2); /* set bit 1 for image resource module */
 139
 140     CloseHandle( file );
 141     return TRUE;
 142
 143 failed:
 144     if (module) UnmapViewOfFile( module );
 145     CloseHandle( file );
 146     return FALSE;
 147 }
 148
 149
 150 /******************************************************************
 151  *      load_library
 152  */
 153 static HMODULE load_library( const UNICODE_STRING *libname, DWORD flags )
 154 {
 155     const DWORD unsupported_flags = LOAD_IGNORE_CODE_AUTHZ_LEVEL | LOAD_LIBRARY_REQUIRE_SIGNED_TARGET;
 156     NTSTATUS status;
 157     HMODULE module;
 158     WCHAR *load_path, *dummy;
 159
 160     if (flags & unsupported_flags) FIXME( "unsupported flag(s) used %#08lx\n", flags );
 161
 162     if (!set_ntstatus( LdrGetDllPath( libname->Buffer, flags, &load_path, &dummy ))) return 0;
 163
 164     if (flags & (LOAD_LIBRARY_AS_DATAFILE | LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE |
 165                  LOAD_LIBRARY_AS_IMAGE_RESOURCE))
 166     {
 167         if (LdrGetDllHandleEx( 0, load_path, NULL, libname, &module ))
 168             load_library_as_datafile( load_path, flags, libname->Buffer, &module );
 169     }
 170     else
 171     {
 172         status = LdrLoadDll( load_path, flags, libname, &module );
 173         if (!set_ntstatus( status ))
 174         {
 175             module = 0;
 176             if (status == STATUS_DLL_NOT_FOUND && (GetVersion() & 0x80000000))
 177                 SetLastError( ERROR_DLL_NOT_FOUND );
 178         }
 179     }
 180
 181     RtlReleasePath( load_path );
 182     return module;
 183 }
 184
 185
 186 /****************************************************************************
 187  *      AddDllDirectory   (kernelbase.@)
 188  */
 189 DLL_DIRECTORY_COOKIE WINAPI DECLSPEC_HOTPATCH AddDllDirectory( const WCHAR *dir )
 190 {
 191     UNICODE_STRING str;
 192     void *cookie;
 193
 194     RtlInitUnicodeString( &str, dir );
 195     if (!set_ntstatus( LdrAddDllDirectory( &str, &cookie ))) return NULL;
 196     return cookie;
 197 }
 198
 199
 200 /***********************************************************************
 201  *      DelayLoadFailureHook   (kernelbase.@)
 202  */
 203 FARPROC WINAPI DECLSPEC_HOTPATCH DelayLoadFailureHook( LPCSTR name, LPCSTR function )
 204 {
 205     ULONG_PTR args[2];
 206
 207     if ((ULONG_PTR)function >> 16)
 208         ERR( "failed to delay load %s.%s\n", name, function );
 209     else
 210         ERR( "failed to delay load %s.%u\n", name, LOWORD(function) );
 211     args[0] = (ULONG_PTR)name;
 212     args[1] = (ULONG_PTR)function;
 213     RaiseException( EXCEPTION_WINE_STUB, EH_NONCONTINUABLE, 2, args );
 214     return NULL;
 215 }
 216
 217
 218 /****************************************************************************
 219  *      DisableThreadLibraryCalls   (kernelbase.@)
 220  */
 221 BOOL WINAPI DECLSPEC_HOTPATCH DisableThreadLibraryCalls( HMODULE module )
 222 {
 223     return set_ntstatus( LdrDisableThreadCalloutsForDll( module ));
 224 }
 225
 226
 227 /***********************************************************************
 228  *      FreeLibrary   (kernelbase.@)
 229  */
 230 BOOL WINAPI DECLSPEC_HOTPATCH FreeLibrary( HINSTANCE module )
 231 {
 232     if (!module)
 233     {
 234         SetLastError( ERROR_INVALID_HANDLE );
 235         return FALSE;
 236     }
 237
 238     if ((ULONG_PTR)module & 3) /* this is a datafile module */
 239     {
 240         void *ptr = (void *)((ULONG_PTR)module & ~3);
 241         if (!RtlImageNtHeader( ptr ))
 242         {
 243             SetLastError( ERROR_BAD_EXE_FORMAT );
 244             return FALSE;
 245         }
 246         if ((ULONG_PTR)module & 1)
 247         {
 248             struct exclusive_datafile *file;
 249
 250             RtlEnterCriticalSection( &exclusive_datafile_list_section );
 251             LIST_FOR_EACH_ENTRY( file, &exclusive_datafile_list, struct exclusive_datafile, entry )
 252             {
 253                 if (file->module != module) continue;
 254                 TRACE( "closing %p for module %p\n", file->file, file->module );
 255                 CloseHandle( file->file );
 256                 list_remove( &file->entry );
 257                 HeapFree( GetProcessHeap(), 0, file );
 258                 break;
 259             }
 260             RtlLeaveCriticalSection( &exclusive_datafile_list_section );
 261         }
 262         return UnmapViewOfFile( ptr );
 263     }
 264
 265     return set_ntstatus( LdrUnloadDll( module ));
 266 }
 267
 268
 269 /***********************************************************************
 270  *      GetModuleFileNameA   (kernelbase.@)
 271  */
 272 DWORD WINAPI DECLSPEC_HOTPATCH GetModuleFileNameA( HMODULE module, LPSTR filename, DWORD size )
 273 {
 274     LPWSTR filenameW = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) );
 275     DWORD len;
 276
 277     if (!filenameW)
 278     {
 279         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 280         return 0;
 281     }
 282     if ((len = GetModuleFileNameW( module, filenameW, size )))
 283     {
 284         len = file_name_WtoA( filenameW, len, filename, size );
 285         if (len < size)
 286             filename[len] = 0;
 287         else
 288             SetLastError( ERROR_INSUFFICIENT_BUFFER );
 289     }
 290     HeapFree( GetProcessHeap(), 0, filenameW );
 291     return len;
 292 }
 293
 294
 295 /***********************************************************************
 296  *      GetModuleFileNameW   (kernelbase.@)
 297  */
 298 DWORD WINAPI DECLSPEC_HOTPATCH GetModuleFileNameW( HMODULE module, LPWSTR filename, DWORD size )
 299 {
 300     ULONG len = 0;
 301     WIN16_SUBSYSTEM_TIB *win16_tib;
 302     UNICODE_STRING name;
 303     NTSTATUS status;
 304
 305     if (!module && ((win16_tib = NtCurrentTeb()->Tib.SubSystemTib)) && win16_tib->exe_name)
 306     {
 307         len = min( size, win16_tib->exe_name->Length / sizeof(WCHAR) );
 308         memcpy( filename, win16_tib->exe_name->Buffer, len * sizeof(WCHAR) );
 309         if (len < size) filename[len] = 0;
 310         goto done;
 311     }
 312
 313     name.Buffer = filename;
 314     name.MaximumLength = min( size, UNICODE_STRING_MAX_CHARS ) * sizeof(WCHAR);
 315     status = LdrGetDllFullName( module, &name );
 316     if (!status || status == STATUS_BUFFER_TOO_SMALL) len = name.Length / sizeof(WCHAR);
 317     SetLastError( RtlNtStatusToDosError( status ));
 318 done:
 319     TRACE( "%s\n", debugstr_wn(filename, len) );
 320     return len;
 321 }
 322
 323
 324 /***********************************************************************
 325  *      GetModuleHandleA   (kernelbase.@)
 326  */
 327 HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA( LPCSTR module )
 328 {
 329     HMODULE ret;
 330
 331     GetModuleHandleExA( GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, module, &ret );
 332     return ret;
 333 }
 334
 335
 336 /***********************************************************************
 337  *      GetModuleHandleW   (kernelbase.@)
 338  */
 339 HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleW( LPCWSTR module )
 340 {
 341     HMODULE ret;
 342
 343     GetModuleHandleExW( GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, module, &ret );
 344     return ret;
 345 }
 346
 347
 348 /***********************************************************************
 349  *      GetModuleHandleExA   (kernelbase.@)
 350  */
 351 BOOL WINAPI DECLSPEC_HOTPATCH GetModuleHandleExA( DWORD flags, LPCSTR name, HMODULE *module )
 352 {
 353     WCHAR *nameW;
 354
 355     if (!name || (flags & GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS))
 356         return GetModuleHandleExW( flags, (LPCWSTR)name, module );
 357
 358     if (!(nameW = file_name_AtoW( name, FALSE ))) return FALSE;
 359     return GetModuleHandleExW( flags, nameW, module );
 360 }
 361
 362
 363 /***********************************************************************
 364  *      GetModuleHandleExW   (kernelbase.@)
 365  */
 366 BOOL WINAPI DECLSPEC_HOTPATCH GetModuleHandleExW( DWORD flags, LPCWSTR name, HMODULE *module )
 367 {
 368     HMODULE ret = NULL;
 369     NTSTATUS status;
 370     void *dummy;
 371
 372     if (!module)
 373     {
 374         SetLastError( ERROR_INVALID_PARAMETER );
 375         return FALSE;
 376     }
 377
 378     if ((flags & ~(GET_MODULE_HANDLE_EX_FLAG_PIN | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT
 379                   | GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS))
 380                   || (flags & (GET_MODULE_HANDLE_EX_FLAG_PIN | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT))
 381                   == (GET_MODULE_HANDLE_EX_FLAG_PIN | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT))
 382     {
 383         *module = NULL;
 384         SetLastError( ERROR_INVALID_PARAMETER );
 385         return FALSE;
 386     }
 387
 388     if (name && !(flags & GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS))
 389     {
 390         UNICODE_STRING wstr;
 391         ULONG ldr_flags = 0;
 392
 393         if (flags & GET_MODULE_HANDLE_EX_FLAG_PIN)
 394             ldr_flags |= LDR_GET_DLL_HANDLE_EX_FLAG_PIN;
 395         if (flags & GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT)
 396             ldr_flags |= LDR_GET_DLL_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT;
 397
 398         RtlInitUnicodeString( &wstr, name );
 399         status = LdrGetDllHandleEx( ldr_flags, NULL, NULL, &wstr, &ret );
 400     }
 401     else
 402     {
 403         ret = name ? RtlPcToFileHeader( (void *)name, &dummy ) : NtCurrentTeb()->Peb->ImageBaseAddress;
 404
 405         if (ret)
 406         {
 407             if (!(flags & GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT))
 408                 status = LdrAddRefDll( flags & GET_MODULE_HANDLE_EX_FLAG_PIN ? LDR_ADDREF_DLL_PIN : 0, ret );
 409             else
 410                 status = STATUS_SUCCESS;
 411         } else status = STATUS_DLL_NOT_FOUND;
 412     }
 413
 414     *module = ret;
 415     return set_ntstatus( status );
 416 }
 417
 418
 419 /***********************************************************************
 420  *      GetProcAddress   (kernelbase.@)
 421  */
 422
 423 #ifdef __x86_64__
 424 /*
 425  * Work around a Delphi bug on x86_64.  When delay loading a symbol,
 426  * Delphi saves rcx, rdx, r8 and r9 to the stack.  It then calls
 427  * GetProcAddress(), pops the saved registers and calls the function.
 428  * This works fine if all of the parameters are ints.  However, since
 429  * it does not save xmm0 - 3, it relies on GetProcAddress() preserving
 430  * these registers if the function takes floating point parameters.
 431  * This wrapper saves xmm0 - 3 to the stack.
 432  */
 433 __ASM_GLOBAL_FUNC( GetProcAddress,
 434                    ".byte 0x48\n\t"  /* hotpatch prolog */
 435                    "pushq %rbp\n\t"
 436                    __ASM_SEH(".seh_pushreg %rbp\n\t")
 437                    __ASM_CFI(".cfi_adjust_cfa_offset 8\n\t")
 438                    __ASM_CFI(".cfi_rel_offset %rbp,0\n\t")
 439                    "movq %rsp,%rbp\n\t"
 440                    __ASM_SEH(".seh_setframe %rbp,0\n\t")
 441                    __ASM_CFI(".cfi_def_cfa_register %rbp\n\t")
 442                    __ASM_SEH(".seh_endprologue\n\t")
 443                    "subq $0x60,%rsp\n\t"
 444                    "andq $~15,%rsp\n\t"
 445                    "movaps %xmm0,0x20(%rsp)\n\t"
 446                    "movaps %xmm1,0x30(%rsp)\n\t"
 447                    "movaps %xmm2,0x40(%rsp)\n\t"
 448                    "movaps %xmm3,0x50(%rsp)\n\t"
 449                    "call " __ASM_NAME("get_proc_address") "\n\t"
 450                    "movaps 0x50(%rsp), %xmm3\n\t"
 451                    "movaps 0x40(%rsp), %xmm2\n\t"
 452                    "movaps 0x30(%rsp), %xmm1\n\t"
 453                    "movaps 0x20(%rsp), %xmm0\n\t"
 454                    "leaq 0(%rbp),%rsp\n\t"
 455                    __ASM_CFI(".cfi_def_cfa_register %rsp\n\t")
 456                    "popq %rbp\n\t"
 457                    __ASM_CFI(".cfi_adjust_cfa_offset -8\n\t")
 458                    __ASM_CFI(".cfi_same_value %rbp\n\t")
 459                    "ret" )
 460 #else /* __x86_64__ */
 461
 462 FARPROC WINAPI DECLSPEC_HOTPATCH GetProcAddress( HMODULE module, LPCSTR function )
 463 {
 464     return get_proc_address( module, function );
 465 }
 466
 467 #endif /* __x86_64__ */
 468
 469
 470 /***********************************************************************
 471  *      IsApiSetImplemented   (kernelbase.@)
 472  */
 473 BOOL WINAPI IsApiSetImplemented( LPCSTR name )
 474 {
 475     UNICODE_STRING str;
 476     NTSTATUS status;
 477     BOOLEAN in_schema, present;
 478
 479     if (!RtlCreateUnicodeStringFromAsciiz( &str, name )) return FALSE;
 480     status = ApiSetQueryApiSetPresenceEx( &str, &in_schema, &present );
 481     RtlFreeUnicodeString( &str );
 482     return !status && present;
 483 }
 484
 485
 486 /***********************************************************************
 487  *      LoadLibraryA   (kernelbase.@)
 488  */
 489 HMODULE WINAPI DECLSPEC_HOTPATCH LoadLibraryA( LPCSTR name )
 490 {
 491     return LoadLibraryExA( name, 0, 0 );
 492 }
 493
 494
 495 /***********************************************************************
 496  *      LoadLibraryW   (kernelbase.@)
 497  */
 498 HMODULE WINAPI DECLSPEC_HOTPATCH LoadLibraryW( LPCWSTR name )
 499 {
 500     return LoadLibraryExW( name, 0, 0 );
 501 }
 502
 503
 504 /******************************************************************
 505  *      LoadLibraryExA   (kernelbase.@)
 506  */
 507 HMODULE WINAPI DECLSPEC_HOTPATCH LoadLibraryExA( LPCSTR name, HANDLE file, DWORD flags )
 508 {
 509     WCHAR *nameW;
 510
 511     if (!(nameW = file_name_AtoW( name, FALSE ))) return 0;
 512     return LoadLibraryExW( nameW, file, flags );
 513 }
 514
 515
 516 /***********************************************************************
 517  *      LoadLibraryExW   (kernelbase.@)
 518  */
 519 HMODULE WINAPI DECLSPEC_HOTPATCH LoadLibraryExW( LPCWSTR name, HANDLE file, DWORD flags )
 520 {
 521     UNICODE_STRING str;
 522     HMODULE module;
 523
 524     if (!name)
 525     {
 526         SetLastError( ERROR_INVALID_PARAMETER );
 527         return 0;
 528     }
 529     RtlInitUnicodeString( &str, name );
 530     if (str.Buffer[str.Length/sizeof(WCHAR) - 1] != ' ') return load_library( &str, flags );
 531
 532     /* library name has trailing spaces */
 533     RtlCreateUnicodeString( &str, name );
 534     while (str.Length > sizeof(WCHAR) && str.Buffer[str.Length/sizeof(WCHAR) - 1] == ' ')
 535         str.Length -= sizeof(WCHAR);
 536
 537     str.Buffer[str.Length/sizeof(WCHAR)] = 0;
 538     module = load_library( &str, flags );
 539     RtlFreeUnicodeString( &str );
 540     return module;
 541 }
 542
 543
 544 /***********************************************************************
 545  *      LoadPackagedLibrary    (kernelbase.@)
 546  */
 547 HMODULE WINAPI /* DECLSPEC_HOTPATCH */ LoadPackagedLibrary( LPCWSTR name, DWORD reserved )
 548 {
 549     FIXME( "semi-stub, name %s, reserved %#lx.\n", debugstr_w(name), reserved );
 550     SetLastError( APPMODEL_ERROR_NO_PACKAGE );
 551     return NULL;
 552 }
 553
 554
 555 /***********************************************************************
 556  *      LoadAppInitDlls    (kernelbase.@)
 557  */
 558 void WINAPI LoadAppInitDlls(void)
 559 {
 560     TRACE( "\n" );
 561 }
 562
 563
 564 /****************************************************************************
 565  *      RemoveDllDirectory   (kernelbase.@)
 566  */
 567 BOOL WINAPI DECLSPEC_HOTPATCH RemoveDllDirectory( DLL_DIRECTORY_COOKIE cookie )
 568 {
 569     return set_ntstatus( LdrRemoveDllDirectory( cookie ));
 570 }
 571
 572
 573 /*************************************************************************
 574  *      SetDefaultDllDirectories   (kernelbase.@)
 575  */
 576 BOOL WINAPI DECLSPEC_HOTPATCH SetDefaultDllDirectories( DWORD flags )
 577 {
 578     return set_ntstatus( LdrSetDefaultDllDirectories( flags ));
 579 }
 580
 581
 582 /***********************************************************************
 583  * Resources
 584  ***********************************************************************/
 585
 586
 587 #define IS_INTRESOURCE(x)   (((ULONG_PTR)(x) >> 16) == 0)
 588
 589 /* retrieve the resource name to pass to the ntdll functions */
 590 static NTSTATUS get_res_nameA( LPCSTR name, UNICODE_STRING *str )
 591 {
 592     if (IS_INTRESOURCE(name))
 593     {
 594         str->Buffer = ULongToPtr( LOWORD(name) );
 595         return STATUS_SUCCESS;
 596     }
 597     if (name[0] == '#')
 598     {
 599         ULONG value;
 600         if (RtlCharToInteger( name + 1, 10, &value ) != STATUS_SUCCESS || HIWORD(value))
 601             return STATUS_INVALID_PARAMETER;
 602         str->Buffer = ULongToPtr(value);
 603         return STATUS_SUCCESS;
 604     }
 605     RtlCreateUnicodeStringFromAsciiz( str, name );
 606     RtlUpcaseUnicodeString( str, str, FALSE );
 607     return STATUS_SUCCESS;
 608 }
 609
 610 /* retrieve the resource name to pass to the ntdll functions */
 611 static NTSTATUS get_res_nameW( LPCWSTR name, UNICODE_STRING *str )
 612 {
 613     if (IS_INTRESOURCE(name))
 614     {
 615         str->Buffer = ULongToPtr( LOWORD(name) );
 616         return STATUS_SUCCESS;
 617     }
 618     if (name[0] == '#')
 619     {
 620         ULONG value;
 621         RtlInitUnicodeString( str, name + 1 );
 622         if (RtlUnicodeStringToInteger( str, 10, &value ) != STATUS_SUCCESS || HIWORD(value))
 623             return STATUS_INVALID_PARAMETER;
 624         str->Buffer = ULongToPtr(value);
 625         return STATUS_SUCCESS;
 626     }
 627     RtlCreateUnicodeString( str, name );
 628     RtlUpcaseUnicodeString( str, str, FALSE );
 629     return STATUS_SUCCESS;
 630 }
 631
 632
 633 /**********************************************************************
 634  *      EnumResourceLanguagesExA        (kernelbase.@)
 635  */
 636 BOOL WINAPI DECLSPEC_HOTPATCH EnumResourceLanguagesExA( HMODULE module, LPCSTR type, LPCSTR name,
 637                                                         ENUMRESLANGPROCA func, LONG_PTR param,
 638                                                         DWORD flags, LANGID lang )
 639 {
 640     int i;
 641     BOOL ret = FALSE;
 642     NTSTATUS status;
 643     UNICODE_STRING typeW, nameW;
 644     LDR_RESOURCE_INFO info;
 645     const IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
 646     const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 647
 648     TRACE( "%p %s %s %p %Ix %lx %d\n", module, debugstr_a(type), debugstr_a(name),
 649            func, param, flags, lang );
 650
 651     if (flags & (RESOURCE_ENUM_MUI | RESOURCE_ENUM_MUI_SYSTEM | RESOURCE_ENUM_VALIDATE))
 652         FIXME( "unimplemented flags: %lx\n", flags );
 653
 654     if (!flags) flags = RESOURCE_ENUM_LN | RESOURCE_ENUM_MUI;
 655     if (!(flags & RESOURCE_ENUM_LN)) return ret;
 656
 657     if (!module) module = GetModuleHandleW( 0 );
 658     typeW.Buffer = nameW.Buffer = NULL;
 659     if ((status = LdrFindResourceDirectory_U( module, NULL, 0, &basedir )) != STATUS_SUCCESS)
 660         goto done;
 661     if ((status = get_res_nameA( type, &typeW )) != STATUS_SUCCESS)
 662         goto done;
 663     if ((status = get_res_nameA( name, &nameW )) != STATUS_SUCCESS)
 664         goto done;
 665     info.Type = (ULONG_PTR)typeW.Buffer;
 666     info.Name = (ULONG_PTR)nameW.Buffer;
 667     if ((status = LdrFindResourceDirectory_U( module, &info, 2, &resdir )) != STATUS_SUCCESS)
 668         goto done;
 669
 670     et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
 671     __TRY
 672     {
 673         for (i = 0; i < resdir->NumberOfNamedEntries + resdir->NumberOfIdEntries; i++)
 674         {
 675             ret = func( module, type, name, et[i].u.Id, param );
 676             if (!ret) break;
 677         }
 678     }
 679     __EXCEPT_PAGE_FAULT
 680     {
 681         ret = FALSE;
 682         status = STATUS_ACCESS_VIOLATION;
 683     }
 684     __ENDTRY
 685 done:
 686     if (!IS_INTRESOURCE(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
 687     if (!IS_INTRESOURCE(nameW.Buffer)) HeapFree( GetProcessHeap(), 0, nameW.Buffer );
 688     if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
 689     return ret;
 690 }
 691
 692
 693 /**********************************************************************
 694  *      EnumResourceLanguagesExW        (kernelbase.@)
 695  */
 696 BOOL WINAPI DECLSPEC_HOTPATCH EnumResourceLanguagesExW( HMODULE module, LPCWSTR type, LPCWSTR name,
 697                                                         ENUMRESLANGPROCW func, LONG_PTR param,
 698                                                         DWORD flags, LANGID lang )
 699 {
 700     int i;
 701     BOOL ret = FALSE;
 702     NTSTATUS status;
 703     UNICODE_STRING typeW, nameW;
 704     LDR_RESOURCE_INFO info;
 705     const IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
 706     const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 707
 708     TRACE( "%p %s %s %p %Ix %lx %d\n", module, debugstr_w(type), debugstr_w(name),
 709            func, param, flags, lang );
 710
 711     if (flags & (RESOURCE_ENUM_MUI | RESOURCE_ENUM_MUI_SYSTEM | RESOURCE_ENUM_VALIDATE))
 712         FIXME( "unimplemented flags: %lx\n", flags );
 713
 714     if (!flags) flags = RESOURCE_ENUM_LN | RESOURCE_ENUM_MUI;
 715     if (!(flags & RESOURCE_ENUM_LN)) return ret;
 716
 717     if (!module) module = GetModuleHandleW( 0 );
 718     typeW.Buffer = nameW.Buffer = NULL;
 719     if ((status = LdrFindResourceDirectory_U( module, NULL, 0, &basedir )) != STATUS_SUCCESS)
 720         goto done;
 721     if ((status = get_res_nameW( type, &typeW )) != STATUS_SUCCESS)
 722         goto done;
 723     if ((status = get_res_nameW( name, &nameW )) != STATUS_SUCCESS)
 724         goto done;
 725     info.Type = (ULONG_PTR)typeW.Buffer;
 726     info.Name = (ULONG_PTR)nameW.Buffer;
 727     if ((status = LdrFindResourceDirectory_U( module, &info, 2, &resdir )) != STATUS_SUCCESS)
 728         goto done;
 729
 730     et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
 731     __TRY
 732     {
 733         for (i = 0; i < resdir->NumberOfNamedEntries + resdir->NumberOfIdEntries; i++)
 734         {
 735             ret = func( module, type, name, et[i].u.Id, param );
 736             if (!ret) break;
 737         }
 738     }
 739     __EXCEPT_PAGE_FAULT
 740     {
 741         ret = FALSE;
 742         status = STATUS_ACCESS_VIOLATION;
 743     }
 744     __ENDTRY
 745 done:
 746     if (!IS_INTRESOURCE(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
 747     if (!IS_INTRESOURCE(nameW.Buffer)) HeapFree( GetProcessHeap(), 0, nameW.Buffer );
 748     if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
 749     return ret;
 750 }
 751
 752
 753 /**********************************************************************
 754  *      EnumResourceNamesExA    (kernelbase.@)
 755  */
 756 BOOL WINAPI DECLSPEC_HOTPATCH EnumResourceNamesExA( HMODULE module, LPCSTR type, ENUMRESNAMEPROCA func,
 757                                                     LONG_PTR param, DWORD flags, LANGID lang )
 758 {
 759     int i;
 760     BOOL ret = FALSE;
 761     DWORD len = 0, newlen;
 762     LPSTR name = NULL;
 763     NTSTATUS status;
 764     UNICODE_STRING typeW;
 765     LDR_RESOURCE_INFO info;
 766     const IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
 767     const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 768     const IMAGE_RESOURCE_DIR_STRING_U *str;
 769
 770     TRACE( "%p %s %p %Ix\n", module, debugstr_a(type), func, param );
 771
 772     if (flags & (RESOURCE_ENUM_MUI | RESOURCE_ENUM_MUI_SYSTEM | RESOURCE_ENUM_VALIDATE))
 773         FIXME( "unimplemented flags: %lx\n", flags );
 774
 775     if (!flags) flags = RESOURCE_ENUM_LN | RESOURCE_ENUM_MUI;
 776     if (!(flags & RESOURCE_ENUM_LN)) return ret;
 777
 778     if (!module) module = GetModuleHandleW( 0 );
 779     typeW.Buffer = NULL;
 780     if ((status = LdrFindResourceDirectory_U( module, NULL, 0, &basedir )) != STATUS_SUCCESS)
 781         goto done;
 782     if ((status = get_res_nameA( type, &typeW )) != STATUS_SUCCESS)
 783         goto done;
 784     info.Type = (ULONG_PTR)typeW.Buffer;
 785     if ((status = LdrFindResourceDirectory_U( module, &info, 1, &resdir )) != STATUS_SUCCESS)
 786         goto done;
 787
 788     et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
 789     __TRY
 790     {
 791         for (i = 0; i < resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries; i++)
 792         {
 793             if (et[i].u.s.NameIsString)
 794             {
 795                 str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)basedir + et[i].u.s.NameOffset);
 796                 newlen = WideCharToMultiByte(CP_ACP, 0, str->NameString, str->Length, NULL, 0, NULL, NULL);
 797                 if (newlen + 1 > len)
 798                 {
 799                     len = newlen + 1;
 800                     HeapFree( GetProcessHeap(), 0, name );
 801                     if (!(name = HeapAlloc( GetProcessHeap(), 0, len + 1 )))
 802                     {
 803                         ret = FALSE;
 804                         break;
 805                     }
 806                 }
 807                 WideCharToMultiByte( CP_ACP, 0, str->NameString, str->Length, name, len, NULL, NULL );
 808                 name[newlen] = 0;
 809                 ret = func( module, type, name, param );
 810             }
 811             else
 812             {
 813                 ret = func( module, type, UIntToPtr(et[i].u.Id), param );
 814             }
 815             if (!ret) break;
 816         }
 817     }
 818     __EXCEPT_PAGE_FAULT
 819     {
 820         ret = FALSE;
 821         status = STATUS_ACCESS_VIOLATION;
 822     }
 823     __ENDTRY
 824
 825 done:
 826     HeapFree( GetProcessHeap(), 0, name );
 827     if (!IS_INTRESOURCE(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
 828     if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
 829     return ret;
 830 }
 831
 832
 833 /**********************************************************************
 834  *      EnumResourceNamesExW    (kernelbase.@)
 835  */
 836 BOOL WINAPI DECLSPEC_HOTPATCH EnumResourceNamesExW( HMODULE module, LPCWSTR type, ENUMRESNAMEPROCW func,
 837                                                     LONG_PTR param, DWORD flags, LANGID lang )
 838 {
 839     int i, len = 0;
 840     BOOL ret = FALSE;
 841     LPWSTR name = NULL;
 842     NTSTATUS status;
 843     UNICODE_STRING typeW;
 844     LDR_RESOURCE_INFO info;
 845     const IMAGE_RESOURCE_DIRECTORY *basedir, *resdir;
 846     const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 847     const IMAGE_RESOURCE_DIR_STRING_U *str;
 848
 849     TRACE( "%p %s %p %Ix\n", module, debugstr_w(type), func, param );
 850
 851     if (flags & (RESOURCE_ENUM_MUI | RESOURCE_ENUM_MUI_SYSTEM | RESOURCE_ENUM_VALIDATE))
 852         FIXME( "unimplemented flags: %lx\n", flags );
 853
 854     if (!flags) flags = RESOURCE_ENUM_LN | RESOURCE_ENUM_MUI;
 855     if (!(flags & RESOURCE_ENUM_LN)) return ret;
 856
 857     if (!module) module = GetModuleHandleW( 0 );
 858     typeW.Buffer = NULL;
 859     if ((status = LdrFindResourceDirectory_U( module, NULL, 0, &basedir )) != STATUS_SUCCESS)
 860         goto done;
 861     if ((status = get_res_nameW( type, &typeW )) != STATUS_SUCCESS)
 862         goto done;
 863     info.Type = (ULONG_PTR)typeW.Buffer;
 864     if ((status = LdrFindResourceDirectory_U( module, &info, 1, &resdir )) != STATUS_SUCCESS)
 865         goto done;
 866
 867     et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
 868     __TRY
 869     {
 870         for (i = 0; i < resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries; i++)
 871         {
 872             if (et[i].u.s.NameIsString)
 873             {
 874                 str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)basedir + et[i].u.s.NameOffset);
 875                 if (str->Length + 1 > len)
 876                 {
 877                     len = str->Length + 1;
 878                     HeapFree( GetProcessHeap(), 0, name );
 879                     if (!(name = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
 880                     {
 881                         ret = FALSE;
 882                         break;
 883                     }
 884                 }
 885                 memcpy(name, str->NameString, str->Length * sizeof (WCHAR));
 886                 name[str->Length] = 0;
 887                 ret = func( module, type, name, param );
 888             }
 889             else
 890             {
 891                 ret = func( module, type, UIntToPtr(et[i].u.Id), param );
 892             }
 893             if (!ret) break;
 894         }
 895     }
 896     __EXCEPT_PAGE_FAULT
 897     {
 898         ret = FALSE;
 899         status = STATUS_ACCESS_VIOLATION;
 900     }
 901     __ENDTRY
 902 done:
 903     HeapFree( GetProcessHeap(), 0, name );
 904     if (!IS_INTRESOURCE(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
 905     if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
 906     return ret;
 907 }
 908
 909
 910 /**********************************************************************
 911  *      EnumResourceNamesW      (kernelbase.@)
 912  */
 913 BOOL WINAPI DECLSPEC_HOTPATCH EnumResourceNamesW( HMODULE module, LPCWSTR type,
 914                                                   ENUMRESNAMEPROCW func, LONG_PTR param )
 915 {
 916     return EnumResourceNamesExW( module, type, func, param, 0, 0 );
 917 }
 918
 919
 920 /**********************************************************************
 921  *      EnumResourceTypesExA    (kernelbase.@)
 922  */
 923 BOOL WINAPI DECLSPEC_HOTPATCH EnumResourceTypesExA( HMODULE module, ENUMRESTYPEPROCA func, LONG_PTR param,
 924                                                     DWORD flags, LANGID lang )
 925 {
 926     int i;
 927     BOOL ret = FALSE;
 928     LPSTR type = NULL;
 929     DWORD len = 0, newlen;
 930     const IMAGE_RESOURCE_DIRECTORY *resdir;
 931     const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 932     const IMAGE_RESOURCE_DIR_STRING_U *str;
 933
 934     TRACE( "%p %p %Ix\n", module, func, param );
 935
 936     if (flags & (RESOURCE_ENUM_MUI | RESOURCE_ENUM_MUI_SYSTEM | RESOURCE_ENUM_VALIDATE))
 937         FIXME( "unimplemented flags: %lx\n", flags );
 938
 939     if (!flags) flags = RESOURCE_ENUM_LN | RESOURCE_ENUM_MUI;
 940     if (!(flags & RESOURCE_ENUM_LN)) return ret;
 941
 942     if (!module) module = GetModuleHandleW( 0 );
 943
 944     if (!set_ntstatus( LdrFindResourceDirectory_U( module, NULL, 0, &resdir ))) return FALSE;
 945
 946     et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
 947     for (i = 0; i < resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries; i++)
 948     {
 949         if (et[i].u.s.NameIsString)
 950         {
 951             str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)resdir + et[i].u.s.NameOffset);
 952             newlen = WideCharToMultiByte( CP_ACP, 0, str->NameString, str->Length, NULL, 0, NULL, NULL);
 953             if (newlen + 1 > len)
 954             {
 955                 len = newlen + 1;
 956                 HeapFree( GetProcessHeap(), 0, type );
 957                 if (!(type = HeapAlloc( GetProcessHeap(), 0, len ))) return FALSE;
 958             }
 959             WideCharToMultiByte( CP_ACP, 0, str->NameString, str->Length, type, len, NULL, NULL);
 960             type[newlen] = 0;
 961             ret = func( module, type, param );
 962         }
 963         else
 964         {
 965             ret = func( module, UIntToPtr(et[i].u.Id), param );
 966         }
 967         if (!ret) break;
 968     }
 969     HeapFree( GetProcessHeap(), 0, type );
 970     return ret;
 971 }
 972
 973
 974 /**********************************************************************
 975  *      EnumResourceTypesExW    (kernelbase.@)
 976  */
 977 BOOL WINAPI DECLSPEC_HOTPATCH EnumResourceTypesExW( HMODULE module, ENUMRESTYPEPROCW func, LONG_PTR param,
 978                                                     DWORD flags, LANGID lang )
 979 {
 980     int i, len = 0;
 981     BOOL ret = FALSE;
 982     LPWSTR type = NULL;
 983     const IMAGE_RESOURCE_DIRECTORY *resdir;
 984     const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
 985     const IMAGE_RESOURCE_DIR_STRING_U *str;
 986
 987     TRACE( "%p %p %Ix\n", module, func, param );
 988
 989     if (!flags) flags = RESOURCE_ENUM_LN | RESOURCE_ENUM_MUI;
 990     if (!(flags & RESOURCE_ENUM_LN)) return ret;
 991
 992     if (!module) module = GetModuleHandleW( 0 );
 993
 994     if (!set_ntstatus( LdrFindResourceDirectory_U( module, NULL, 0, &resdir ))) return FALSE;
 995
 996     et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
 997     for (i = 0; i < resdir->NumberOfNamedEntries + resdir->NumberOfIdEntries; i++)
 998     {
 999         if (et[i].u.s.NameIsString)
1000         {
1001             str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const BYTE *)resdir + et[i].u.s.NameOffset);
1002             if (str->Length + 1 > len)
1003             {
1004                 len = str->Length + 1;
1005                 HeapFree( GetProcessHeap(), 0, type );
1006                 if (!(type = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return FALSE;
1007             }
1008             memcpy(type, str->NameString, str->Length * sizeof (WCHAR));
1009             type[str->Length] = 0;
1010             ret = func( module, type, param );
1011         }
1012         else
1013         {
1014             ret = func( module, UIntToPtr(et[i].u.Id), param );
1015         }
1016         if (!ret) break;
1017     }
1018     HeapFree( GetProcessHeap(), 0, type );
1019     return ret;
1020 }
1021
1022
1023 /**********************************************************************
1024  *          FindResourceExW  (kernelbase.@)
1025  */
1026 HRSRC WINAPI DECLSPEC_HOTPATCH FindResourceExW( HMODULE module, LPCWSTR type, LPCWSTR name, WORD lang )
1027 {
1028     NTSTATUS status;
1029     UNICODE_STRING nameW, typeW;
1030     LDR_RESOURCE_INFO info;
1031     const IMAGE_RESOURCE_DATA_ENTRY *entry = NULL;
1032
1033     TRACE( "%p %s %s %04x\n", module, debugstr_w(type), debugstr_w(name), lang );
1034
1035     if (!module) module = GetModuleHandleW( 0 );
1036     nameW.Buffer = typeW.Buffer = NULL;
1037
1038     __TRY
1039     {
1040         if ((status = get_res_nameW( name, &nameW )) != STATUS_SUCCESS) goto done;
1041         if ((status = get_res_nameW( type, &typeW )) != STATUS_SUCCESS) goto done;
1042         info.Type = (ULONG_PTR)typeW.Buffer;
1043         info.Name = (ULONG_PTR)nameW.Buffer;
1044         info.Language = lang;
1045         status = LdrFindResource_U( module, &info, 3, &entry );
1046     done:
1047         if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
1048     }
1049     __EXCEPT_PAGE_FAULT
1050     {
1051         SetLastError( ERROR_INVALID_PARAMETER );
1052     }
1053     __ENDTRY
1054
1055     if (!IS_INTRESOURCE(nameW.Buffer)) HeapFree( GetProcessHeap(), 0, nameW.Buffer );
1056     if (!IS_INTRESOURCE(typeW.Buffer)) HeapFree( GetProcessHeap(), 0, typeW.Buffer );
1057     return (HRSRC)entry;
1058 }
1059
1060
1061 /**********************************************************************
1062  *          FindResourceW    (kernelbase.@)
1063  */
1064 HRSRC WINAPI DECLSPEC_HOTPATCH FindResourceW( HINSTANCE module, LPCWSTR name, LPCWSTR type )
1065 {
1066     return FindResourceExW( module, type, name, MAKELANGID( LANG_NEUTRAL, SUBLANG_NEUTRAL ) );
1067 }
1068
1069
1070 /**********************************************************************
1071  *          FreeResource     (kernelbase.@)
1072  */
1073 BOOL WINAPI DECLSPEC_HOTPATCH FreeResource( HGLOBAL handle )
1074 {
1075     return FALSE;
1076 }
1077
1078
1079 /**********************************************************************
1080  *          LoadResource     (kernelbase.@)
1081  */
1082 HGLOBAL WINAPI DECLSPEC_HOTPATCH LoadResource( HINSTANCE module, HRSRC rsrc )
1083 {
1084     void *ret;
1085
1086     TRACE( "%p %p\n", module, rsrc );
1087
1088     if (!rsrc) return 0;
1089     if (!module) module = GetModuleHandleW( 0 );
1090     if (!set_ntstatus( LdrAccessResource( module, (IMAGE_RESOURCE_DATA_ENTRY *)rsrc, &ret, NULL )))
1091         return 0;
1092     return ret;
1093 }
1094
1095
1096 /**********************************************************************
1097  *          LockResource     (kernelbase.@)
1098  */
1099 LPVOID WINAPI DECLSPEC_HOTPATCH LockResource( HGLOBAL handle )
1100 {
1101     return handle;
1102 }
1103
1104
1105 /**********************************************************************
1106  *          SizeofResource   (kernelbase.@)
1107  */
1108 DWORD WINAPI DECLSPEC_HOTPATCH SizeofResource( HINSTANCE module, HRSRC rsrc )
1109 {
1110     if (!rsrc) return 0;
1111     return ((IMAGE_RESOURCE_DATA_ENTRY *)rsrc)->Size;
1112 }
1113
1114
1115 /***********************************************************************
1116  * Activation contexts
1117  ***********************************************************************/
1118
1119
1120 /***********************************************************************
1121  *          ActivateActCtx    (kernelbase.@)
1122  */
1123 BOOL WINAPI DECLSPEC_HOTPATCH ActivateActCtx( HANDLE context, ULONG_PTR *cookie )
1124 {
1125     return set_ntstatus( RtlActivateActivationContext( 0, context, cookie ));
1126 }
1127
1128
1129 /***********************************************************************
1130  *          AddRefActCtx    (kernelbase.@)
1131  */
1132 void WINAPI DECLSPEC_HOTPATCH AddRefActCtx( HANDLE context )
1133 {
1134     RtlAddRefActivationContext( context );
1135 }
1136
1137
1138 /***********************************************************************
1139  *          CreateActCtxW    (kernelbase.@)
1140  */
1141 HANDLE WINAPI DECLSPEC_HOTPATCH CreateActCtxW( PCACTCTXW ctx )
1142 {
1143     HANDLE context;
1144
1145     TRACE( "%p %08lx\n", ctx, ctx ? ctx->dwFlags : 0 );
1146
1147     if (!set_ntstatus( RtlCreateActivationContext( &context, ctx ))) return INVALID_HANDLE_VALUE;
1148     return context;
1149 }
1150
1151
1152 /***********************************************************************
1153  *          DeactivateActCtx    (kernelbase.@)
1154  */
1155 BOOL WINAPI DECLSPEC_HOTPATCH DeactivateActCtx( DWORD flags, ULONG_PTR cookie )
1156 {
1157     RtlDeactivateActivationContext( flags, cookie );
1158     return TRUE;
1159 }
1160
1161
1162 /***********************************************************************
1163  *          FindActCtxSectionGuid    (kernelbase.@)
1164  */
1165 BOOL WINAPI DECLSPEC_HOTPATCH FindActCtxSectionGuid( DWORD flags, const GUID *ext_guid, ULONG id,
1166                                                      const GUID *guid, PACTCTX_SECTION_KEYED_DATA info )
1167 {
1168     return set_ntstatus( RtlFindActivationContextSectionGuid( flags, ext_guid, id, guid, info ));
1169 }
1170
1171
1172 /***********************************************************************
1173  *          FindActCtxSectionStringW    (kernelbase.@)
1174  */
1175 BOOL WINAPI DECLSPEC_HOTPATCH FindActCtxSectionStringW( DWORD flags, const GUID *ext_guid, ULONG id,
1176                                                         LPCWSTR str, PACTCTX_SECTION_KEYED_DATA info )
1177 {
1178     UNICODE_STRING us;
1179
1180     if (!info)
1181     {
1182         SetLastError( ERROR_INVALID_PARAMETER );
1183         return FALSE;
1184     }
1185     RtlInitUnicodeString( &us, str );
1186     return set_ntstatus( RtlFindActivationContextSectionString( flags, ext_guid, id, &us, info ));
1187 }
1188
1189
1190 /***********************************************************************
1191  *          GetCurrentActCtx    (kernelbase.@)
1192  */
1193 BOOL WINAPI DECLSPEC_HOTPATCH GetCurrentActCtx( HANDLE *pcontext )
1194 {
1195     return set_ntstatus( RtlGetActiveActivationContext( pcontext ));
1196 }
1197
1198
1199 /***********************************************************************
1200  *          QueryActCtxSettingsW    (kernelbase.@)
1201  */
1202 BOOL WINAPI DECLSPEC_HOTPATCH QueryActCtxSettingsW( DWORD flags, HANDLE ctx, const WCHAR *ns,
1203                                                     const WCHAR *settings, WCHAR *buffer, SIZE_T size,
1204                                                     SIZE_T *written )
1205 {
1206     return set_ntstatus( RtlQueryActivationContextApplicationSettings( flags, ctx, ns, settings,
1207                                                                        buffer, size, written ));
1208 }
1209
1210
1211 /***********************************************************************
1212  *          QueryActCtxW    (kernelbase.@)
1213  */
1214 BOOL WINAPI DECLSPEC_HOTPATCH QueryActCtxW( DWORD flags, HANDLE context, PVOID inst, ULONG class,
1215                                             PVOID buffer, SIZE_T size, SIZE_T *written )
1216 {
1217     return set_ntstatus( RtlQueryInformationActivationContext( flags, context, inst, class,
1218                                                                buffer, size, written ));
1219 }
1220
1221
1222 /***********************************************************************
1223  *          ReleaseActCtx    (kernelbase.@)
1224  */
1225 void WINAPI DECLSPEC_HOTPATCH ReleaseActCtx( HANDLE context )
1226 {
1227     RtlReleaseActivationContext( context );
1228 }
1229
1230
1231 /***********************************************************************
1232  *          ZombifyActCtx    (kernelbase.@)
1233  */
1234 BOOL WINAPI DECLSPEC_HOTPATCH ZombifyActCtx( HANDLE context )
1235 {
1236     return set_ntstatus( RtlZombifyActivationContext( context ));
1237 }