source: trunk/kLdr/kLdr.h@ 2832

Last change on this file since 2832 was 2832, checked in by bird, 19 years ago

specified more of the api.
  • Property svn:keywords set to Id
File size: 24.7 KB
Line 
1/* $Id: kLdr.h 2832 2006-10-24 22:26:01Z bird $ */
2/** @file
3 *
4 * kLdr - The Dynamic Loader.
5 *
6 * Copyright (c) 2006 knut st. osmundsen <bird@anduin.net>
7 *
8 *
9 * This file is part of kLdr.
10 *
11 * kLdr is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * kLdr is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with kLdr; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 *
25 */
26
27#ifndef __kLdr_h__
28#define __kLdr_h__
29
30#ifdef __cplusplus
31extern "C" {
32#endif
33
34/* kLdr depend on size_t, [u]intNN_t, [u]intptr_t and some related constants. */
35#include <sys/types.h>
36#include <stddef.h>
37#ifdef _MSC_VER
38typedef signed char int8_t;
39typedef unsigned char uint8_t;
40typedef signed short int16_t;
41typedef unsigned short uint16_t;
42typedef signed int int32_t;
43typedef unsigned int uint32_t;
44typedef signed __int64 int64_t;
45typedef unsigned __int64 uint64_t;
46typedef uint64_t uintmax_t;
47#else
48# include <stdint.h>
49#endif
50
51
52/** @defgroup grp_kLdrRdr kLdrRdr - The file provider
53 * @{ */
54
55typedef enum KLDRPROT
56{
57 /** The usual invalid 0. */
58 KLDRPROT_INVALID = 0,
59 /** No access (page not present). */
60 KLDRPROT_NOACCESS,
61 /** Read only. */
62 KLDRPROT_READONLY,
63 /** Read & write. */
64 KLDRPROT_READWRITE,
65 /** Read & copy on write. */
66 KLDRPROT_WRITECOPY,
67 /** Execute only. */
68 KLDRPROT_EXECUTE,
69 /** Execute & read. */
70 KLDRPROT_EXECUTE_READ,
71 /** Execute, read & write. */
72 KLDRPROT_EXECUTE_READWRITE,
73 /** Execute, read & copy on write. */
74 KLDRPROT_EXECUTE_WRITECOPY,
75 /** The usual end value. (exclusive) */
76 KLDRPROT_END,
77 /** Blow the type up to 32-bits. */
78 KLDRPROT_32BIT_HACK = 0x7fffffff
79} KLDRPROT;
80
81
82/** Pointer to a file provider instance core. */
83typedef struct KLDRRDR *PKLDRRDR;
84/** Pointer to a file provider instance core pointer. */
85typedef struct KLDRRDR **PPKLDRRDR;
86
87/**
88 * File provider instance operations.
89 */
90typedef struct KLDRRDROPS
91{
92 /** The name of this file provider. */
93 const char *pszName;
94 /** Pointer to the next file provider. */
95 const struct KLDRRDROPS *pNext;
96
97 /** Try create a new file provider instance.
98 *
99 * @returns 0 on success, OS specific error code on failure.
100 * @param ppRdr Where to store the file provider instance.
101 * @param pszFilename The filename to open.
102 */
103 int (* pfnCreate)( PPKLDRRDR ppRdr, const char *pszFilename);
104 /** Destroy the file provider instance.
105 *
106 * @returns 0 on success, OS specific error code on failure.
107 * On failure, the file provider instance will be in an indeterminate state - don't touch it!
108 * @param pRdr The file provider instance.
109 */
110 int (* pfnDestroy)( PKLDRRDR pRdr);
111 /** Read bits from the file.
112 *
113 * @returns 0 on success, OS specific error code on failure.
114 * @param pRdr The file provider instance.
115 * @param pvBuf Where to put the bits.
116 * @param cb The number of bytes to read.
117 * @param off Where to start reading.
118 */
119 int (* pfnRead)( PKLDRRDR pRdr, void *pvBuf, size_t cb, off_t off);
120 /** Map all the file bits into memory (read only).
121 *
122 * @returns 0 on success, OS specific error code on failure.
123 * @param pRdr The file provider instance.
124 * @param ppvBits Where to store the address of the mapping.
125 * The size can be obtained using pfnSize.
126 */
127 int (* pfnAllMap)( PKLDRRDR pRdr, const void **ppvBits);
128 /** Unmap a file bits mapping obtained by KLDRRDROPS::pfnAllMap.
129 *
130 * @returns 0 on success, OS specific error code on failure.
131 * @param pRdr The file provider instance.
132 * @param pvBits The mapping address.
133 */
134 int (* pfnAllUnmap)(PKLDRRDR pRdr, const void *pvBits);
135 /** Get the file size.
136 *
137 * @returns The file size. Returns -1 on failure.
138 * @param pRdr The file provider instance.
139 */
140 off_t (* pfnSize)( PKLDRRDR pRdr);
141 /** Get the file pointer offset.
142 *
143 * @returns The file pointer offset. Returns -1 on failure.
144 * @param pRdr The file provider instance.
145 */
146 off_t (* pfnTell)( PKLDRRDR pRdr);
147 /** Get the file name.
148 *
149 * @returns The file size. Returns -1 on failure.
150 * @param pRdr The file provider instance.
151 */
152 const char * (* pfnName)(PKLDRRDR pRdr);
153 /**
154 * Prepares a memory region to map file sections into.
155 *
156 * @returns 0 on success, OS specific error code on failure.
157 * @param pRdr The file provider instance.
158 * @param ppv If fFixed is set, *ppv contains the memory location which
159 * the region should be based at. If fFixed is clear the OS
160 * is free to choose the location.
161 * On successful return *ppv contains address of the prepared
162 * memory region.
163 * @param cb The size of the memory region to prepare.
164 * @param fFixed When set *ppv will contain the desired region address.
165 *
166 */
167 int (* pfnPrepare)(PKLDRRDR pRdr, void **ppv, size_t cb, unsigned fFixed);
168 /**
169 * Maps a section of the file into the memory region reserved by pfnPrepare.
170 *
171 * @returns 0 on success, OS specific error code on failure.
172 * @param pRdr The file provider instance.
173 * @param pv The address in the prepared region.
174 * @param cb The size of the memory mapping.
175 * @param enmProt The desired memory protection.
176 * @param offFile The start of the raw file bytes.
177 * @param cbFile The number of raw file bytes. This must be less or equal to cb.
178 */
179 int (* pfnMap)(PKLDRRDR pRdr, void *pv, size_t cb, KLDRPROT enmProt, off_t offFile, size_t cbFile);
180 /**
181 * Changes the page protection of a section mapped using pfnMap.
182 *
183 * This is typically used for applying fixups and similar.
184 *
185 * @returns 0 on success, OS specific error code on failure.
186 * @param pRdr The file provider instance.
187 * @param pv The address passed to pfnMap.
188 * @param cb The size passed to pfnMap.
189 * @param enmProt The desired memory protection.
190 */
191 int (* pfnProtect)(PKLDRRDR pRdr, void *pv, size_t cb, KLDRPROT enmProt);
192 /**
193 * Unmaps a section of the file previously mapped using pfnMap.
194 *
195 * @returns 0 on success, OS specific error code on failure.
196 * @param pRdr The file provider instance.
197 * @param pv The address passed to pfnMap.
198 * @param cb The size passed to pfnMap.
199 */
200 int (* pfnUnmap)(PKLDRRDR pRdr, void *pv, size_t cb);
201 /**
202 * Releases the memory region prepared by pfnPrepare().
203 *
204 * Before calling this function, all sections mapped by pfnMap must first be unmapped by calling pfnUnmap.
205 *
206 * @returns 0 on success, OS specific error code on failure.
207 * @param pRdr The file provider instance.
208 * @param pv The address of the prepared region.
209 * @param cb The size of the prepared region.
210 */
211 int (* pfnUnprepare)(PKLDRRDR pRdr, void *pv, size_t cb);
212 /**
213 * We're done reading from the file but would like to keep file mappings.
214 *
215 * If the OS support closing the file handle while the file is mapped,
216 * the reader should do so.
217 *
218 * @param pRdr The file provider instance.
219 */
220 void (* pfnDone)(PKLDRRDR pRdr);
221 /** The usual non-zero dummy that makes sure we've initialized all members. */
222 uint32_t u32Dummy;
223} KLDRRDROPS;
224/** Pointer to file provider operations. */
225typedef KLDRRDROPS *PKLDRRDROPS;
226/** Pointer to const file provider operations. */
227typedef const KLDRRDROPS *PCKLDRRDROPS;
228
229
230/**
231 * File provider instance core.
232 */
233typedef struct KLDRRDR
234{
235 /** Pointer to the file provider operations. */
236 PCKLDRRDROPS pOps;
237} KLDRRDR;
238
239void kLdrRdrAddProvider(PKLDRRDROPS pAdd);
240
241int kLdrRdrOpen( PPKLDRRDR ppRdr, const char *pszFilename);
242int kLdrRdrClose( PKLDRRDR pRdr);
243int kLdrRdrRead( PKLDRRDR pRdr, void *pvBuf, size_t cb, off_t off);
244int kLdrRdrAllMap( PKLDRRDR pRdr, const void **ppvBits);
245int kLdrRdrAllUnmap(PKLDRRDR pRdr, const void *pvBits);
246off_t kLdrRdrSize( PKLDRRDR pRdr);
247off_t kLdrRdrTell( PKLDRRDR pRdr);
248const char *kLdrRdrName(PKLDRRDR pRdr);
249
250/** @} */
251
252
253
254/** @defgroup grp_kLdrMod kLdrMod - The executable image intepreter
255 * @{ */
256
257/**
258 * Loader segment.
259 */
260typedef struct KLDRSEG
261{
262 /** Variable free to use for the kLdr user. */
263 void *pvUser;
264 /** The segment name. */
265 const char *pszName;
266 /** The size of the segment. */
267 size_t cb;
268 /** The link time load address. */
269 void *pvLink;
270 /** The actual load address (if loaded). */
271 void *pv;
272 /** The segment protection. */
273 KLDRPROT enmProt;
274} KLDRSEG, *PKLDRSEG;
275
276
277/**
278 * Loader module format.
279 */
280typedef enum KLDRFMT
281{
282 /** The usual invalid 0 format. */
283 KLDRFMT_INVALID = 0,
284 /** The native OS loader. */
285 KLDRFMT_NATIVE,
286 /** The AOUT loader. */
287 KLDRFMT_AOUT,
288 /** The ELF loader. */
289 KLDRFMT_ELF,
290 /** The LX loader. */
291 KLDRFMT_LX,
292 /** The mach-o loader. */
293 KLDRFMT_MACHO,
294 /** The LX loader. */
295 KLDRFMT_PE,
296 /** The end of the valid format values (exclusive). */
297 KLDRFMT_END,
298 /** Hack to blow the type up to 32-bit. */
299 KLDRFMT_32BIT_HACK = 0x7fffffff
300} KLDRFMT;
301
302
303/**
304 * Loader module type.
305 */
306typedef enum KLDRTYPE
307{
308 /** The usual invalid 0 type. */
309 KLDRTYPE_INVALID = 0,
310 /** Object file. */
311 KLDRTYPE_OBJECT,
312 /** Executable module, fixed load address. */
313 KLDRTYPE_EXECUTABLE_FIXED,
314 /** Executable module, relocatable, non-fixed load address. */
315 KLDRTYPE_EXECUTABLE_RELOCATABLE,
316 /** Executable module, position independent code, non-fixed load address. */
317 KLDRTYPE_EXECUTABLE_PIC,
318 /** Shared library, fixed load address.
319 * Typically a system library. */
320 KLDRTYPE_SHARED_LIBRARY_FIXED,
321 /** Shared library, relocatable, non-fixed load address. */
322 KLDRTYPE_SHARED_LIBRARY_RELOCATABLE,
323 /** Shared library, position independent code, non-fixed load address. */
324 KLDRTYPE_SHARED_LIBRARY_PIC,
325 /** DLL that contains no code or data only imports and exports. (Chiefly OS/2.) */
326 KLDRTYPE_FORWARDER_DLL,
327 /** Core or dump. */
328 KLDRTYPE_CORE,
329 /** The end of the valid types values (exclusive). */
330 KLDRTYPE_END,
331 /** Hack to blow the type up to 32-bit. */
332 KLDRTYPE_32BIT_HACK = 0x7fffffff
333} KLDRTYPE;
334
335
336/**
337 * CPU Architecture.
338 * @todo Double check the non intel architectures.
339 */
340typedef enum KLDRARCH
341{
342 /** The usual invalid one. */
343 KLDRARCH_INVALID = 0,
344 /** Clone or Intel 16-bit x86. */
345 KLDRARCH_X86_16,
346 /** Clone or Intel 32-bit x86. */
347 KLDRARCH_X86_32,
348 /** AMD64 (including clones). */
349 KLDRARCH_AMD64,
350 /** Itanic (64-bit). */
351 KLDRARCH_IA64,
352 /** ALPHA (64-bit). */
353 KLDRARCH_ALPHA,
354 /** ALPHA limited to 32-bit. */
355 KLDRARCH_ALPHA_32,
356 /** 32-bit ARM. */
357 KLDRARCH_ARM_32,
358 /** 64-bit ARM. */
359 KLDRARCH_ARM_64,
360 /** 32-bit MIPS. */
361 KLDRARCH_MIPS_32,
362 /** 64-bit MIPS. */
363 KLDRARCH_MIPS_64,
364 /** 32-bit PowerPC. */
365 KLDRARCH_POWERPC_32,
366 /** 64-bit PowerPC. */
367 KLDRARCH_POWERPC_64,
368 /** 32-bit SPARC. */
369 KLDRARCH_SPARC_32,
370 /** 64-bit SPARC. */
371 KLDRARCH_SPARC_64,
372 /** The end of the valid architecture values (exclusive). */
373 KLDRARCH_END,
374 /** Hack to blow the type up to 32-bit. */
375 KLDRARCH_32BIT_HACK = 0x7fffffff
376} KLDRARCH;
377
378/**
379 * CPU models.
380 */
381typedef enum KLDRCPU
382{
383 /** The usual invalid cpu. */
384 KLDRCPU_INVALID = 0,
385 /** @name KLDRARCH_X86_16
386 * @{ */
387 KLDRCPU_I8086,
388 KLDRCPU_I8088,
389 KLDRCPU_I80186,
390 KLDRCPU_I80286,
391 KLDRCPU_I386_16,
392 KLDRCPU_I486_16,
393 KLDRCPU_I486SX_16,
394 KLDRCPU_I586_16,
395 KLDRCPU_I686_16,
396 KLDRCPU_K6_16,
397 KLDRCPU_K7_16,
398 KLDRCPU_K8_16,
399 /** @} */
400
401 /** @name KLDRARCH_X86_32
402 * @{ */
403 KLDRCPU_I386,
404 KLDRCPU_I486,
405 KLDRCPU_I486SX,
406 KLDRCPU_I586,
407 KLDRCPU_I686,
408 KLDRCPU_P4,
409 KLDRCPU_CORE2_32,
410 KLDRCPU_K6,
411 KLDRCPU_K7,
412 KLDRCPU_K8_32,
413 /** @} */
414
415 /** @name KLDRARCH_AMD64
416 * @{ */
417 KLDRCPU_K8,
418 KLDRCPU_P4_64,
419 KLDRCPU_CORE2,
420 /** @} */
421
422 /** The end of the valid cpu values (exclusive). */
423 KLDRCPU_END,
424 /** Hack to blow the type up to 32-bit. */
425 KLDRCPU_32BIT_HACK = 0x7fffffff
426} KLDRCPU;
427
428
429/**
430 * Loader endian indicator.
431 */
432typedef enum KLDRENDIAN
433{
434 /** The usual invalid endian. */
435 KLDRENDIAN_INVALID,
436 /** Little endian. */
437 KLDRENDIAN_LITTLE,
438 /** Bit endian. */
439 KLDRENDIAN_BIG,
440 /** Endianness doesn't have a meaning in the context. */
441 KLDRENDIAN_NA,
442 /** The end of the valid endian values (exclusive). */
443 KLDRENDIAN_END,
444 /** Hack to blow the type up to 32-bit. */
445 KLDRENDIAN_32BIT_HACK = 0x7fffffff
446} KLDRENDIAN;
447
448
449/**
450 * Loader module.
451 */
452typedef struct KLDRMOD
453{
454 /** Magic number. */
455 uint32_t u32Magic;
456 /** The format of this module. */
457 KLDRFMT enmFmt;
458 /** The type of module. */
459 KLDRTYPE enmType;
460 /** The architecture this module was built for. */
461 KLDRARCH enmArch;
462 /** The minium cpu this module was built for.
463 * This might not be accurate, so use kLdrModCanExecuteOn() to check. */
464 KLDRARCH enmCpu;
465 /** The endian used by the module. */
466 KLDRENDIAN enmEndian;
467 /** The filename length (bytes). */
468 uint32_t cchFilename;
469 /** The filename. */
470 const char *pszFilename;
471 /** The module name. */
472 const char *pszName;
473 /** The module name length (bytes). */
474 uint32_t cchName;
475 /** The number of segments in the module. */
476 uint32_t cSegments;
477 /** The module data. */
478 void *pvData;
479 /** Segments. (variable size, can be zero) */
480 KLDRSEG aSegments[1];
481} KLDRMOD, *PKLDRMOD, **PPKLDRMOD;
482
483
484/** Special base address value alias for the link address. */
485#define KLDRMOD_BASEADDRESS_LINK (~(uintmax_t)1)
486/** Special base address value alias for the actual load address (must be mapped). */
487#define KLDRMOD_BASEADDRESS_MAP (~(uintmax_t)2)
488
489/** @name Load symbol kind flags.
490 * @{ */
491/** The bitness doesn't matter. */
492#define KLDRSYMKIND_NO_BIT 0x00000000
493/** 16-bit symbol. */
494#define KLDRSYMKIND_16BIT 0x00000001
495/** 32-bit symbol. */
496#define KLDRSYMKIND_32BIT 0x00000002
497/** 64-bit symbol. */
498#define KLDRSYMKIND_64BIT 0x00000003
499/** Mask out the bit.*/
500#define KLDRSYMKIND_BIT_MASK 0x00000003
501/** We don't know the type of symbol. */
502#define KLDRSYMKIND_NO_TYPE 0x00000000
503/** The symbol is a code object (method/function/procedure/whateveryouwannacallit). */
504#define KLDRSYMKIND_CODE 0x00000010
505/** The symbol is a data object. */
506#define KLDRSYMKIND_DATA 0x00000020
507/** Mask out the symbol type. */
508#define KLDRSYMKIND_TYPE_MASK 0x00000030
509/** Valid symbol kind mask. */
510#define KLDRSYMKIND_MASK 0x00000033
511/** @} */
512
513/** @name kLdrModEnumSymbols flags.
514 * @{ */
515/** Returns ALL kinds of symbols. The default is to only return public/exported symbols. */
516#define KLDRMOD_ENUM_SYMBOL_FLAGS_ALL 0x00000001
517/** @} */
518
519
520typedef int FNKLDRMODGETIMPORT(PKLDRMOD pMod, const char *pszModule, const char *pszSymbol, uint32_t uSymbol,
521 uintmax_t *pValue, uint32_t *pfKind, void *pvModuleUser, void *pvUser);
522typedef FNKLDRMODGETIMPORT *PFNKLDRMODGETIMPORT;
523typedef int FNKLDRMODENUMIMPMODS(PKLDRMOD pMod, const char *pszImpMod, unsigned fFlags, void *pvUser);
524typedef FNKLDRMODENUMIMPMODS *PFNKLDRMODENUMIMPMODS;
525typedef int FNKLDRMODENUMSYMS(PKLDRMOD pMod, const char *pszSymbol, unsigned uSymbol, uintmax_t Value, uint32_t fKind, void *pvUser);
526typedef FNKLDRMODENUMSYMS *PFNKLDRMODENUMSYMS;
527
528int kLdrModOpen(const char *pszFilename, PPKLDRMOD ppMod);
529int kLdrModClose(PKLDRMOD pMod);
530int kLdrModGetSymbol(PKLDRMOD pMod, const void *pvBits, uintmax_t BaseAddress, const char *pszSymbol, uintmax_t *pValue, uint32_t *pfKind);
531int kLdrModEnumSymbols(PKLDRMOD pMod, unsigned fFlags, const void *pvBits, uintmax_t BaseAddress, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser);
532int kLdrModEnumImportModules(PKLDRMOD pMod, unsigned fFlags, const void *pvBits, FNKLDRMODENUMIMPMODS pfnCallback, void *pvUser);
533int kLdrModMap(PKLDRMOD pMod);
534int kLdrModUnmap(PKLDRMOD pMod);
535int kLdrModFixupMapping(PKLDRMOD pMod, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
536size_t kLdrModSize(PKLDRMOD pMod);
537int kLdrModGetBits(PKLDRMOD pMod, void *pvBits, uintmax_t BaseAddress, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
538int kLdrModRelocateBits(PKLDRMOD pMod, void *pvBits, uintmax_t NewBaseAddress, uintmax_t OldBaseAddress, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
539int kLdrModCanExecuteOn(PKLDRMOD pMod, KLDRARCH enmArch, KLDRCPU enmCpu);
540
541/** @} */
542
543
544
545
546/** @defgroup grp_kLdrDyld kLdrDyld - The dynamic loader
547 * @{ */
548
549/** The handle to a dynamic loader module. */
550typedef struct KLDRDYLD *HKLDRMOD;
551/** Pointer to the handle to a dynamic loader module. */
552typedef HKLDRMOD *PHKLDRMOD;
553
554
555/**
556 * File search method.
557 *
558 * In addition to it's own way of finding files, kLdr emulates
559 * the methods employed by the most popular systems.
560 */
561typedef enum KLDRDYLDSEARCH
562{
563 /** The usual invalid file search method. */
564 KLDRDYLD_SEARCH_INVALID = 0,
565 /** Uses the kLdr file search method.
566 * @todo invent me. */
567 KLDRDYLD_SEARCH_KLDR,
568 /** Use the emulation closest to the host system. */
569 KLDRDYLD_SEARCH_HOST,
570 /** Emulate the OS/2 file search method.
571 * On non-OS/2 systems, BEGINLIBPATH, LIBPATH, ENDLIBPATH and LIBPATHSTRICT are
572 * taken form the environment. */
573 KLDRDYLD_SEARCH_OS2,
574 /** Emulate the standard window file search method. */
575 KLDRDYLD_SEARCH_WINDOWS,
576 /** Emulate the alternative window file search method. */
577 KLDRDYLD_SEARCH_WINDOWS_ALTERED,
578 /** Emulate the most common UNIX file search method. */
579 KLDRDYLD_SEARCH_UNIX_COMMON,
580} KLDRDYLDSEARCH;
581
582/** @name kLdrLoadDll flags.
583 * @{ */
584/** The symbols in the module should be loaded into the global unix namespace.
585 * If not specified, the symbols are local and can only be referenced directly. */
586#define KLDRYDLD_LOAD_FLAGS_GLOBAL_SYMBOLS 0x00000001
587/** The module shouldn't be found by a global module search.
588 * If not specified, the module can be found by unspecified module searches,
589 * typical used when loading import/dep modules. */
590#define KLDRYDLD_LOAD_FLAGS_SPECIFIC_MODULE 0x00000002
591/** @todo more to come. */
592/** @} */
593
594
595int kLdrDyldLoad(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, unsigned fFlags,
596 PHKLDRMOD phMod, char *pszErr, size_t cchErr);
597int kLdrDyldUnload(HKLDRMOD hMod);
598int kLdrDyldFindByName(const char *pszDll, PHKLDRMOD *phMod);
599int kLdrDyldFindByPC(uintptr_t PC, PHKLDRMOD *phMod, uint32_t *piSegment, uintptr_t *poffSegment);
600int kLdrDyldGetName(HKLDRMOD hMod, char *pszName, size_t cchName);
601int kLdrDyldGetFilename(HKLDRMOD hMod, char *pszName, size_t cchName);
602int kLdrDyldQuerySymbol(HKLDRMOD hMod, uint32_t uSymbolOrdinal, const char *pszSymbolName, uintptr_t *pValue, uint32_t *pfKind);
603
604/** @name OS/2 like API
605 * @{ */
606int kLdrDosLoadModule(char *pszObject, size_t cbObject, const char *pszModule, PHKLDRMOD phMod);
607int kLdrDosFreeModule(HKLDRMOD hMod);
608int kLdrDosQueryModuleHandle(const char *pszModname, PHKLDRMOD phMod);
609int kLdrDosQueryModuleName(HKLDRMOD hMod, size_t cchName, char *pszName);
610int kLdrDosQueryProcAddr(HKLDRMOD hMod, uint32_t iOrdinal, const char *pszProcName, void **ppvProcAddr);
611int kLdrDosQueryProcType(HKLDRMOD hMod, uint32_t iOrdinal, const char *pszProcName, uint32_t *pfProcType);
612int kLdrDosQueryModFromEIP(PHKLDRMOD phMod, uint32_t *piObject, size_t cbName, char *pszName, uintptr_t *poffObject, uintptr_t ulEIP);
613int kLdrDosReplaceModule(const char *pszOldModule, const char *pszNewModule, const char *pszBackupModule);
614int kLdrDosGetResource(HKLDRMOD hMod, uint32_t idType, uint32_t idName, void **pvResAddr);
615int kLdrDosQueryResourceSize(HKLDRMOD hMod, uint32_t idTypeID, uint32_t idName, uint32_t *pcb);
616int kLdrDosFreeResource(void *pvResAddr);
617/** @} */
618
619/** @name POSIX like API
620 * @{ */
621HKLDRMOD kLdrDlOpen(const char *pszLibrary, int fFlags);
622const char *kLdrDlError(void);
623void * kLdrDlSym(HKLDRMOD hMod, const char *pszSymbol);
624int kLdrDlClose(HKLDRMOD hMod);
625/** @} */
626
627/** @name Win32 like API
628 * @{ */
629HKLDRMOD kLdrWLoadLibrary(const char *pszFilename);
630HKLDRMOD kLdrWLoadLibraryEx(const char *pszFilename, void *hFileReserved, uint32_t fFlags);
631uint32_t kLdrWGetModuleFileName(HKLDRMOD hMod, char *pszModName, size_t cchModName);
632HKLDRMOD kLdrWGetModuleHandle(const char *pszFilename);
633int kLdrWGetModuleHandleEx(uint32_t fFlags, const char *pszFilename, HKLDRMOD hMod);
634void * kLdrWGetProcAddress(HKLDRMOD hMod, const char *pszProcName);
635uint32_t kLdrWGetDllDirectory(size_t cchDir, char *pszDir);
636int kLdrWSetDllDirectory(const char *pszDir);
637int kLdrWFreeLibrary(HKLDRMOD hMod);
638int kLdrWDisableThreadLibraryCalls(HKLDRMOD hMod);
639
640/** @} */
641
642
643/** @name Process Bootstrapping
644 * @{ */
645
646/**
647 * Argument package from the stub.
648 */
649typedef struct KLDREXEARGS
650{
651 /** Flags. (Currently unused, MBZ.) */
652 uint32_t fFlags;
653 /** The executable file that the stub is supposed to load. */
654 char szExecutable[260];
655 /** The LD_LIBRARY_PATH prefix for the process.. */
656 char szLibPath[4096 - 260 - sizeof(uint32_t)];
657} KLDREXEARGS, *PKLDREXEARGS;
658
659void kLdrLoadExe(PKLDREXEARGS pArgs, void *pvOS);
660
661/** @} */
662
663/** @} */
664
665
666/** @defgroup grp_kLdrErr kLdr Status Codes
667 * kLdr uses a mix of native status codes and it's own status codes.
668 * A status code of 0 means success, all other status codes means failure.
669 * @{
670 */
671#ifdef __OS2__
672# define KLDR_ERR_BASE 0x7face000
673#elif defined(__WIN__)
674# define KLDR_ERR_BASE 0x7face000
675#else
676# error "port me"
677#endif
678/** The image format is unknown. */
679#define KLDR_ERR_UNKNOWN_FORMAT (KLDR_ERR_BASE + 0)
680/** The MZ image format isn't supported by this kLdr build. */
681#define KLDR_ERR_MZ_NOT_SUPPORTED (KLDR_ERR_BASE + 1)
682/** The NE image format isn't supported by this kLdr build. */
683#define KLDR_ERR_NE_NOT_SUPPORTED (KLDR_ERR_BASE + 2)
684/** The LX image format isn't supported by this kLdr build. */
685#define KLDR_ERR_LX_NOT_SUPPORTED (KLDR_ERR_BASE + 3)
686/** The LE image format isn't supported by this kLdr build. */
687#define KLDR_ERR_LE_NOT_SUPPORTED (KLDR_ERR_BASE + 4)
688/** The PE image format isn't supported by this kLdr build. */
689#define KLDR_ERR_PE_NOT_SUPPORTED (KLDR_ERR_BASE + 5)
690/** The ELF image format isn't supported by this kLdr build. */
691#define KLDR_ERR_ELF_NOT_SUPPORTED (KLDR_ERR_BASE + 6)
692/** The mach-o image format isn't supported by this kLdr build. */
693#define KLDR_ERR_MACHO_NOT_SUPPORTED (KLDR_ERR_BASE + 7)
694/** The mach-o image format isn't supported by this kLdr build. */
695#define KLDR_ERR_AOUT_NOT_SUPPORTED (KLDR_ERR_BASE + 8)
696/** The mach-o image format isn't supported by this kLdr build. */
697#define KLDR_ERR_BAD_FIXUP (KLDR_ERR_BASE + 32)
698
699/** @} */
700
701
702#ifdef __cplusplus
703}
704#endif
705
706#endif
707
Note: See TracBrowser for help on using the repository browser.