← Back to branch summary

~ubuntu-branches/ubuntu/wily/opencollada/wily-proposed

« back to all changes in this revision

Viewing changes to Externals/LibXML/xmlmodule.c

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2015-05-14 17:23:27 UTC
  • Revision ID: package-import@ubuntu.com-20150514172327-f862u8envms01fra
Tags: upstream-0.1.0~20140703.ddf8f47+dfsg1
Import upstream version 0.1.0~20140703.ddf8f47+dfsg1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Externals/LibXML/xmlmodule.c
 
1
/*
 
2
 * xmlmodule.c : basic API for dynamic module loading added 2.6.17
 
3
 *
 
4
 * See Copyright for the status of this software.
 
5
 *
 
6
 * joelwreed@comcast.net
 
7
 *
 
8
 * http://www.fortran-2000.com/ArnaudRecipes/sharedlib.html
 
9
 */
 
10
 
 
11
#define IN_LIBXML
 
12
#include "libxml.h"
 
13
 
 
14
#include <string.h>
 
15
#include <libxml/xmlmemory.h>
 
16
#include <libxml/xmlerror.h>
 
17
#include <libxml/xmlmodule.h>
 
18
#include <libxml/globals.h>
 
19
 
 
20
#ifdef LIBXML_MODULES_ENABLED
 
21
 
 
22
struct _xmlModule {
 
23
    unsigned char *name;
 
24
    void *handle;
 
25
};
 
26
 
 
27
static void *xmlModulePlatformOpen(const char *name);
 
28
static int xmlModulePlatformClose(void *handle);
 
29
static int xmlModulePlatformSymbol(void *handle, const char *name, void **result);
 
30
 
 
31
/************************************************************************
 
32
 *                                                                      *
 
33
 *              module memory error handler                             *
 
34
 *                                                                      *
 
35
 ************************************************************************/
 
36
 
 
37
/**
 
38
 * xmlModuleErrMemory:
 
39
 * @extra:  extra information
 
40
 *
 
41
 * Handle an out of memory condition
 
42
 */
 
43
static void
 
44
xmlModuleErrMemory(xmlModulePtr module, const char *extra)
 
45
{
 
46
    const char *name = NULL;
 
47
 
 
48
    if (module != NULL) {
 
49
        name = (const char *) module->name;
 
50
    }
 
51
 
 
52
    __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_MODULE,
 
53
                    XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
 
54
                    name, NULL, 0, 0,
 
55
                    "Memory allocation failed : %s\n", extra);
 
56
}
 
57
 
 
58
/**
 
59
 * xmlModuleOpen:
 
60
 * @name: the module name
 
61
 * @options: a set of xmlModuleOption
 
62
 *
 
63
 * Opens a module/shared library given its name or path
 
64
 * TODO: options are not yet implemented.
 
65
 *
 
66
 * Returns a handle for the module or NULL in case of error
 
67
 */
 
68
xmlModulePtr
 
69
xmlModuleOpen(const char *name, int options ATTRIBUTE_UNUSED)
 
70
{
 
71
    xmlModulePtr module;
 
72
 
 
73
    module = (xmlModulePtr) xmlMalloc(sizeof(xmlModule));
 
74
    if (module == NULL) {
 
75
        xmlModuleErrMemory(NULL, "creating module");
 
76
        return (NULL);
 
77
    }
 
78
 
 
79
    memset(module, 0, sizeof(xmlModule));
 
80
 
 
81
    module->handle = xmlModulePlatformOpen(name);
 
82
 
 
83
    if (module->handle == NULL) {
 
84
        xmlFree(module);
 
85
        __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_MODULE,
 
86
                        XML_MODULE_OPEN, XML_ERR_FATAL, NULL, 0, 0,
 
87
                        name, NULL, 0, 0, "failed to open %s\n", name);
 
88
        return(NULL);
 
89
    }
 
90
 
 
91
    module->name = xmlStrdup((const xmlChar *) name);
 
92
    return (module);
 
93
}
 
94
 
 
95
/**
 
96
 * xmlModuleSymbol:
 
97
 * @module: the module
 
98
 * @name: the name of the symbol
 
99
 * @symbol: the resulting symbol address
 
100
 *
 
101
 * Lookup for a symbol address in the given module
 
102
 *
 
103
 * Returns 0 if the symbol was found, or -1 in case of error
 
104
 */
 
105
int
 
106
xmlModuleSymbol(xmlModulePtr module, const char *name, void **symbol)
 
107
{
 
108
    int rc = -1;
 
109
        
 
110
    if ((NULL == module) || (symbol == NULL)) {
 
111
        __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_MODULE,
 
112
                        XML_MODULE_OPEN, XML_ERR_FATAL, NULL, 0, 0,
 
113
                        NULL, NULL, 0, 0, "null parameter\n");
 
114
        return rc;
 
115
    }
 
116
 
 
117
    rc = xmlModulePlatformSymbol(module->handle, name, symbol);
 
118
 
 
119
    if (rc == -1) {
 
120
        __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_MODULE,
 
121
                        XML_MODULE_OPEN, XML_ERR_FATAL, NULL, 0, 0,
 
122
                        name, NULL, 0, 0,
 
123
                        "failed to find symbol: %s\n",
 
124
                        (name == NULL ? "NULL" : name));
 
125
        return rc;
 
126
    }
 
127
 
 
128
    return rc;
 
129
}
 
130
 
 
131
/**
 
132
 * xmlModuleClose:
 
133
 * @module: the module handle
 
134
 *
 
135
 * The close operations unload the associated module and free the
 
136
 * data associated to the module.
 
137
 *
 
138
 * Returns 0 in case of success, -1 in case of argument error and -2
 
139
 *         if the module could not be closed/unloaded.
 
140
 */
 
141
int
 
142
xmlModuleClose(xmlModulePtr module)
 
143
{
 
144
    int rc;
 
145
 
 
146
    if (NULL == module) {
 
147
        __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_MODULE,
 
148
                        XML_MODULE_CLOSE, XML_ERR_FATAL, NULL, 0, 0,
 
149
                        NULL, NULL, 0, 0, "null module pointer\n");
 
150
        return -1;
 
151
    }
 
152
 
 
153
    rc = xmlModulePlatformClose(module->handle);
 
154
 
 
155
    if (rc != 0) {
 
156
        __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_MODULE,
 
157
                        XML_MODULE_CLOSE, XML_ERR_FATAL, NULL, 0, 0,
 
158
                        (const char *) module->name, NULL, 0, 0,
 
159
                        "failed to close: %s\n", module->name);
 
160
        return -2;
 
161
    }
 
162
 
 
163
    rc = xmlModuleFree(module);
 
164
    return (rc);
 
165
}
 
166
 
 
167
/**
 
168
 * xmlModuleFree:
 
169
 * @module: the module handle
 
170
 *
 
171
 * The free operations free the data associated to the module
 
172
 * but does not unload the associated shared library which may still
 
173
 * be in use.
 
174
 *
 
175
 * Returns 0 in case of success, -1 in case of argument error
 
176
 */
 
177
int
 
178
xmlModuleFree(xmlModulePtr module)
 
179
{
 
180
    if (NULL == module) {
 
181
        __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_MODULE,
 
182
                        XML_MODULE_CLOSE, XML_ERR_FATAL, NULL, 0, NULL,
 
183
                        NULL, NULL, 0, 0, "null module pointer\n");
 
184
        return -1;
 
185
    }
 
186
 
 
187
    xmlFree(module->name);
 
188
    xmlFree(module);
 
189
 
 
190
    return (0);
 
191
}
 
192
 
 
193
#if defined(HAVE_DLOPEN) && !defined(_WIN32)
 
194
#ifdef HAVE_DLFCN_H
 
195
#include <dlfcn.h>
 
196
#endif
 
197
 
 
198
#ifndef RTLD_GLOBAL            /* For Tru64 UNIX 4.0 */
 
199
#define RTLD_GLOBAL 0
 
200
#endif
 
201
 
 
202
/**
 
203
 * xmlModulePlatformOpen:
 
204
 * @name: path to the module
 
205
 *
 
206
 * returns a handle on success, and zero on error.
 
207
 */
 
208
 
 
209
static void *
 
210
xmlModulePlatformOpen(const char *name)
 
211
{
 
212
    return dlopen(name, RTLD_GLOBAL | RTLD_NOW);
 
213
}
 
214
 
 
215
/*
 
216
 * xmlModulePlatformClose:
 
217
 * @handle: handle to the module
 
218
 *
 
219
 * returns 0 on success, and non-zero on error.
 
220
 */
 
221
 
 
222
static int
 
223
xmlModulePlatformClose(void *handle)
 
224
{
 
225
    return dlclose(handle);
 
226
}
 
227
 
 
228
/*
 
229
 * xmlModulePlatformSymbol:
 
230
 * http://www.opengroup.org/onlinepubs/009695399/functions/dlsym.html
 
231
 * returns 0 on success and the loaded symbol in result, and -1 on error.
 
232
 */
 
233
 
 
234
static int
 
235
xmlModulePlatformSymbol(void *handle, const char *name, void **symbol)
 
236
{
 
237
    *symbol = dlsym(handle, name);
 
238
    if (dlerror() != NULL) {
 
239
        return -1;
 
240
    }
 
241
    return 0;
 
242
}
 
243
 
 
244
#else /* ! HAVE_DLOPEN */
 
245
 
 
246
#ifdef HAVE_SHLLOAD             /* HAVE_SHLLOAD */
 
247
#ifdef HAVE_DL_H
 
248
#include <dl.h>
 
249
#endif
 
250
/*
 
251
 * xmlModulePlatformOpen:
 
252
 * returns a handle on success, and zero on error.
 
253
 */
 
254
 
 
255
static void *
 
256
xmlModulePlatformOpen(const char *name)
 
257
{
 
258
    return shl_load(name, BIND_IMMEDIATE, 0L);
 
259
}
 
260
 
 
261
/*
 
262
 * xmlModulePlatformClose:
 
263
 * returns 0 on success, and non-zero on error.
 
264
 */
 
265
 
 
266
static int
 
267
xmlModulePlatformClose(void *handle)
 
268
{
 
269
    return shl_unload(handle);
 
270
}
 
271
 
 
272
/*
 
273
 * xmlModulePlatformSymbol:
 
274
 * http://docs.hp.com/en/B2355-90683/shl_load.3X.html
 
275
 * returns 0 on success and the loaded symbol in result, and -1 on error.
 
276
 */
 
277
 
 
278
static int
 
279
xmlModulePlatformSymbol(void *handle, const char *name, void **symbol)
 
280
{
 
281
    int rc;
 
282
 
 
283
    errno = 0;
 
284
    rc = shl_findsym(&handle, name, TYPE_UNDEFINED, symbol);
 
285
    return rc;
 
286
}
 
287
 
 
288
#endif /* HAVE_SHLLOAD */
 
289
#endif /* ! HAVE_DLOPEN */
 
290
 
 
291
#ifdef _WIN32
 
292
 
 
293
#include <windows.h>
 
294
 
 
295
/*
 
296
 * xmlModulePlatformOpen:
 
297
 * returns a handle on success, and zero on error.
 
298
 */
 
299
 
 
300
static void *
 
301
xmlModulePlatformOpen(const char *name)
 
302
{
 
303
    return LoadLibrary(name);
 
304
}
 
305
 
 
306
/*
 
307
 * xmlModulePlatformClose:
 
308
 * returns 0 on success, and non-zero on error.
 
309
 */
 
310
 
 
311
static int
 
312
xmlModulePlatformClose(void *handle)
 
313
{
 
314
    int rc;
 
315
 
 
316
    rc = FreeLibrary(handle);
 
317
    return (0 == rc);
 
318
}
 
319
 
 
320
/*
 
321
 * xmlModulePlatformSymbol:
 
322
 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dllproc/base/getprocaddress.asp
 
323
 * returns 0 on success and the loaded symbol in result, and -1 on error.
 
324
 */
 
325
 
 
326
static int
 
327
xmlModulePlatformSymbol(void *handle, const char *name, void **symbol)
 
328
{
 
329
    *symbol = GetProcAddress(handle, name);
 
330
    return (NULL == *symbol) ? -1 : 0;
 
331
}
 
332
 
 
333
#endif /* _WIN32 */
 
334
 
 
335
#ifdef HAVE_BEOS
 
336
 
 
337
#include <kernel/image.h>
 
338
 
 
339
/*
 
340
 * xmlModulePlatformOpen:
 
341
 * beos api info: http://www.beunited.org/bebook/The%20Kernel%20Kit/Images.html
 
342
 * returns a handle on success, and zero on error.
 
343
 */
 
344
 
 
345
static void *
 
346
xmlModulePlatformOpen(const char *name)
 
347
{
 
348
    return (void *) load_add_on(name);
 
349
}
 
350
 
 
351
/*
 
352
 * xmlModulePlatformClose:
 
353
 * beos api info: http://www.beunited.org/bebook/The%20Kernel%20Kit/Images.html
 
354
 * returns 0 on success, and non-zero on error.
 
355
 */
 
356
 
 
357
static int
 
358
xmlModulePlatformClose(void *handle)
 
359
{
 
360
    status_t rc;
 
361
 
 
362
    rc = unload_add_on((image_id) handle);
 
363
 
 
364
    if (rc == B_OK)
 
365
        return 0;
 
366
    else
 
367
        return -1;
 
368
}
 
369
 
 
370
/*
 
371
 * xmlModulePlatformSymbol:
 
372
 * beos api info: http://www.beunited.org/bebook/The%20Kernel%20Kit/Images.html
 
373
 * returns 0 on success and the loaded symbol in result, and -1 on error.
 
374
 */
 
375
 
 
376
static int
 
377
xmlModulePlatformSymbol(void *handle, const char *name, void **symbol)
 
378
{
 
379
    status_t rc;
 
380
 
 
381
    rc = get_image_symbol((image_id) handle, name, B_SYMBOL_TYPE_ANY, symbol);
 
382
 
 
383
    return (rc == B_OK) ? 0 : -1;
 
384
}
 
385
 
 
386
#endif /* HAVE_BEOS */
 
387
 
 
388
#ifdef HAVE_OS2
 
389
 
 
390
#include <os2.h>
 
391
 
 
392
/*
 
393
 * xmlModulePlatformOpen:
 
394
 * os2 api info: http://www.edm2.com/os2api/Dos/DosLoadModule.html
 
395
 * returns a handle on success, and zero on error.
 
396
 */
 
397
 
 
398
static void *
 
399
xmlModulePlatformOpen(const char *name)
 
400
{
 
401
    char errbuf[256];
 
402
    void *handle;
 
403
    int rc;
 
404
 
 
405
    rc = DosLoadModule(errbuf, sizeof(errbuf) - 1, name, &handle);
 
406
 
 
407
    if (rc)
 
408
        return 0;
 
409
    else
 
410
        return (handle);
 
411
}
 
412
 
 
413
/*
 
414
 * xmlModulePlatformClose:
 
415
 * os2 api info: http://www.edm2.com/os2api/Dos/DosFreeModule.html
 
416
 * returns 0 on success, and non-zero on error.
 
417
 */
 
418
 
 
419
static int
 
420
xmlModulePlatformClose(void *handle)
 
421
{
 
422
    return DosFreeModule(handle);
 
423
}
 
424
 
 
425
/*
 
426
 * xmlModulePlatformSymbol:
 
427
 * os2 api info: http://www.edm2.com/os2api/Dos/DosQueryProcAddr.html
 
428
 * returns 0 on success and the loaded symbol in result, and -1 on error.
 
429
 */
 
430
 
 
431
static int
 
432
xmlModulePlatformSymbol(void *handle, const char *name, void **symbol)
 
433
{
 
434
    int rc;
 
435
 
 
436
    rc = DosQueryProcAddr(handle, 0, name, symbol);
 
437
 
 
438
    return (rc == NO_ERROR) ? 0 : -1;
 
439
}
 
440
 
 
441
#endif /* HAVE_OS2 */
 
442
 
 
443
#define bottom_xmlmodule
 
444
#include "elfgcchack.h"
 
445
#endif /* LIBXML_MODULES_ENABLED */