VirtualBox

source: vbox/trunk/include/iprt/ldr.h@ 70092

Last change on this file since 70092 was 69105, checked in by vboxsync, 7 years ago

include/iprt/: (C) year

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 42.8 KB
Line 
1/** @file
2 * IPRT - Loader.
3 */
4
5/*
6 * Copyright (C) 2006-2017 Oracle Corporation
7 *
8 * This file is part of VirtualBox Open Source Edition (OSE), as
9 * available from http://www.virtualbox.org. This file is free software;
10 * you can redistribute it and/or modify it under the terms of the GNU
11 * General Public License (GPL) as published by the Free Software
12 * Foundation, in version 2 as it comes in the "COPYING" file of the
13 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15 *
16 * The contents of this file may alternatively be used under the terms
17 * of the Common Development and Distribution License Version 1.0
18 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19 * VirtualBox OSE distribution, in which case the provisions of the
20 * CDDL are applicable instead of those of the GPL.
21 *
22 * You may elect to license modified versions of this file under the
23 * terms and conditions of either the GPL or the CDDL or both.
24 */
25
26#ifndef ___iprt_ldr_h
27#define ___iprt_ldr_h
28
29#include <iprt/cdefs.h>
30#include <iprt/types.h>
31
32
33/** @defgroup grp_ldr RTLdr - Loader
34 * @ingroup grp_rt
35 * @{
36 */
37
38
39RT_C_DECLS_BEGIN
40
41/** Loader address (unsigned integer). */
42typedef RTUINTPTR RTLDRADDR;
43/** Pointer to a loader address. */
44typedef RTLDRADDR *PRTLDRADDR;
45/** Pointer to a const loader address. */
46typedef RTLDRADDR const *PCRTLDRADDR;
47/** The max loader address value. */
48#define RTLDRADDR_MAX RTUINTPTR_MAX
49/** NIL loader address value. */
50#define NIL_RTLDRADDR RTLDRADDR_MAX
51
52
53/**
54 * Loader module format.
55 */
56typedef enum RTLDRFMT
57{
58 /** The usual invalid 0 format. */
59 RTLDRFMT_INVALID = 0,
60 /** The native OS loader. */
61 RTLDRFMT_NATIVE,
62 /** The AOUT loader. */
63 RTLDRFMT_AOUT,
64 /** The ELF loader. */
65 RTLDRFMT_ELF,
66 /** The LX loader. */
67 RTLDRFMT_LX,
68 /** The Mach-O loader. */
69 RTLDRFMT_MACHO,
70 /** The PE loader. */
71 RTLDRFMT_PE,
72 /** The end of the valid format values (exclusive). */
73 RTLDRFMT_END,
74 /** Hack to blow the type up to 32-bit. */
75 RTLDRFMT_32BIT_HACK = 0x7fffffff
76} RTLDRFMT;
77
78
79/**
80 * Loader module type.
81 */
82typedef enum RTLDRTYPE
83{
84 /** The usual invalid 0 type. */
85 RTLDRTYPE_INVALID = 0,
86 /** Object file. */
87 RTLDRTYPE_OBJECT,
88 /** Executable module, fixed load address. */
89 RTLDRTYPE_EXECUTABLE_FIXED,
90 /** Executable module, relocatable, non-fixed load address. */
91 RTLDRTYPE_EXECUTABLE_RELOCATABLE,
92 /** Executable module, position independent code, non-fixed load address. */
93 RTLDRTYPE_EXECUTABLE_PIC,
94 /** Shared library, fixed load address.
95 * Typically a system library. */
96 RTLDRTYPE_SHARED_LIBRARY_FIXED,
97 /** Shared library, relocatable, non-fixed load address. */
98 RTLDRTYPE_SHARED_LIBRARY_RELOCATABLE,
99 /** Shared library, position independent code, non-fixed load address. */
100 RTLDRTYPE_SHARED_LIBRARY_PIC,
101 /** DLL that contains no code or data only imports and exports. (Chiefly OS/2.) */
102 RTLDRTYPE_FORWARDER_DLL,
103 /** Core or dump. */
104 RTLDRTYPE_CORE,
105 /** Debug module (debug info with empty code & data segments). */
106 RTLDRTYPE_DEBUG_INFO,
107 /** The end of the valid types values (exclusive). */
108 RTLDRTYPE_END,
109 /** Hack to blow the type up to 32-bit. */
110 RTLDRTYPE_32BIT_HACK = 0x7fffffff
111} RTLDRTYPE;
112
113
114/**
115 * Loader endian indicator.
116 */
117typedef enum RTLDRENDIAN
118{
119 /** The usual invalid endian. */
120 RTLDRENDIAN_INVALID,
121 /** Little endian. */
122 RTLDRENDIAN_LITTLE,
123 /** Bit endian. */
124 RTLDRENDIAN_BIG,
125 /** Endianness doesn't have a meaning in the context. */
126 RTLDRENDIAN_NA,
127 /** The end of the valid endian values (exclusive). */
128 RTLDRENDIAN_END,
129 /** Hack to blow the type up to 32-bit. */
130 RTLDRENDIAN_32BIT_HACK = 0x7fffffff
131} RTLDRENDIAN;
132
133
134/** Pointer to a loader reader instance. */
135typedef struct RTLDRREADER *PRTLDRREADER;
136/**
137 * Loader image reader instance.
138 *
139 * @remarks The reader will typically have a larger structure wrapping this one
140 * for storing necessary instance variables.
141 *
142 * The loader ASSUMES the caller serializes all access to the
143 * individual loader module handlers, thus no serialization is required
144 * when implementing this interface.
145 */
146typedef struct RTLDRREADER
147{
148 /** Magic value (RTLDRREADER_MAGIC). */
149 uintptr_t uMagic;
150
151 /**
152 * Reads bytes at a give place in the raw image.
153 *
154 * @returns iprt status code.
155 * @param pReader Pointer to the reader instance.
156 * @param pvBuf Where to store the bits.
157 * @param cb Number of bytes to read.
158 * @param off Where to start reading relative to the start of the raw image.
159 */
160 DECLCALLBACKMEMBER(int, pfnRead)(PRTLDRREADER pReader, void *pvBuf, size_t cb, RTFOFF off);
161
162 /**
163 * Tells end position of last read.
164 *
165 * @returns position relative to start of the raw image.
166 * @param pReader Pointer to the reader instance.
167 */
168 DECLCALLBACKMEMBER(RTFOFF, pfnTell)(PRTLDRREADER pReader);
169
170 /**
171 * Gets the size of the raw image bits.
172 *
173 * @returns size of raw image bits in bytes.
174 * @param pReader Pointer to the reader instance.
175 */
176 DECLCALLBACKMEMBER(RTFOFF, pfnSize)(PRTLDRREADER pReader);
177
178 /**
179 * Map the bits into memory.
180 *
181 * The mapping will be freed upon calling pfnDestroy() if not pfnUnmap()
182 * is called before that. The mapping is read only.
183 *
184 * @returns iprt status code.
185 * @param pReader Pointer to the reader instance.
186 * @param ppvBits Where to store the address of the memory mapping on success.
187 * The size of the mapping can be obtained by calling pfnSize().
188 */
189 DECLCALLBACKMEMBER(int, pfnMap)(PRTLDRREADER pReader, const void **ppvBits);
190
191 /**
192 * Unmap bits.
193 *
194 * @returns iprt status code.
195 * @param pReader Pointer to the reader instance.
196 * @param pvBits Memory pointer returned by pfnMap().
197 */
198 DECLCALLBACKMEMBER(int, pfnUnmap)(PRTLDRREADER pReader, const void *pvBits);
199
200 /**
201 * Gets the most appropriate log name.
202 *
203 * @returns Pointer to readonly log name.
204 * @param pReader Pointer to the reader instance.
205 */
206 DECLCALLBACKMEMBER(const char *, pfnLogName)(PRTLDRREADER pReader);
207
208 /**
209 * Releases all resources associated with the reader instance.
210 * The instance is invalid after this call returns.
211 *
212 * @returns iprt status code.
213 * @param pReader Pointer to the reader instance.
214 */
215 DECLCALLBACKMEMBER(int, pfnDestroy)(PRTLDRREADER pReader);
216} RTLDRREADER;
217
218/** Magic value for RTLDRREADER (Gordon Matthew Thomas Sumner / Sting). */
219#define RTLDRREADER_MAGIC UINT32_C(0x19511002)
220
221
222/**
223 * Gets the default file suffix for DLL/SO/DYLIB/whatever.
224 *
225 * @returns The stuff (readonly).
226 */
227RTDECL(const char *) RTLdrGetSuff(void);
228
229/**
230 * Checks if a library is loadable or not.
231 *
232 * This may attempt load and unload the library.
233 *
234 * @returns true/false accordingly.
235 * @param pszFilename Image filename.
236 */
237RTDECL(bool) RTLdrIsLoadable(const char *pszFilename);
238
239/**
240 * Loads a dynamic load library (/shared object) image file using native
241 * OS facilities.
242 *
243 * The filename will be appended the default DLL/SO extension of
244 * the platform if it have been omitted. This means that it's not
245 * possible to load DLLs/SOs with no extension using this interface,
246 * but that's not a bad tradeoff.
247 *
248 * If no path is specified in the filename, the OS will usually search it's library
249 * path to find the image file.
250 *
251 * @returns iprt status code.
252 * @param pszFilename Image filename.
253 * @param phLdrMod Where to store the handle to the loader module.
254 */
255RTDECL(int) RTLdrLoad(const char *pszFilename, PRTLDRMOD phLdrMod);
256
257/**
258 * Loads a dynamic load library (/shared object) image file using native
259 * OS facilities.
260 *
261 * The filename will be appended the default DLL/SO extension of
262 * the platform if it have been omitted. This means that it's not
263 * possible to load DLLs/SOs with no extension using this interface,
264 * but that's not a bad tradeoff.
265 *
266 * If no path is specified in the filename, the OS will usually search it's library
267 * path to find the image file.
268 *
269 * @returns iprt status code.
270 * @param pszFilename Image filename.
271 * @param phLdrMod Where to store the handle to the loader module.
272 * @param fFlags See RTLDRLOAD_FLAGS_XXX.
273 * @param pErrInfo Where to return extended error information. Optional.
274 */
275RTDECL(int) RTLdrLoadEx(const char *pszFilename, PRTLDRMOD phLdrMod, uint32_t fFlags, PRTERRINFO pErrInfo);
276
277/** @defgroup RTLDRLOAD_FLAGS_XXX RTLdrLoadEx flags.
278 * @{ */
279/** Symbols defined in this library are not made available to resolve
280 * references in subsequently loaded libraries (default). */
281#define RTLDRLOAD_FLAGS_LOCAL UINT32_C(0)
282/** Symbols defined in this library will be made available for symbol
283 * resolution of subsequently loaded libraries. */
284#define RTLDRLOAD_FLAGS_GLOBAL RT_BIT_32(0)
285/** Do not unload the library upon RTLdrClose. (For system libs.) */
286#define RTLDRLOAD_FLAGS_NO_UNLOAD RT_BIT_32(1)
287/** Windows/NT: Search the DLL load directory for imported DLLs - W7,
288 * Vista, and W2K8 requires KB2533623 to be installed to support this; not
289 * supported on XP, W2K3 or earlier. Ignored on other platforms. */
290#define RTLDRLOAD_FLAGS_NT_SEARCH_DLL_LOAD_DIR RT_BIT_32(2)
291/** The mask of valid flag bits. */
292#define RTLDRLOAD_FLAGS_VALID_MASK UINT32_C(0x00000007)
293/** @} */
294
295/**
296 * Loads a dynamic load library (/shared object) image file residing in one of
297 * the default system library locations.
298 *
299 * Only the system library locations are searched. No suffix is required.
300 *
301 * @returns iprt status code.
302 * @param pszFilename Image filename. No path.
303 * @param fNoUnload Do not unload the library when RTLdrClose is called.
304 * @param phLdrMod Where to store the handle to the loaded module.
305 */
306RTDECL(int) RTLdrLoadSystem(const char *pszFilename, bool fNoUnload, PRTLDRMOD phLdrMod);
307
308/**
309 * Combines RTLdrLoadSystem and RTLdrGetSymbol, with fNoUnload set to true.
310 *
311 * @returns The symbol value, NULL on failure. (If you care for a less boolean
312 * status, go thru the necessary API calls yourself.)
313 * @param pszFilename Image filename. No path.
314 * @param pszSymbol Symbol name.
315 */
316RTDECL(void *) RTLdrGetSystemSymbol(const char *pszFilename, const char *pszSymbol);
317
318/**
319 * Loads a dynamic load library (/shared object) image file residing in the
320 * RTPathAppPrivateArch() directory.
321 *
322 * Suffix is not required.
323 *
324 * @returns iprt status code.
325 * @param pszFilename Image filename. No path.
326 * @param phLdrMod Where to store the handle to the loaded module.
327 */
328RTDECL(int) RTLdrLoadAppPriv(const char *pszFilename, PRTLDRMOD phLdrMod);
329
330/**
331 * Gets the native module handle for a module loaded by RTLdrLoad, RTLdrLoadEx,
332 * RTLdrLoadSystem, or RTLdrLoadAppPriv.
333 *
334 * @returns Native handle on success, ~(uintptr_t)0 on failure.
335 * @param hLdrMod The loader module handle.
336 */
337RTDECL(uintptr_t) RTLdrGetNativeHandle(RTLDRMOD hLdrMod);
338
339
340/**
341 * Image architecuture specifier for RTLdrOpenEx.
342 */
343typedef enum RTLDRARCH
344{
345 RTLDRARCH_INVALID = 0,
346 /** Whatever. */
347 RTLDRARCH_WHATEVER,
348 /** The host architecture. */
349 RTLDRARCH_HOST,
350 /** 32-bit x86. */
351 RTLDRARCH_X86_32,
352 /** AMD64 (64-bit x86 if you like). */
353 RTLDRARCH_AMD64,
354 /** End of the valid values. */
355 RTLDRARCH_END,
356 /** Make sure the type is a full 32-bit. */
357 RTLDRARCH_32BIT_HACK = 0x7fffffff
358} RTLDRARCH;
359/** Pointer to a RTLDRARCH. */
360typedef RTLDRARCH *PRTLDRARCH;
361
362/** @name RTLDR_O_XXX - RTLdrOpen flags.
363 * @{ */
364/** Open for debugging or introspection reasons.
365 * This will skip a few of the stricter validations when loading images. */
366#define RTLDR_O_FOR_DEBUG RT_BIT_32(0)
367/** Open for signature validation. */
368#define RTLDR_O_FOR_VALIDATION RT_BIT_32(1)
369/** The arch specification is just a guideline for FAT binaries. */
370#define RTLDR_O_WHATEVER_ARCH RT_BIT_32(2)
371/** Ignore the architecture specification if there is no code. */
372#define RTLDR_O_IGNORE_ARCH_IF_NO_CODE RT_BIT_32(3)
373/** Mask of valid flags. */
374#define RTLDR_O_VALID_MASK UINT32_C(0x0000000f)
375/** @} */
376
377/**
378 * Open a binary image file.
379 *
380 * @returns iprt status code.
381 * @param pszFilename Image filename.
382 * @param fFlags Valid RTLDR_O_XXX combination.
383 * @param enmArch CPU architecture specifier for the image to be loaded.
384 * @param phLdrMod Where to store the handle to the loader module.
385 */
386RTDECL(int) RTLdrOpen(const char *pszFilename, uint32_t fFlags, RTLDRARCH enmArch, PRTLDRMOD phLdrMod);
387
388/**
389 * Open a binary image file, extended version.
390 *
391 * @returns iprt status code.
392 * @param pszFilename Image filename.
393 * @param fFlags Valid RTLDR_O_XXX combination.
394 * @param enmArch CPU architecture specifier for the image to be loaded.
395 * @param phLdrMod Where to store the handle to the loader module.
396 * @param pErrInfo Where to return extended error information. Optional.
397 */
398RTDECL(int) RTLdrOpenEx(const char *pszFilename, uint32_t fFlags, RTLDRARCH enmArch, PRTLDRMOD phLdrMod, PRTERRINFO pErrInfo);
399
400/**
401 * Opens a binary image file using kLdr.
402 *
403 * @returns iprt status code.
404 * @param pszFilename Image filename.
405 * @param phLdrMod Where to store the handle to the loaded module.
406 * @param fFlags Valid RTLDR_O_XXX combination.
407 * @param enmArch CPU architecture specifier for the image to be loaded.
408 * @remark Primarily for testing the loader.
409 */
410RTDECL(int) RTLdrOpenkLdr(const char *pszFilename, uint32_t fFlags, RTLDRARCH enmArch, PRTLDRMOD phLdrMod);
411
412/**
413 * Open part with reader.
414 *
415 * @returns iprt status code.
416 * @param pReader The loader reader instance which will provide the raw
417 * image bits. The reader instance will be consumed on
418 * success. On failure, the caller has to do the cleaning
419 * up.
420 * @param fFlags Valid RTLDR_O_XXX combination.
421 * @param enmArch Architecture specifier.
422 * @param phMod Where to store the handle.
423 * @param pErrInfo Where to return extended error information. Optional.
424 */
425RTDECL(int) RTLdrOpenWithReader(PRTLDRREADER pReader, uint32_t fFlags, RTLDRARCH enmArch, PRTLDRMOD phMod, PRTERRINFO pErrInfo);
426
427/**
428 * Called to read @a cb bytes at @a off into @a pvBuf.
429 *
430 * @returns IPRT status code
431 * @param pvBuf The output buffer.
432 * @param cb The number of bytes to read.
433 * @param off Where to start reading.
434 * @param pvUser The user parameter.
435 */
436typedef DECLCALLBACK(int) FNRTLDRRDRMEMREAD(void *pvBuf, size_t cb, size_t off, void *pvUser);
437/** Pointer to a RTLdrOpenInMemory reader callback. */
438typedef FNRTLDRRDRMEMREAD *PFNRTLDRRDRMEMREAD;
439
440/**
441 * Called to when the module is unloaded (or done loading) to release resources
442 * associated with it (@a pvUser).
443 *
444 * @returns IPRT status code
445 * @param pvUser The user parameter.
446 */
447typedef DECLCALLBACK(void) FNRTLDRRDRMEMDTOR(void *pvUser);
448/** Pointer to a RTLdrOpenInMemory destructor callback. */
449typedef FNRTLDRRDRMEMDTOR *PFNRTLDRRDRMEMDTOR;
450
451/**
452 * Open a in-memory image or an image with a custom reader callback.
453 *
454 * @returns IPRT status code.
455 * @param pszName The image name.
456 * @param fFlags Valid RTLDR_O_XXX combination.
457 * @param enmArch CPU architecture specifier for the image to be loaded.
458 * @param cbImage The size of the image (fake file).
459 * @param pfnRead The read function. If NULL is passed in, a default
460 * reader function is provided that assumes @a pvUser
461 * points to the raw image bits, at least @a cbImage of
462 * valid memory.
463 * @param pfnDtor The destructor function. If NULL is passed, a default
464 * destructor will be provided that passes @a pvUser to
465 * RTMemFree.
466 * @param pvUser The user argument or, if any of the callbacks are NULL,
467 * a pointer to a memory block.
468 * @param phLdrMod Where to return the module handle.
469 *
470 * @remarks With the exception of invalid @a pfnDtor and/or @a pvUser
471 * parameters, the pfnDtor methods (or the default one if NULL) will
472 * always be invoked. The destruction of pvUser is entirely in the
473 * hands of this method once it's called.
474 */
475RTDECL(int) RTLdrOpenInMemory(const char *pszName, uint32_t fFlags, RTLDRARCH enmArch, size_t cbImage,
476 PFNRTLDRRDRMEMREAD pfnRead, PFNRTLDRRDRMEMDTOR pfnDtor, void *pvUser,
477 PRTLDRMOD phLdrMod);
478
479/**
480 * Closes a loader module handle.
481 *
482 * The handle can be obtained using any of the RTLdrLoad(), RTLdrOpen()
483 * and RTLdrOpenInMemory() functions.
484 *
485 * @returns iprt status code.
486 * @param hLdrMod The loader module handle.
487 */
488RTDECL(int) RTLdrClose(RTLDRMOD hLdrMod);
489
490/**
491 * Gets the address of a named exported symbol.
492 *
493 * @returns iprt status code.
494 * @retval VERR_LDR_FORWARDER forwarder, use pfnQueryForwarderInfo. Buffer size
495 * hint in @a ppvValue.
496 * @param hLdrMod The loader module handle.
497 * @param pszSymbol Symbol name.
498 * @param ppvValue Where to store the symbol value. Note that this is restricted to the
499 * pointer size used on the host!
500 */
501RTDECL(int) RTLdrGetSymbol(RTLDRMOD hLdrMod, const char *pszSymbol, void **ppvValue);
502
503/**
504 * Gets the address of a named exported symbol.
505 *
506 * This function differs from the plain one in that it can deal with
507 * both GC and HC address sizes, and that it can calculate the symbol
508 * value relative to any given base address.
509 *
510 * @returns iprt status code.
511 * @retval VERR_LDR_FORWARDER forwarder, use pfnQueryForwarderInfo. Buffer size
512 * hint in @a pValue.
513 * @param hLdrMod The loader module handle.
514 * @param pvBits Optional pointer to the loaded image.
515 * Set this to NULL if no RTLdrGetBits() processed image bits are available.
516 * Not supported for RTLdrLoad() images.
517 * @param BaseAddress Image load address.
518 * Not supported for RTLdrLoad() images.
519 * @param iOrdinal Symbol ordinal number, pass UINT32_MAX if pszSymbol
520 * should be used instead.
521 * @param pszSymbol Symbol name.
522 * @param pValue Where to store the symbol value.
523 */
524RTDECL(int) RTLdrGetSymbolEx(RTLDRMOD hLdrMod, const void *pvBits, RTLDRADDR BaseAddress,
525 uint32_t iOrdinal, const char *pszSymbol, PRTLDRADDR pValue);
526
527/**
528 * Gets the address of a named exported function.
529 *
530 * Same as RTLdrGetSymbol, but skips the status code and pointer to return
531 * variable stuff.
532 *
533 * @returns Pointer to the function if found, NULL if not.
534 * @param hLdrMod The loader module handle.
535 * @param pszSymbol Function name.
536 */
537RTDECL(PFNRT) RTLdrGetFunction(RTLDRMOD hLdrMod, const char *pszSymbol);
538
539/**
540 * Information about an imported symbol.
541 */
542typedef struct RTLDRIMPORTINFO
543{
544 /** Symbol table entry number, UINT32_MAX if not available. */
545 uint32_t iSelfOrdinal;
546 /** The ordinal of the imported symbol in szModule, UINT32_MAX if not used. */
547 uint32_t iOrdinal;
548 /** The symbol name, NULL if not used. This points to the char immediately
549 * following szModule when returned by RTLdrQueryForwarderInfo. */
550 const char *pszSymbol;
551 /** The name of the module being imported from. */
552 char szModule[1];
553} RTLDRIMPORTINFO;
554/** Pointer to information about an imported symbol. */
555typedef RTLDRIMPORTINFO *PRTLDRIMPORTINFO;
556/** Pointer to const information about an imported symbol. */
557typedef RTLDRIMPORTINFO const *PCRTLDRIMPORTINFO;
558
559/**
560 * Query information about a forwarded symbol.
561 *
562 * @returns IPRT status code.
563 * @param hLdrMod The loader module handle.
564 * @param pvBits Optional pointer to the loaded image.
565 * Set this to NULL if no RTLdrGetBits() processed image bits are available.
566 * Not supported for RTLdrLoad() images.
567 * @param iOrdinal Symbol ordinal number, pass UINT32_MAX if pszSymbol
568 * should be used instead.
569 * @param pszSymbol Symbol name.
570 * @param pInfo Where to return the forwarder info.
571 * @param cbInfo Size of the buffer @a pInfo points to. For a size
572 * hint, see @a pValue when RTLdrGetSymbolEx returns
573 * VERR_LDR_FORWARDER.
574 */
575RTDECL(int) RTLdrQueryForwarderInfo(RTLDRMOD hLdrMod, const void *pvBits, uint32_t iOrdinal, const char *pszSymbol,
576 PRTLDRIMPORTINFO pInfo, size_t cbInfo);
577
578
579/**
580 * Gets the size of the loaded image.
581 *
582 * This is not necessarily available for images that has been loaded using
583 * RTLdrLoad().
584 *
585 * @returns image size (in bytes).
586 * @returns ~(size_t)0 on if not available.
587 * @param hLdrMod Handle to the loader module.
588 */
589RTDECL(size_t) RTLdrSize(RTLDRMOD hLdrMod);
590
591/**
592 * Resolve an external symbol during RTLdrGetBits().
593 *
594 * @returns iprt status code.
595 * @param hLdrMod The loader module handle.
596 * @param pszModule Module name.
597 * @param pszSymbol Symbol name, NULL if uSymbol should be used.
598 * @param uSymbol Symbol ordinal, ~0 if pszSymbol should be used.
599 * @param pValue Where to store the symbol value (address).
600 * @param pvUser User argument.
601 */
602typedef DECLCALLBACK(int) FNRTLDRIMPORT(RTLDRMOD hLdrMod, const char *pszModule, const char *pszSymbol, unsigned uSymbol,
603 PRTLDRADDR pValue, void *pvUser);
604/** Pointer to a FNRTLDRIMPORT() callback function. */
605typedef FNRTLDRIMPORT *PFNRTLDRIMPORT;
606
607/**
608 * Loads the image into a buffer provided by the user and applies fixups
609 * for the given base address.
610 *
611 * @returns iprt status code.
612 * @param hLdrMod The load module handle.
613 * @param pvBits Where to put the bits.
614 * Must be as large as RTLdrSize() suggests.
615 * @param BaseAddress The base address.
616 * @param pfnGetImport Callback function for resolving imports one by one.
617 * @param pvUser User argument for the callback.
618 * @remark Not supported for RTLdrLoad() images.
619 */
620RTDECL(int) RTLdrGetBits(RTLDRMOD hLdrMod, void *pvBits, RTLDRADDR BaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser);
621
622/**
623 * Relocates bits after getting them.
624 * Useful for code which moves around a bit.
625 *
626 * @returns iprt status code.
627 * @param hLdrMod The loader module handle.
628 * @param pvBits Where the image bits are.
629 * Must have been passed to RTLdrGetBits().
630 * @param NewBaseAddress The new base address.
631 * @param OldBaseAddress The old base address.
632 * @param pfnGetImport Callback function for resolving imports one by one.
633 * @param pvUser User argument for the callback.
634 * @remark Not supported for RTLdrLoad() images.
635 */
636RTDECL(int) RTLdrRelocate(RTLDRMOD hLdrMod, void *pvBits, RTLDRADDR NewBaseAddress, RTLDRADDR OldBaseAddress,
637 PFNRTLDRIMPORT pfnGetImport, void *pvUser);
638
639/**
640 * Enumeration callback function used by RTLdrEnumSymbols().
641 *
642 * @returns iprt status code. Failure will stop the enumeration.
643 * @param hLdrMod The loader module handle.
644 * @param pszSymbol Symbol name. NULL if ordinal only.
645 * @param uSymbol Symbol ordinal, ~0 if not used.
646 * @param Value Symbol value.
647 * @param pvUser The user argument specified to RTLdrEnumSymbols().
648 */
649typedef DECLCALLBACK(int) FNRTLDRENUMSYMS(RTLDRMOD hLdrMod, const char *pszSymbol, unsigned uSymbol, RTLDRADDR Value, void *pvUser);
650/** Pointer to a FNRTLDRENUMSYMS() callback function. */
651typedef FNRTLDRENUMSYMS *PFNRTLDRENUMSYMS;
652
653/**
654 * Enumerates all symbols in a module.
655 *
656 * @returns iprt status code.
657 * @param hLdrMod The loader module handle.
658 * @param fFlags Flags indicating what to return and such.
659 * @param pvBits Optional pointer to the loaded image. (RTLDR_ENUM_SYMBOL_FLAGS_*)
660 * Set this to NULL if no RTLdrGetBits() processed image bits are available.
661 * @param BaseAddress Image load address.
662 * @param pfnCallback Callback function.
663 * @param pvUser User argument for the callback.
664 * @remark Not supported for RTLdrLoad() images.
665 */
666RTDECL(int) RTLdrEnumSymbols(RTLDRMOD hLdrMod, unsigned fFlags, const void *pvBits, RTLDRADDR BaseAddress, PFNRTLDRENUMSYMS pfnCallback, void *pvUser);
667
668/** @name RTLdrEnumSymbols flags.
669 * @{ */
670/** Returns ALL kinds of symbols. The default is to only return public/exported symbols. */
671#define RTLDR_ENUM_SYMBOL_FLAGS_ALL RT_BIT(1)
672/** Ignore forwarders (for use with RTLDR_ENUM_SYMBOL_FLAGS_ALL). */
673#define RTLDR_ENUM_SYMBOL_FLAGS_NO_FWD RT_BIT(2)
674/** @} */
675
676
677/**
678 * Debug info type (as far the loader can tell).
679 */
680typedef enum RTLDRDBGINFOTYPE
681{
682 /** The invalid 0 value. */
683 RTLDRDBGINFOTYPE_INVALID = 0,
684 /** Unknown debug info format. */
685 RTLDRDBGINFOTYPE_UNKNOWN,
686 /** Stabs. */
687 RTLDRDBGINFOTYPE_STABS,
688 /** Debug With Arbitrary Record Format (DWARF). */
689 RTLDRDBGINFOTYPE_DWARF,
690 /** Debug With Arbitrary Record Format (DWARF), in external file (DWO). */
691 RTLDRDBGINFOTYPE_DWARF_DWO,
692 /** Microsoft Codeview debug info. */
693 RTLDRDBGINFOTYPE_CODEVIEW,
694 /** Microsoft Codeview debug info, in external v2.0+ program database (PDB). */
695 RTLDRDBGINFOTYPE_CODEVIEW_PDB20,
696 /** Microsoft Codeview debug info, in external v7.0+ program database (PDB). */
697 RTLDRDBGINFOTYPE_CODEVIEW_PDB70,
698 /** Microsoft Codeview debug info, in external file (DBG). */
699 RTLDRDBGINFOTYPE_CODEVIEW_DBG,
700 /** Microsoft COFF debug info. */
701 RTLDRDBGINFOTYPE_COFF,
702 /** Watcom debug info. */
703 RTLDRDBGINFOTYPE_WATCOM,
704 /** IBM High Level Language debug info. */
705 RTLDRDBGINFOTYPE_HLL,
706 /** The end of the valid debug info values (exclusive). */
707 RTLDRDBGINFOTYPE_END,
708 /** Blow the type up to 32-bits. */
709 RTLDRDBGINFOTYPE_32BIT_HACK = 0x7fffffff
710} RTLDRDBGINFOTYPE;
711
712
713/**
714 * Debug info details for the enumeration callback.
715 */
716typedef struct RTLDRDBGINFO
717{
718 /** The kind of debug info. */
719 RTLDRDBGINFOTYPE enmType;
720 /** The debug info ordinal number / id. */
721 uint32_t iDbgInfo;
722 /** The file offset *if* this type has one specific location in the executable
723 * image file. This is -1 if there isn't any specific file location. */
724 RTFOFF offFile;
725 /** The link address of the debug info if it's loadable. NIL_RTLDRADDR if not
726 * loadable*/
727 RTLDRADDR LinkAddress;
728 /** The size of the debug information. -1 is used if this isn't applicable.*/
729 RTLDRADDR cb;
730 /** This is set if the debug information is found in an external file. NULL
731 * if no external file involved.
732 * @note Putting it outside the union to allow lazy callback implementation. */
733 const char *pszExtFile;
734 /** Type (enmType) specific information. */
735 union
736 {
737 /** RTLDRDBGINFOTYPE_DWARF */
738 struct
739 {
740 /** The section name. */
741 const char *pszSection;
742 } Dwarf;
743
744 /** RTLDRDBGINFOTYPE_DWARF_DWO */
745 struct
746 {
747 /** The CRC32 of the external file. */
748 uint32_t uCrc32;
749 } Dwo;
750
751 /** RTLDRDBGINFOTYPE_CODEVIEW, RTLDRDBGINFOTYPE_COFF */
752 struct
753 {
754 /** The PE image size. */
755 uint32_t cbImage;
756 /** The timestamp. */
757 uint32_t uTimestamp;
758 /** The major version from the entry. */
759 uint32_t uMajorVer;
760 /** The minor version from the entry. */
761 uint32_t uMinorVer;
762 } Cv, Coff;
763
764 /** RTLDRDBGINFOTYPE_CODEVIEW_DBG */
765 struct
766 {
767 /** The PE image size. */
768 uint32_t cbImage;
769 /** The timestamp. */
770 uint32_t uTimestamp;
771 } Dbg;
772
773 /** RTLDRDBGINFOTYPE_CODEVIEW_PDB20*/
774 struct
775 {
776 /** The PE image size. */
777 uint32_t cbImage;
778 /** The timestamp. */
779 uint32_t uTimestamp;
780 /** The PDB age. */
781 uint32_t uAge;
782 } Pdb20;
783
784 /** RTLDRDBGINFOTYPE_CODEVIEW_PDB70 */
785 struct
786 {
787 /** The PE image size. */
788 uint32_t cbImage;
789 /** The PDB age. */
790 uint32_t uAge;
791 /** The UUID. */
792 RTUUID Uuid;
793 } Pdb70;
794 } u;
795} RTLDRDBGINFO;
796/** Pointer to debug info details. */
797typedef RTLDRDBGINFO *PRTLDRDBGINFO;
798/** Pointer to read only debug info details. */
799typedef RTLDRDBGINFO const *PCRTLDRDBGINFO;
800
801
802/**
803 * Debug info enumerator callback.
804 *
805 * @returns VINF_SUCCESS to continue the enumeration. Any other status code
806 * will cause RTLdrEnumDbgInfo to immediately return with that status.
807 *
808 * @param hLdrMod The module handle.
809 * @param pDbgInfo Pointer to a read only structure with the details.
810 * @param pvUser The user parameter specified to RTLdrEnumDbgInfo.
811 */
812typedef DECLCALLBACK(int) FNRTLDRENUMDBG(RTLDRMOD hLdrMod, PCRTLDRDBGINFO pDbgInfo, void *pvUser);
813/** Pointer to a debug info enumerator callback. */
814typedef FNRTLDRENUMDBG *PFNRTLDRENUMDBG;
815
816/**
817 * Enumerate the debug info contained in the executable image.
818 *
819 * @returns IPRT status code or whatever pfnCallback returns.
820 *
821 * @param hLdrMod The module handle.
822 * @param pvBits Optional pointer to bits returned by
823 * RTLdrGetBits(). This can be used by some module
824 * interpreters to reduce memory consumption.
825 * @param pfnCallback The callback function.
826 * @param pvUser The user argument.
827 */
828RTDECL(int) RTLdrEnumDbgInfo(RTLDRMOD hLdrMod, const void *pvBits, PFNRTLDRENUMDBG pfnCallback, void *pvUser);
829
830
831/**
832 * Loader segment.
833 */
834typedef struct RTLDRSEG
835{
836 /** The segment name. Always set to something. */
837 const char *pszName;
838 /** The length of the segment name. */
839 uint32_t cchName;
840 /** The flat selector to use for the segment (i.e. data/code).
841 * Primarily a way for the user to specify selectors for the LX/LE and NE interpreters. */
842 uint16_t SelFlat;
843 /** The 16-bit selector to use for the segment.
844 * Primarily a way for the user to specify selectors for the LX/LE and NE interpreters. */
845 uint16_t Sel16bit;
846 /** Segment flags. */
847 uint32_t fFlags;
848 /** The segment protection (RTMEM_PROT_XXX). */
849 uint32_t fProt;
850 /** The size of the segment. */
851 RTLDRADDR cb;
852 /** The required segment alignment.
853 * The to 0 if the segment isn't supposed to be mapped. */
854 RTLDRADDR Alignment;
855 /** The link address.
856 * Set to NIL_RTLDRADDR if the segment isn't supposed to be mapped or if
857 * the image doesn't have link addresses. */
858 RTLDRADDR LinkAddress;
859 /** File offset of the segment.
860 * Set to -1 if no file backing (like BSS). */
861 RTFOFF offFile;
862 /** Size of the file bits of the segment.
863 * Set to -1 if no file backing (like BSS). */
864 RTFOFF cbFile;
865 /** The relative virtual address when mapped.
866 * Set to NIL_RTLDRADDR if the segment isn't supposed to be mapped. */
867 RTLDRADDR RVA;
868 /** The size of the segment including the alignment gap up to the next segment when mapped.
869 * This is set to NIL_RTLDRADDR if not implemented. */
870 RTLDRADDR cbMapped;
871} RTLDRSEG;
872/** Pointer to a loader segment. */
873typedef RTLDRSEG *PRTLDRSEG;
874/** Pointer to a read only loader segment. */
875typedef RTLDRSEG const *PCRTLDRSEG;
876
877
878/** @name Segment flags
879 * @{ */
880/** The segment is 16-bit. When not set the default of the target architecture is assumed. */
881#define RTLDRSEG_FLAG_16BIT UINT32_C(1)
882/** The segment requires a 16-bit selector alias. (OS/2) */
883#define RTLDRSEG_FLAG_OS2_ALIAS16 UINT32_C(2)
884/** Conforming segment (x86 weirdness). (OS/2) */
885#define RTLDRSEG_FLAG_OS2_CONFORM UINT32_C(4)
886/** IOPL (ring-2) segment. (OS/2) */
887#define RTLDRSEG_FLAG_OS2_IOPL UINT32_C(8)
888/** @} */
889
890/**
891 * Segment enumerator callback.
892 *
893 * @returns VINF_SUCCESS to continue the enumeration. Any other status code
894 * will cause RTLdrEnumSegments to immediately return with that
895 * status.
896 *
897 * @param hLdrMod The module handle.
898 * @param pSeg The segment information.
899 * @param pvUser The user parameter specified to RTLdrEnumSegments.
900 */
901typedef DECLCALLBACK(int) FNRTLDRENUMSEGS(RTLDRMOD hLdrMod, PCRTLDRSEG pSeg, void *pvUser);
902/** Pointer to a segment enumerator callback. */
903typedef FNRTLDRENUMSEGS *PFNRTLDRENUMSEGS;
904
905/**
906 * Enumerate the debug info contained in the executable image.
907 *
908 * @returns IPRT status code or whatever pfnCallback returns.
909 *
910 * @param hLdrMod The module handle.
911 * @param pfnCallback The callback function.
912 * @param pvUser The user argument.
913 */
914RTDECL(int) RTLdrEnumSegments(RTLDRMOD hLdrMod, PFNRTLDRENUMSEGS pfnCallback, void *pvUser);
915
916/**
917 * Converts a link address to a segment:offset address.
918 *
919 * @returns IPRT status code.
920 *
921 * @param hLdrMod The module handle.
922 * @param LinkAddress The link address to convert.
923 * @param piSeg Where to return the segment index.
924 * @param poffSeg Where to return the segment offset.
925 */
926RTDECL(int) RTLdrLinkAddressToSegOffset(RTLDRMOD hLdrMod, RTLDRADDR LinkAddress, uint32_t *piSeg, PRTLDRADDR poffSeg);
927
928/**
929 * Converts a link address to an image relative virtual address (RVA).
930 *
931 * @returns IPRT status code.
932 *
933 * @param hLdrMod The module handle.
934 * @param LinkAddress The link address to convert.
935 * @param pRva Where to return the RVA.
936 */
937RTDECL(int) RTLdrLinkAddressToRva(RTLDRMOD hLdrMod, RTLDRADDR LinkAddress, PRTLDRADDR pRva);
938
939/**
940 * Converts an image relative virtual address (RVA) to a segment:offset.
941 *
942 * @returns IPRT status code.
943 *
944 * @param hLdrMod The module handle.
945 * @param iSeg The segment index.
946 * @param offSeg The segment offset.
947 * @param pRva Where to return the RVA.
948 */
949RTDECL(int) RTLdrSegOffsetToRva(RTLDRMOD hLdrMod, uint32_t iSeg, RTLDRADDR offSeg, PRTLDRADDR pRva);
950
951/**
952 * Converts a segment:offset into an image relative virtual address (RVA).
953 *
954 * @returns IPRT status code.
955 *
956 * @param hLdrMod The module handle.
957 * @param Rva The link address to convert.
958 * @param piSeg Where to return the segment index.
959 * @param poffSeg Where to return the segment offset.
960 */
961RTDECL(int) RTLdrRvaToSegOffset(RTLDRMOD hLdrMod, RTLDRADDR Rva, uint32_t *piSeg, PRTLDRADDR poffSeg);
962
963/**
964 * Gets the image format.
965 *
966 * @returns Valid image format on success. RTLDRFMT_INVALID on invalid handle or
967 * other errors.
968 * @param hLdrMod The module handle.
969 */
970RTDECL(RTLDRFMT) RTLdrGetFormat(RTLDRMOD hLdrMod);
971
972/**
973 * Gets the image type.
974 *
975 * @returns Valid image type value on success. RTLDRTYPE_INVALID on
976 * invalid handle or other errors.
977 * @param hLdrMod The module handle.
978 */
979RTDECL(RTLDRTYPE) RTLdrGetType(RTLDRMOD hLdrMod);
980
981/**
982 * Gets the image endian-ness.
983 *
984 * @returns Valid image endian value on success. RTLDRENDIAN_INVALID on invalid
985 * handle or other errors.
986 * @param hLdrMod The module handle.
987 */
988RTDECL(RTLDRENDIAN) RTLdrGetEndian(RTLDRMOD hLdrMod);
989
990/**
991 * Gets the image endian-ness.
992 *
993 * @returns Valid image architecture value on success.
994 * RTLDRARCH_INVALID on invalid handle or other errors.
995 * @param hLdrMod The module handle.
996 */
997RTDECL(RTLDRARCH) RTLdrGetArch(RTLDRMOD hLdrMod);
998
999/**
1000 * Loader properties that can be queried thru RTLdrQueryProp.
1001 */
1002typedef enum RTLDRPROP
1003{
1004 RTLDRPROP_INVALID = 0,
1005 /** The image UUID (Mach-O).
1006 * Returns a RTUUID in the buffer. */
1007 RTLDRPROP_UUID,
1008 /** The image timestamp in seconds, genrally since unix epoc.
1009 * Returns a 32-bit or 64-bit signed integer value in the buffer. */
1010 RTLDRPROP_TIMESTAMP_SECONDS,
1011 /** Checks if the image is signed.
1012 * Returns a bool. */
1013 RTLDRPROP_IS_SIGNED,
1014 /** Retrives the PKCS \#7 SignedData blob that signs the image.
1015 * Returns variable sized buffer containing the ASN.1 BER encoding.
1016 *
1017 * @remarks This generally starts with a PKCS \#7 Content structure, the
1018 * SignedData bit is found a few levels down into this as per RFC. */
1019 RTLDRPROP_PKCS7_SIGNED_DATA,
1020
1021 /** Query whether code signature checks are enabled. */
1022 RTLDRPROP_SIGNATURE_CHECKS_ENFORCED,
1023
1024 /** Number of import or needed modules. */
1025 RTLDRPROP_IMPORT_COUNT,
1026 /** Import module by index (32-bit) stored in the buffer. */
1027 RTLDRPROP_IMPORT_MODULE,
1028 /** The file offset of the main executable header.
1029 * This is mainly for PE, NE and LX headers, but also Mach-O FAT. */
1030 RTLDRPROP_FILE_OFF_HEADER,
1031 /** The internal module name.
1032 * This is the SONAME for ELF, export table name for PE, and zero'th resident
1033 * name table entry for LX.
1034 * Returns zero terminated string. */
1035 RTLDRPROP_INTERNAL_NAME,
1036
1037 /** End of valid properties. */
1038 RTLDRPROP_END,
1039 /** Blow the type up to 32 bits. */
1040 RTLDRPROP_32BIT_HACK = 0x7fffffff
1041} RTLDRPROP;
1042
1043/**
1044 * Generic method for querying image properties.
1045 *
1046 * @returns IPRT status code.
1047 * @retval VERR_NOT_SUPPORTED if the property query isn't supported (either all
1048 * or that specific property). The caller must handle this result.
1049 * @retval VERR_NOT_FOUND the property was not found in the module. The caller
1050 * must also normally deal with this.
1051 * @retval VERR_INVALID_FUNCTION if the function value is wrong.
1052 * @retval VERR_INVALID_PARAMETER if the buffer size is wrong.
1053 * @retval VERR_BUFFER_OVERFLOW if the function doesn't have a fixed size
1054 * buffer and the buffer isn't big enough. Use RTLdrQueryPropEx.
1055 * @retval VERR_INVALID_HANDLE if the handle is invalid.
1056 *
1057 * @param hLdrMod The module handle.
1058 * @param enmProp The property to query.
1059 * @param pvBuf Pointer to the input / output buffer. In most cases
1060 * it's only used for returning data.
1061 * @param cbBuf The size of the buffer.
1062 */
1063RTDECL(int) RTLdrQueryProp(RTLDRMOD hLdrMod, RTLDRPROP enmProp, void *pvBuf, size_t cbBuf);
1064
1065/**
1066 * Generic method for querying image properties, extended version.
1067 *
1068 * @returns IPRT status code.
1069 * @retval VERR_NOT_SUPPORTED if the property query isn't supported (either all
1070 * or that specific property). The caller must handle this result.
1071 * @retval VERR_NOT_FOUND the property was not found in the module. The caller
1072 * must also normally deal with this.
1073 * @retval VERR_INVALID_FUNCTION if the function value is wrong.
1074 * @retval VERR_INVALID_PARAMETER if the fixed buffer size is wrong. Correct
1075 * size in @a *pcbRet.
1076 * @retval VERR_BUFFER_OVERFLOW if the function doesn't have a fixed size
1077 * buffer and the buffer isn't big enough. Correct size in @a *pcbRet.
1078 * @retval VERR_INVALID_HANDLE if the handle is invalid.
1079 *
1080 * @param hLdrMod The module handle.
1081 * @param enmProp The property to query.
1082 * @param pvBits Optional pointer to bits returned by
1083 * RTLdrGetBits(). This can be utilized by some module
1084 * interpreters to reduce memory consumption and file
1085 * access.
1086 * @param pvBuf Pointer to the input / output buffer. In most cases
1087 * it's only used for returning data.
1088 * @param cbBuf The size of the buffer.
1089 * @param pcbRet Where to return the amount of data returned. On
1090 * buffer size errors, this is set to the correct size.
1091 * Optional.
1092 */
1093RTDECL(int) RTLdrQueryPropEx(RTLDRMOD hLdrMod, RTLDRPROP enmProp, void *pvBits, void *pvBuf, size_t cbBuf, size_t *pcbRet);
1094
1095
1096/**
1097 * Signature type, see FNRTLDRVALIDATESIGNEDDATA.
1098 */
1099typedef enum RTLDRSIGNATURETYPE
1100{
1101 /** Invalid value. */
1102 RTLDRSIGNATURETYPE_INVALID = 0,
1103 /** A RTPKCS7CONTENTINFO structure w/ RTPKCS7SIGNEDDATA inside.
1104 * It's parsed, so the whole binary ASN.1 representation can be found by
1105 * using RTASN1CORE_GET_RAW_ASN1_PTR() and RTASN1CORE_GET_RAW_ASN1_SIZE(). */
1106 RTLDRSIGNATURETYPE_PKCS7_SIGNED_DATA,
1107 /** End of valid values. */
1108 RTLDRSIGNATURETYPE_END,
1109 /** Make sure the size is 32-bit. */
1110 RTLDRSIGNATURETYPE_32BIT_HACK = 0x7fffffff
1111} RTLDRSIGNATURETYPE;
1112
1113/**
1114 * Callback used by RTLdrVerifySignature to verify the signature and associated
1115 * certificates.
1116 *
1117 * @returns IPRT status code.
1118 * @param hLdrMod The module handle.
1119 * @param enmSignature The signature format.
1120 * @param pvSignature The signature data. Format given by @a enmSignature.
1121 * @param cbSignature The size of the buffer @a pvSignature points to.
1122 * @param pErrInfo Pointer to an error info buffer, optional.
1123 * @param pvUser User argument.
1124 *
1125 */
1126typedef DECLCALLBACK(int) FNRTLDRVALIDATESIGNEDDATA(RTLDRMOD hLdrMod, RTLDRSIGNATURETYPE enmSignature, void const *pvSignature, size_t cbSignature,
1127 PRTERRINFO pErrInfo, void *pvUser);
1128/** Pointer to a signature verification callback. */
1129typedef FNRTLDRVALIDATESIGNEDDATA *PFNRTLDRVALIDATESIGNEDDATA;
1130
1131/**
1132 * Verify the image signature.
1133 *
1134 * This may permform additional integrity checks on the image structures that
1135 * was not done when opening the image.
1136 *
1137 * @returns IPRT status code.
1138 * @retval VERR_LDRVI_NOT_SIGNED if not signed.
1139 *
1140 * @param hLdrMod The module handle.
1141 * @param pfnCallback Callback that does the signature and certificate
1142 * verficiation.
1143 * @param pvUser User argument for the callback.
1144 * @param pErrInfo Pointer to an error info buffer. Optional.
1145 */
1146RTDECL(int) RTLdrVerifySignature(RTLDRMOD hLdrMod, PFNRTLDRVALIDATESIGNEDDATA pfnCallback, void *pvUser, PRTERRINFO pErrInfo);
1147
1148/**
1149 * Calculate the image hash according the image signing rules.
1150 *
1151 * @returns IPRT status code.
1152 * @param hLdrMod The module handle.
1153 * @param enmDigest Which kind of digest.
1154 * @param pszDigest Where to store the image digest.
1155 * @param cbDigest Size of the buffer @a pszDigest points at.
1156 */
1157RTDECL(int) RTLdrHashImage(RTLDRMOD hLdrMod, RTDIGESTTYPE enmDigest, char *pszDigest, size_t cbDigest);
1158
1159RT_C_DECLS_END
1160
1161/** @} */
1162
1163#endif
1164
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette