← Back to branch summary

~ubuntu-branches/ubuntu/wily/libxml2/wily-proposed

« back to all changes in this revision

Viewing changes to .pc/0003-Fix-a-thread-portability-problem.patch/threads.c

  • Committer: Package Import Robot
  • Author(s): Marc Deslauriers
  • Date: 2013-07-11 09:31:50 UTC
  • mfrom: (43.2.4 sid)
  • Revision ID: package-import@ubuntu.com-20130711093150-t3vcnrpfqepqt0mp
Tags: 2.9.1+dfsg1-2ubuntu1
* Merged from Debian unstable. Remaining changes:
  - Fix python multi-arch includes issues. 
  - Allow the package to cross-build.
  - Set PYTHON_LIBS for cross builds.
  - Remove explicit build dependency on binutils.
  - Configure the udeb --without-python.
* Dropped patches:
  - CVE-2013-0338.patch: upstream
  - CVE-2013-1969.patch: upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/0003-Fix-a-thread-portability-problem.patch/threads.c
1
 
/**
2
 
 * threads.c: set of generic threading related routines
3
 
 *
4
 
 * See Copyright for the status of this software.
5
 
 *
6
 
 * Gary Pennington <Gary.Pennington@uk.sun.com>
7
 
 * daniel@veillard.com
8
 
 */
9
 
 
10
 
#define IN_LIBXML
11
 
#include "libxml.h"
12
 
 
13
 
#include <string.h>
14
 
 
15
 
#include <libxml/threads.h>
16
 
#include <libxml/globals.h>
17
 
 
18
 
#ifdef HAVE_SYS_TYPES_H
19
 
#include <sys/types.h>
20
 
#endif
21
 
#ifdef HAVE_UNISTD_H
22
 
#include <unistd.h>
23
 
#endif
24
 
#ifdef HAVE_STDLIB_H
25
 
#include <stdlib.h>
26
 
#endif
27
 
#ifdef HAVE_PTHREAD_H
28
 
#include <pthread.h>
29
 
#elif defined HAVE_WIN32_THREADS
30
 
#include <windows.h>
31
 
#ifndef HAVE_COMPILER_TLS
32
 
#include <process.h>
33
 
#endif
34
 
#endif
35
 
 
36
 
#ifdef HAVE_BEOS_THREADS
37
 
#include <OS.h>
38
 
#include <TLS.h>
39
 
#endif
40
 
 
41
 
#if defined(SOLARIS)
42
 
#include <note.h>
43
 
#endif
44
 
 
45
 
/* #define DEBUG_THREADS */
46
 
 
47
 
#ifdef HAVE_PTHREAD_H
48
 
 
49
 
static int libxml_is_threaded = -1;
50
 
#ifdef __GNUC__
51
 
#ifdef linux
52
 
#if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || (__GNUC__ > 3)
53
 
extern int pthread_once (pthread_once_t *__once_control,
54
 
                         void (*__init_routine) (void))
55
 
           __attribute((weak));
56
 
extern void *pthread_getspecific (pthread_key_t __key)
57
 
           __attribute((weak));
58
 
extern int pthread_setspecific (pthread_key_t __key,
59
 
                                __const void *__pointer)
60
 
           __attribute((weak));
61
 
extern int pthread_key_create (pthread_key_t *__key,
62
 
                               void (*__destr_function) (void *))
63
 
           __attribute((weak));
64
 
extern int pthread_key_delete (pthread_key_t __key)
65
 
           __attribute((weak));
66
 
extern int pthread_mutex_init ()
67
 
           __attribute((weak));
68
 
extern int pthread_mutex_destroy ()
69
 
           __attribute((weak));
70
 
extern int pthread_mutex_lock ()
71
 
           __attribute((weak));
72
 
extern int pthread_mutex_unlock ()
73
 
           __attribute((weak));
74
 
extern int pthread_cond_init ()
75
 
           __attribute((weak));
76
 
extern int pthread_cond_destroy ()
77
 
           __attribute((weak));
78
 
extern int pthread_cond_wait ()
79
 
           __attribute((weak));
80
 
extern int pthread_equal ()
81
 
           __attribute((weak));
82
 
extern pthread_t pthread_self ()
83
 
           __attribute((weak));
84
 
extern int pthread_key_create ()
85
 
           __attribute((weak));
86
 
extern int pthread_key_delete ()
87
 
           __attribute((weak));
88
 
extern int pthread_cond_signal ()
89
 
           __attribute((weak));
90
 
#endif
91
 
#endif /* linux */
92
 
#endif /* __GNUC__ */
93
 
#endif /* HAVE_PTHREAD_H */
94
 
 
95
 
/*
96
 
 * TODO: this module still uses malloc/free and not xmlMalloc/xmlFree
97
 
 *       to avoid some crazyness since xmlMalloc/xmlFree may actually
98
 
 *       be hosted on allocated blocks needing them for the allocation ...
99
 
 */
100
 
 
101
 
/*
102
 
 * xmlMutex are a simple mutual exception locks
103
 
 */
104
 
struct _xmlMutex {
105
 
#ifdef HAVE_PTHREAD_H
106
 
    pthread_mutex_t lock;
107
 
#elif defined HAVE_WIN32_THREADS
108
 
    HANDLE mutex;
109
 
#elif defined HAVE_BEOS_THREADS
110
 
    sem_id sem;
111
 
    thread_id tid;
112
 
#else
113
 
    int empty;
114
 
#endif
115
 
};
116
 
 
117
 
/*
118
 
 * xmlRMutex are reentrant mutual exception locks
119
 
 */
120
 
struct _xmlRMutex {
121
 
#ifdef HAVE_PTHREAD_H
122
 
    pthread_mutex_t lock;
123
 
    unsigned int held;
124
 
    unsigned int waiters;
125
 
    pthread_t tid;
126
 
    pthread_cond_t cv;
127
 
#elif defined HAVE_WIN32_THREADS
128
 
    CRITICAL_SECTION cs;
129
 
    unsigned int count;
130
 
#elif defined HAVE_BEOS_THREADS
131
 
    xmlMutexPtr lock;
132
 
    thread_id tid;
133
 
    int32 count;
134
 
#else
135
 
    int empty;
136
 
#endif
137
 
};
138
 
 
139
 
/*
140
 
 * This module still has some internal static data.
141
 
 *   - xmlLibraryLock a global lock
142
 
 *   - globalkey used for per-thread data
143
 
 */
144
 
 
145
 
#ifdef HAVE_PTHREAD_H
146
 
static pthread_key_t globalkey;
147
 
static pthread_t mainthread;
148
 
static pthread_once_t once_control = PTHREAD_ONCE_INIT;
149
 
static pthread_mutex_t global_init_lock = PTHREAD_MUTEX_INITIALIZER;
150
 
#elif defined HAVE_WIN32_THREADS
151
 
#if defined(HAVE_COMPILER_TLS)
152
 
static __declspec(thread) xmlGlobalState tlstate;
153
 
static __declspec(thread) int tlstate_inited = 0;
154
 
#else /* HAVE_COMPILER_TLS */
155
 
static DWORD globalkey = TLS_OUT_OF_INDEXES;
156
 
#endif /* HAVE_COMPILER_TLS */
157
 
static DWORD mainthread;
158
 
static struct {
159
 
    DWORD done;
160
 
    DWORD control;
161
 
} run_once = { 0, 0};
162
 
static volatile LPCRITICAL_SECTION global_init_lock = NULL;
163
 
 
164
 
/* endif HAVE_WIN32_THREADS */
165
 
#elif defined HAVE_BEOS_THREADS
166
 
int32 globalkey = 0;
167
 
thread_id mainthread = 0;
168
 
int32 run_once_init = 0;
169
 
static int32 global_init_lock = -1;
170
 
static vint32 global_init_count = 0;
171
 
#endif
172
 
 
173
 
static xmlRMutexPtr xmlLibraryLock = NULL;
174
 
 
175
 
#ifdef LIBXML_THREAD_ENABLED
176
 
static void xmlOnceInit(void);
177
 
#endif
178
 
 
179
 
/**
180
 
 * xmlNewMutex:
181
 
 *
182
 
 * xmlNewMutex() is used to allocate a libxml2 token struct for use in
183
 
 * synchronizing access to data.
184
 
 *
185
 
 * Returns a new simple mutex pointer or NULL in case of error
186
 
 */
187
 
xmlMutexPtr
188
 
xmlNewMutex(void)
189
 
{
190
 
    xmlMutexPtr tok;
191
 
 
192
 
    if ((tok = malloc(sizeof(xmlMutex))) == NULL)
193
 
        return (NULL);
194
 
#ifdef HAVE_PTHREAD_H
195
 
    if (libxml_is_threaded != 0)
196
 
        pthread_mutex_init(&tok->lock, NULL);
197
 
#elif defined HAVE_WIN32_THREADS
198
 
    tok->mutex = CreateMutex(NULL, FALSE, NULL);
199
 
#elif defined HAVE_BEOS_THREADS
200
 
    if ((tok->sem = create_sem(1, "xmlMutex")) < B_OK) {
201
 
        free(tok);
202
 
        return NULL;
203
 
    }
204
 
    tok->tid = -1;
205
 
#endif
206
 
    return (tok);
207
 
}
208
 
 
209
 
/**
210
 
 * xmlFreeMutex:
211
 
 * @tok:  the simple mutex
212
 
 *
213
 
 * xmlFreeMutex() is used to reclaim resources associated with a libxml2 token
214
 
 * struct.
215
 
 */
216
 
void
217
 
xmlFreeMutex(xmlMutexPtr tok)
218
 
{
219
 
    if (tok == NULL)
220
 
        return;
221
 
 
222
 
#ifdef HAVE_PTHREAD_H
223
 
    if (libxml_is_threaded != 0)
224
 
        pthread_mutex_destroy(&tok->lock);
225
 
#elif defined HAVE_WIN32_THREADS
226
 
    CloseHandle(tok->mutex);
227
 
#elif defined HAVE_BEOS_THREADS
228
 
    delete_sem(tok->sem);
229
 
#endif
230
 
    free(tok);
231
 
}
232
 
 
233
 
/**
234
 
 * xmlMutexLock:
235
 
 * @tok:  the simple mutex
236
 
 *
237
 
 * xmlMutexLock() is used to lock a libxml2 token.
238
 
 */
239
 
void
240
 
xmlMutexLock(xmlMutexPtr tok)
241
 
{
242
 
    if (tok == NULL)
243
 
        return;
244
 
#ifdef HAVE_PTHREAD_H
245
 
    if (libxml_is_threaded != 0)
246
 
        pthread_mutex_lock(&tok->lock);
247
 
#elif defined HAVE_WIN32_THREADS
248
 
    WaitForSingleObject(tok->mutex, INFINITE);
249
 
#elif defined HAVE_BEOS_THREADS
250
 
    if (acquire_sem(tok->sem) != B_NO_ERROR) {
251
 
#ifdef DEBUG_THREADS
252
 
        xmlGenericError(xmlGenericErrorContext,
253
 
                        "xmlMutexLock():BeOS:Couldn't aquire semaphore\n");
254
 
        exit();
255
 
#endif
256
 
    }
257
 
    tok->tid = find_thread(NULL);
258
 
#endif
259
 
 
260
 
}
261
 
 
262
 
/**
263
 
 * xmlMutexUnlock:
264
 
 * @tok:  the simple mutex
265
 
 *
266
 
 * xmlMutexUnlock() is used to unlock a libxml2 token.
267
 
 */
268
 
void
269
 
xmlMutexUnlock(xmlMutexPtr tok)
270
 
{
271
 
    if (tok == NULL)
272
 
        return;
273
 
#ifdef HAVE_PTHREAD_H
274
 
    if (libxml_is_threaded != 0)
275
 
        pthread_mutex_unlock(&tok->lock);
276
 
#elif defined HAVE_WIN32_THREADS
277
 
    ReleaseMutex(tok->mutex);
278
 
#elif defined HAVE_BEOS_THREADS
279
 
    if (tok->tid == find_thread(NULL)) {
280
 
        tok->tid = -1;
281
 
        release_sem(tok->sem);
282
 
    }
283
 
#endif
284
 
}
285
 
 
286
 
/**
287
 
 * xmlNewRMutex:
288
 
 *
289
 
 * xmlRNewMutex() is used to allocate a reentrant mutex for use in
290
 
 * synchronizing access to data. token_r is a re-entrant lock and thus useful
291
 
 * for synchronizing access to data structures that may be manipulated in a
292
 
 * recursive fashion.
293
 
 *
294
 
 * Returns the new reentrant mutex pointer or NULL in case of error
295
 
 */
296
 
xmlRMutexPtr
297
 
xmlNewRMutex(void)
298
 
{
299
 
    xmlRMutexPtr tok;
300
 
 
301
 
    if ((tok = malloc(sizeof(xmlRMutex))) == NULL)
302
 
        return (NULL);
303
 
#ifdef HAVE_PTHREAD_H
304
 
    if (libxml_is_threaded != 0) {
305
 
        pthread_mutex_init(&tok->lock, NULL);
306
 
        tok->held = 0;
307
 
        tok->waiters = 0;
308
 
        pthread_cond_init(&tok->cv, NULL);
309
 
    }
310
 
#elif defined HAVE_WIN32_THREADS
311
 
    InitializeCriticalSection(&tok->cs);
312
 
    tok->count = 0;
313
 
#elif defined HAVE_BEOS_THREADS
314
 
    if ((tok->lock = xmlNewMutex()) == NULL) {
315
 
        free(tok);
316
 
        return NULL;
317
 
    }
318
 
    tok->count = 0;
319
 
#endif
320
 
    return (tok);
321
 
}
322
 
 
323
 
/**
324
 
 * xmlFreeRMutex:
325
 
 * @tok:  the reentrant mutex
326
 
 *
327
 
 * xmlRFreeMutex() is used to reclaim resources associated with a
328
 
 * reentrant mutex.
329
 
 */
330
 
void
331
 
xmlFreeRMutex(xmlRMutexPtr tok ATTRIBUTE_UNUSED)
332
 
{
333
 
    if (tok == NULL)
334
 
        return;
335
 
#ifdef HAVE_PTHREAD_H
336
 
    if (libxml_is_threaded != 0) {
337
 
        pthread_mutex_destroy(&tok->lock);
338
 
        pthread_cond_destroy(&tok->cv);
339
 
    }
340
 
#elif defined HAVE_WIN32_THREADS
341
 
    DeleteCriticalSection(&tok->cs);
342
 
#elif defined HAVE_BEOS_THREADS
343
 
    xmlFreeMutex(tok->lock);
344
 
#endif
345
 
    free(tok);
346
 
}
347
 
 
348
 
/**
349
 
 * xmlRMutexLock:
350
 
 * @tok:  the reentrant mutex
351
 
 *
352
 
 * xmlRMutexLock() is used to lock a libxml2 token_r.
353
 
 */
354
 
void
355
 
xmlRMutexLock(xmlRMutexPtr tok)
356
 
{
357
 
    if (tok == NULL)
358
 
        return;
359
 
#ifdef HAVE_PTHREAD_H
360
 
    if (libxml_is_threaded == 0)
361
 
        return;
362
 
 
363
 
    pthread_mutex_lock(&tok->lock);
364
 
    if (tok->held) {
365
 
        if (pthread_equal(tok->tid, pthread_self())) {
366
 
            tok->held++;
367
 
            pthread_mutex_unlock(&tok->lock);
368
 
            return;
369
 
        } else {
370
 
            tok->waiters++;
371
 
            while (tok->held)
372
 
                pthread_cond_wait(&tok->cv, &tok->lock);
373
 
            tok->waiters--;
374
 
        }
375
 
    }
376
 
    tok->tid = pthread_self();
377
 
    tok->held = 1;
378
 
    pthread_mutex_unlock(&tok->lock);
379
 
#elif defined HAVE_WIN32_THREADS
380
 
    EnterCriticalSection(&tok->cs);
381
 
    ++tok->count;
382
 
#elif defined HAVE_BEOS_THREADS
383
 
    if (tok->lock->tid == find_thread(NULL)) {
384
 
        tok->count++;
385
 
        return;
386
 
    } else {
387
 
        xmlMutexLock(tok->lock);
388
 
        tok->count = 1;
389
 
    }
390
 
#endif
391
 
}
392
 
 
393
 
/**
394
 
 * xmlRMutexUnlock:
395
 
 * @tok:  the reentrant mutex
396
 
 *
397
 
 * xmlRMutexUnlock() is used to unlock a libxml2 token_r.
398
 
 */
399
 
void
400
 
xmlRMutexUnlock(xmlRMutexPtr tok ATTRIBUTE_UNUSED)
401
 
{
402
 
    if (tok == NULL)
403
 
        return;
404
 
#ifdef HAVE_PTHREAD_H
405
 
    if (libxml_is_threaded == 0)
406
 
        return;
407
 
 
408
 
    pthread_mutex_lock(&tok->lock);
409
 
    tok->held--;
410
 
    if (tok->held == 0) {
411
 
        if (tok->waiters)
412
 
            pthread_cond_signal(&tok->cv);
413
 
        memset(&tok->tid, 0, sizeof(tok->tid));
414
 
    }
415
 
    pthread_mutex_unlock(&tok->lock);
416
 
#elif defined HAVE_WIN32_THREADS
417
 
    if (!--tok->count)
418
 
        LeaveCriticalSection(&tok->cs);
419
 
#elif defined HAVE_BEOS_THREADS
420
 
    if (tok->lock->tid == find_thread(NULL)) {
421
 
        tok->count--;
422
 
        if (tok->count == 0) {
423
 
            xmlMutexUnlock(tok->lock);
424
 
        }
425
 
        return;
426
 
    }
427
 
#endif
428
 
}
429
 
 
430
 
/**
431
 
 * xmlGlobalInitMutexLock
432
 
 *
433
 
 * Makes sure that the global initialization mutex is initialized and
434
 
 * locks it.
435
 
 */
436
 
void
437
 
__xmlGlobalInitMutexLock(void)
438
 
{
439
 
    /* Make sure the global init lock is initialized and then lock it. */
440
 
#ifdef HAVE_PTHREAD_H
441
 
    /* The mutex is statically initialized, so we just lock it. */
442
 
    if (pthread_mutex_lock != NULL)
443
 
        pthread_mutex_lock(&global_init_lock);
444
 
#elif defined HAVE_WIN32_THREADS
445
 
    LPCRITICAL_SECTION cs;
446
 
 
447
 
    /* Create a new critical section */
448
 
    if (global_init_lock == NULL) {
449
 
        cs = malloc(sizeof(CRITICAL_SECTION));
450
 
        if (cs == NULL) {
451
 
            xmlGenericError(xmlGenericErrorContext,
452
 
                            "xmlGlobalInitMutexLock: out of memory\n");
453
 
            return;
454
 
        }
455
 
        InitializeCriticalSection(cs);
456
 
 
457
 
        /* Swap it into the global_init_lock */
458
 
#ifdef InterlockedCompareExchangePointer
459
 
        InterlockedCompareExchangePointer(&global_init_lock, cs, NULL);
460
 
#else /* Use older void* version */
461
 
        InterlockedCompareExchange((void **) &global_init_lock,
462
 
                                   (void *) cs, NULL);
463
 
#endif /* InterlockedCompareExchangePointer */
464
 
 
465
 
        /* If another thread successfully recorded its critical
466
 
         * section in the global_init_lock then discard the one
467
 
         * allocated by this thread. */
468
 
        if (global_init_lock != cs) {
469
 
            DeleteCriticalSection(cs);
470
 
            free(cs);
471
 
        }
472
 
    }
473
 
 
474
 
    /* Lock the chosen critical section */
475
 
    EnterCriticalSection(global_init_lock);
476
 
#elif defined HAVE_BEOS_THREADS
477
 
    int32 sem;
478
 
 
479
 
    /* Allocate a new semaphore */
480
 
    sem = create_sem(1, "xmlGlobalinitMutex");
481
 
 
482
 
    while (global_init_lock == -1) {
483
 
        if (atomic_add(&global_init_count, 1) == 0) {
484
 
            global_init_lock = sem;
485
 
        } else {
486
 
            snooze(1);
487
 
            atomic_add(&global_init_count, -1);
488
 
        }
489
 
    }
490
 
 
491
 
    /* If another thread successfully recorded its critical
492
 
     * section in the global_init_lock then discard the one
493
 
     * allocated by this thread. */
494
 
    if (global_init_lock != sem)
495
 
        delete_sem(sem);
496
 
 
497
 
    /* Acquire the chosen semaphore */
498
 
    if (acquire_sem(global_init_lock) != B_NO_ERROR) {
499
 
#ifdef DEBUG_THREADS
500
 
        xmlGenericError(xmlGenericErrorContext,
501
 
                        "xmlGlobalInitMutexLock():BeOS:Couldn't acquire semaphore\n");
502
 
        exit();
503
 
#endif
504
 
    }
505
 
#endif
506
 
}
507
 
 
508
 
void
509
 
__xmlGlobalInitMutexUnlock(void)
510
 
{
511
 
#ifdef HAVE_PTHREAD_H
512
 
    if (pthread_mutex_unlock != NULL)
513
 
        pthread_mutex_unlock(&global_init_lock);
514
 
#elif defined HAVE_WIN32_THREADS
515
 
    if (global_init_lock != NULL) {
516
 
        LeaveCriticalSection(global_init_lock);
517
 
    }
518
 
#elif defined HAVE_BEOS_THREADS
519
 
    release_sem(global_init_lock);
520
 
#endif
521
 
}
522
 
 
523
 
/**
524
 
 * xmlGlobalInitMutexDestroy
525
 
 *
526
 
 * Makes sure that the global initialization mutex is destroyed before
527
 
 * application termination.
528
 
 */
529
 
void
530
 
__xmlGlobalInitMutexDestroy(void)
531
 
{
532
 
#ifdef HAVE_PTHREAD_H
533
 
#elif defined HAVE_WIN32_THREADS
534
 
    if (global_init_lock != NULL) {
535
 
        DeleteCriticalSection(global_init_lock);
536
 
        free(global_init_lock);
537
 
        global_init_lock = NULL;
538
 
    }
539
 
#endif
540
 
}
541
 
 
542
 
/************************************************************************
543
 
 *                                                                      *
544
 
 *                      Per thread global state handling                *
545
 
 *                                                                      *
546
 
 ************************************************************************/
547
 
 
548
 
#ifdef LIBXML_THREAD_ENABLED
549
 
#ifdef xmlLastError
550
 
#undef xmlLastError
551
 
#endif
552
 
 
553
 
/**
554
 
 * xmlFreeGlobalState:
555
 
 * @state:  a thread global state
556
 
 *
557
 
 * xmlFreeGlobalState() is called when a thread terminates with a non-NULL
558
 
 * global state. It is is used here to reclaim memory resources.
559
 
 */
560
 
static void
561
 
xmlFreeGlobalState(void *state)
562
 
{
563
 
    xmlGlobalState *gs = (xmlGlobalState *) state;
564
 
 
565
 
    /* free any memory allocated in the thread's xmlLastError */
566
 
    xmlResetError(&(gs->xmlLastError));
567
 
    free(state);
568
 
}
569
 
 
570
 
/**
571
 
 * xmlNewGlobalState:
572
 
 *
573
 
 * xmlNewGlobalState() allocates a global state. This structure is used to
574
 
 * hold all data for use by a thread when supporting backwards compatibility
575
 
 * of libxml2 to pre-thread-safe behaviour.
576
 
 *
577
 
 * Returns the newly allocated xmlGlobalStatePtr or NULL in case of error
578
 
 */
579
 
static xmlGlobalStatePtr
580
 
xmlNewGlobalState(void)
581
 
{
582
 
    xmlGlobalState *gs;
583
 
 
584
 
    gs = malloc(sizeof(xmlGlobalState));
585
 
    if (gs == NULL) {
586
 
        xmlGenericError(xmlGenericErrorContext,
587
 
                        "xmlGetGlobalState: out of memory\n");
588
 
        return (NULL);
589
 
    }
590
 
 
591
 
    memset(gs, 0, sizeof(xmlGlobalState));
592
 
    xmlInitializeGlobalState(gs);
593
 
    return (gs);
594
 
}
595
 
#endif /* LIBXML_THREAD_ENABLED */
596
 
 
597
 
#ifdef HAVE_PTHREAD_H
598
 
#elif defined HAVE_WIN32_THREADS
599
 
#if !defined(HAVE_COMPILER_TLS)
600
 
#if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL)
601
 
typedef struct _xmlGlobalStateCleanupHelperParams {
602
 
    HANDLE thread;
603
 
    void *memory;
604
 
} xmlGlobalStateCleanupHelperParams;
605
 
 
606
 
static void XMLCDECL
607
 
xmlGlobalStateCleanupHelper(void *p)
608
 
{
609
 
    xmlGlobalStateCleanupHelperParams *params =
610
 
        (xmlGlobalStateCleanupHelperParams *) p;
611
 
    WaitForSingleObject(params->thread, INFINITE);
612
 
    CloseHandle(params->thread);
613
 
    xmlFreeGlobalState(params->memory);
614
 
    free(params);
615
 
    _endthread();
616
 
}
617
 
#else /* LIBXML_STATIC && !LIBXML_STATIC_FOR_DLL */
618
 
 
619
 
typedef struct _xmlGlobalStateCleanupHelperParams {
620
 
    void *memory;
621
 
    struct _xmlGlobalStateCleanupHelperParams *prev;
622
 
    struct _xmlGlobalStateCleanupHelperParams *next;
623
 
} xmlGlobalStateCleanupHelperParams;
624
 
 
625
 
static xmlGlobalStateCleanupHelperParams *cleanup_helpers_head = NULL;
626
 
static CRITICAL_SECTION cleanup_helpers_cs;
627
 
 
628
 
#endif /* LIBXMLSTATIC && !LIBXML_STATIC_FOR_DLL */
629
 
#endif /* HAVE_COMPILER_TLS */
630
 
#endif /* HAVE_WIN32_THREADS */
631
 
 
632
 
#if defined HAVE_BEOS_THREADS
633
 
 
634
 
/**
635
 
 * xmlGlobalStateCleanup:
636
 
 * @data: unused parameter
637
 
 *
638
 
 * Used for Beos only
639
 
 */
640
 
void
641
 
xmlGlobalStateCleanup(void *data)
642
 
{
643
 
    void *globalval = tls_get(globalkey);
644
 
 
645
 
    if (globalval != NULL)
646
 
        xmlFreeGlobalState(globalval);
647
 
}
648
 
#endif
649
 
 
650
 
/**
651
 
 * xmlGetGlobalState:
652
 
 *
653
 
 * xmlGetGlobalState() is called to retrieve the global state for a thread.
654
 
 *
655
 
 * Returns the thread global state or NULL in case of error
656
 
 */
657
 
xmlGlobalStatePtr
658
 
xmlGetGlobalState(void)
659
 
{
660
 
#ifdef HAVE_PTHREAD_H
661
 
    xmlGlobalState *globalval;
662
 
 
663
 
    if (libxml_is_threaded == 0)
664
 
        return (NULL);
665
 
 
666
 
    pthread_once(&once_control, xmlOnceInit);
667
 
 
668
 
    if ((globalval = (xmlGlobalState *)
669
 
         pthread_getspecific(globalkey)) == NULL) {
670
 
        xmlGlobalState *tsd = xmlNewGlobalState();
671
 
        if (tsd == NULL)
672
 
            return(NULL);
673
 
 
674
 
        pthread_setspecific(globalkey, tsd);
675
 
        return (tsd);
676
 
    }
677
 
    return (globalval);
678
 
#elif defined HAVE_WIN32_THREADS
679
 
#if defined(HAVE_COMPILER_TLS)
680
 
    if (!tlstate_inited) {
681
 
        tlstate_inited = 1;
682
 
        xmlInitializeGlobalState(&tlstate);
683
 
    }
684
 
    return &tlstate;
685
 
#else /* HAVE_COMPILER_TLS */
686
 
    xmlGlobalState *globalval;
687
 
    xmlGlobalStateCleanupHelperParams *p;
688
 
 
689
 
    xmlOnceInit();
690
 
#if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL)
691
 
    globalval = (xmlGlobalState *) TlsGetValue(globalkey);
692
 
#else
693
 
    p = (xmlGlobalStateCleanupHelperParams *) TlsGetValue(globalkey);
694
 
    globalval = (xmlGlobalState *) (p ? p->memory : NULL);
695
 
#endif
696
 
    if (globalval == NULL) {
697
 
        xmlGlobalState *tsd = xmlNewGlobalState();
698
 
 
699
 
        if (tsd == NULL)
700
 
            return(NULL);
701
 
        p = (xmlGlobalStateCleanupHelperParams *)
702
 
            malloc(sizeof(xmlGlobalStateCleanupHelperParams));
703
 
        if (p == NULL) {
704
 
            xmlGenericError(xmlGenericErrorContext,
705
 
                            "xmlGetGlobalState: out of memory\n");
706
 
            xmlFreeGlobalState(tsd);
707
 
            return(NULL);
708
 
        }
709
 
        p->memory = tsd;
710
 
#if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL)
711
 
        DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
712
 
                        GetCurrentProcess(), &p->thread, 0, TRUE,
713
 
                        DUPLICATE_SAME_ACCESS);
714
 
        TlsSetValue(globalkey, tsd);
715
 
        _beginthread(xmlGlobalStateCleanupHelper, 0, p);
716
 
#else
717
 
        EnterCriticalSection(&cleanup_helpers_cs);
718
 
        if (cleanup_helpers_head != NULL) {
719
 
            cleanup_helpers_head->prev = p;
720
 
        }
721
 
        p->next = cleanup_helpers_head;
722
 
        p->prev = NULL;
723
 
        cleanup_helpers_head = p;
724
 
        TlsSetValue(globalkey, p);
725
 
        LeaveCriticalSection(&cleanup_helpers_cs);
726
 
#endif
727
 
 
728
 
        return (tsd);
729
 
    }
730
 
    return (globalval);
731
 
#endif /* HAVE_COMPILER_TLS */
732
 
#elif defined HAVE_BEOS_THREADS
733
 
    xmlGlobalState *globalval;
734
 
 
735
 
    xmlOnceInit();
736
 
 
737
 
    if ((globalval = (xmlGlobalState *) tls_get(globalkey)) == NULL) {
738
 
        xmlGlobalState *tsd = xmlNewGlobalState();
739
 
        if (tsd == NULL)
740
 
            return (NULL);
741
 
 
742
 
        tls_set(globalkey, tsd);
743
 
        on_exit_thread(xmlGlobalStateCleanup, NULL);
744
 
        return (tsd);
745
 
    }
746
 
    return (globalval);
747
 
#else
748
 
    return (NULL);
749
 
#endif
750
 
}
751
 
 
752
 
/************************************************************************
753
 
 *                                                                      *
754
 
 *                      Library wide thread interfaces                  *
755
 
 *                                                                      *
756
 
 ************************************************************************/
757
 
 
758
 
/**
759
 
 * xmlGetThreadId:
760
 
 *
761
 
 * xmlGetThreadId() find the current thread ID number
762
 
 * Note that this is likely to be broken on some platforms using pthreads
763
 
 * as the specification doesn't mandate pthread_t to be an integer type
764
 
 *
765
 
 * Returns the current thread ID number
766
 
 */
767
 
int
768
 
xmlGetThreadId(void)
769
 
{
770
 
#ifdef HAVE_PTHREAD_H
771
 
    pthread_t id;
772
 
    int ret;
773
 
 
774
 
    if (libxml_is_threaded == 0)
775
 
        return (0);
776
 
    id = pthread_self();
777
 
    /* horrible but preserves compat, see warning above */
778
 
    memcpy(&ret, &id, sizeof(ret));
779
 
    return (ret);
780
 
#elif defined HAVE_WIN32_THREADS
781
 
    return GetCurrentThreadId();
782
 
#elif defined HAVE_BEOS_THREADS
783
 
    return find_thread(NULL);
784
 
#else
785
 
    return ((int) 0);
786
 
#endif
787
 
}
788
 
 
789
 
/**
790
 
 * xmlIsMainThread:
791
 
 *
792
 
 * xmlIsMainThread() check whether the current thread is the main thread.
793
 
 *
794
 
 * Returns 1 if the current thread is the main thread, 0 otherwise
795
 
 */
796
 
int
797
 
xmlIsMainThread(void)
798
 
{
799
 
#ifdef HAVE_PTHREAD_H
800
 
    if (libxml_is_threaded == -1)
801
 
        xmlInitThreads();
802
 
    if (libxml_is_threaded == 0)
803
 
        return (1);
804
 
    pthread_once(&once_control, xmlOnceInit);
805
 
#elif defined HAVE_WIN32_THREADS
806
 
    xmlOnceInit();
807
 
#elif defined HAVE_BEOS_THREADS
808
 
    xmlOnceInit();
809
 
#endif
810
 
 
811
 
#ifdef DEBUG_THREADS
812
 
    xmlGenericError(xmlGenericErrorContext, "xmlIsMainThread()\n");
813
 
#endif
814
 
#ifdef HAVE_PTHREAD_H
815
 
    return (pthread_equal(mainthread,pthread_self()));
816
 
#elif defined HAVE_WIN32_THREADS
817
 
    return (mainthread == GetCurrentThreadId());
818
 
#elif defined HAVE_BEOS_THREADS
819
 
    return (mainthread == find_thread(NULL));
820
 
#else
821
 
    return (1);
822
 
#endif
823
 
}
824
 
 
825
 
/**
826
 
 * xmlLockLibrary:
827
 
 *
828
 
 * xmlLockLibrary() is used to take out a re-entrant lock on the libxml2
829
 
 * library.
830
 
 */
831
 
void
832
 
xmlLockLibrary(void)
833
 
{
834
 
#ifdef DEBUG_THREADS
835
 
    xmlGenericError(xmlGenericErrorContext, "xmlLockLibrary()\n");
836
 
#endif
837
 
    xmlRMutexLock(xmlLibraryLock);
838
 
}
839
 
 
840
 
/**
841
 
 * xmlUnlockLibrary:
842
 
 *
843
 
 * xmlUnlockLibrary() is used to release a re-entrant lock on the libxml2
844
 
 * library.
845
 
 */
846
 
void
847
 
xmlUnlockLibrary(void)
848
 
{
849
 
#ifdef DEBUG_THREADS
850
 
    xmlGenericError(xmlGenericErrorContext, "xmlUnlockLibrary()\n");
851
 
#endif
852
 
    xmlRMutexUnlock(xmlLibraryLock);
853
 
}
854
 
 
855
 
/**
856
 
 * xmlInitThreads:
857
 
 *
858
 
 * xmlInitThreads() is used to to initialize all the thread related
859
 
 * data of the libxml2 library.
860
 
 */
861
 
void
862
 
xmlInitThreads(void)
863
 
{
864
 
#ifdef HAVE_PTHREAD_H
865
 
    if (libxml_is_threaded == -1) {
866
 
        if ((pthread_once != NULL) &&
867
 
            (pthread_getspecific != NULL) &&
868
 
            (pthread_setspecific != NULL) &&
869
 
            (pthread_key_create != NULL) &&
870
 
            (pthread_key_delete != NULL) &&
871
 
            (pthread_mutex_init != NULL) &&
872
 
            (pthread_mutex_destroy != NULL) &&
873
 
            (pthread_mutex_lock != NULL) &&
874
 
            (pthread_mutex_unlock != NULL) &&
875
 
            (pthread_cond_init != NULL) &&
876
 
            (pthread_cond_destroy != NULL) &&
877
 
            (pthread_cond_wait != NULL) &&
878
 
            (pthread_equal != NULL) &&
879
 
            (pthread_self != NULL) &&
880
 
            (pthread_cond_signal != NULL)) {
881
 
            libxml_is_threaded = 1;
882
 
 
883
 
/* fprintf(stderr, "Running multithreaded\n"); */
884
 
        } else {
885
 
 
886
 
/* fprintf(stderr, "Running without multithread\n"); */
887
 
            libxml_is_threaded = 0;
888
 
        }
889
 
    }
890
 
#elif defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
891
 
    InitializeCriticalSection(&cleanup_helpers_cs);
892
 
#endif
893
 
}
894
 
 
895
 
/**
896
 
 * xmlCleanupThreads:
897
 
 *
898
 
 * xmlCleanupThreads() is used to to cleanup all the thread related
899
 
 * data of the libxml2 library once processing has ended.
900
 
 *
901
 
 * WARNING: if your application is multithreaded or has plugin support
902
 
 *          calling this may crash the application if another thread or
903
 
 *          a plugin is still using libxml2. It's sometimes very hard to
904
 
 *          guess if libxml2 is in use in the application, some libraries
905
 
 *          or plugins may use it without notice. In case of doubt abstain
906
 
 *          from calling this function or do it just before calling exit()
907
 
 *          to avoid leak reports from valgrind !
908
 
 */
909
 
void
910
 
xmlCleanupThreads(void)
911
 
{
912
 
#ifdef DEBUG_THREADS
913
 
    xmlGenericError(xmlGenericErrorContext, "xmlCleanupThreads()\n");
914
 
#endif
915
 
#ifdef HAVE_PTHREAD_H
916
 
    if ((libxml_is_threaded)  && (pthread_key_delete != NULL))
917
 
        pthread_key_delete(globalkey);
918
 
    once_control = PTHREAD_ONCE_INIT;
919
 
#elif defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
920
 
    if (globalkey != TLS_OUT_OF_INDEXES) {
921
 
        xmlGlobalStateCleanupHelperParams *p;
922
 
 
923
 
        EnterCriticalSection(&cleanup_helpers_cs);
924
 
        p = cleanup_helpers_head;
925
 
        while (p != NULL) {
926
 
            xmlGlobalStateCleanupHelperParams *temp = p;
927
 
 
928
 
            p = p->next;
929
 
            xmlFreeGlobalState(temp->memory);
930
 
            free(temp);
931
 
        }
932
 
        cleanup_helpers_head = 0;
933
 
        LeaveCriticalSection(&cleanup_helpers_cs);
934
 
        TlsFree(globalkey);
935
 
        globalkey = TLS_OUT_OF_INDEXES;
936
 
    }
937
 
    DeleteCriticalSection(&cleanup_helpers_cs);
938
 
#endif
939
 
}
940
 
 
941
 
#ifdef LIBXML_THREAD_ENABLED
942
 
 
943
 
/**
944
 
 * xmlOnceInit
945
 
 *
946
 
 * xmlOnceInit() is used to initialize the value of mainthread for use
947
 
 * in other routines. This function should only be called using
948
 
 * pthread_once() in association with the once_control variable to ensure
949
 
 * that the function is only called once. See man pthread_once for more
950
 
 * details.
951
 
 */
952
 
static void
953
 
xmlOnceInit(void)
954
 
{
955
 
#ifdef HAVE_PTHREAD_H
956
 
    (void) pthread_key_create(&globalkey, xmlFreeGlobalState);
957
 
    mainthread = pthread_self();
958
 
#elif defined(HAVE_WIN32_THREADS)
959
 
    if (!run_once.done) {
960
 
        if (InterlockedIncrement(&run_once.control) == 1) {
961
 
#if !defined(HAVE_COMPILER_TLS)
962
 
            globalkey = TlsAlloc();
963
 
#endif
964
 
            mainthread = GetCurrentThreadId();
965
 
            run_once.done = 1;
966
 
        } else {
967
 
            /* Another thread is working; give up our slice and
968
 
             * wait until they're done. */
969
 
            while (!run_once.done)
970
 
                Sleep(0);
971
 
        }
972
 
    }
973
 
#elif defined HAVE_BEOS_THREADS
974
 
    if (atomic_add(&run_once_init, 1) == 0) {
975
 
        globalkey = tls_allocate();
976
 
        tls_set(globalkey, NULL);
977
 
        mainthread = find_thread(NULL);
978
 
    } else
979
 
        atomic_add(&run_once_init, -1);
980
 
#endif
981
 
}
982
 
#endif
983
 
 
984
 
/**
985
 
 * DllMain:
986
 
 * @hinstDLL: handle to DLL instance
987
 
 * @fdwReason: Reason code for entry
988
 
 * @lpvReserved: generic pointer (depends upon reason code)
989
 
 *
990
 
 * Entry point for Windows library. It is being used to free thread-specific
991
 
 * storage.
992
 
 *
993
 
 * Returns TRUE always
994
 
 */
995
 
#ifdef HAVE_PTHREAD_H
996
 
#elif defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
997
 
#if defined(LIBXML_STATIC_FOR_DLL)
998
 
BOOL XMLCALL
999
 
xmlDllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
1000
 
#else
1001
 
BOOL WINAPI
1002
 
DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
1003
 
#endif
1004
 
{
1005
 
    switch (fdwReason) {
1006
 
        case DLL_THREAD_DETACH:
1007
 
            if (globalkey != TLS_OUT_OF_INDEXES) {
1008
 
                xmlGlobalState *globalval = NULL;
1009
 
                xmlGlobalStateCleanupHelperParams *p =
1010
 
                    (xmlGlobalStateCleanupHelperParams *)
1011
 
                    TlsGetValue(globalkey);
1012
 
                globalval = (xmlGlobalState *) (p ? p->memory : NULL);
1013
 
                if (globalval) {
1014
 
                    xmlFreeGlobalState(globalval);
1015
 
                    TlsSetValue(globalkey, NULL);
1016
 
                }
1017
 
                if (p) {
1018
 
                    EnterCriticalSection(&cleanup_helpers_cs);
1019
 
                    if (p == cleanup_helpers_head)
1020
 
                        cleanup_helpers_head = p->next;
1021
 
                    else
1022
 
                        p->prev->next = p->next;
1023
 
                    if (p->next != NULL)
1024
 
                        p->next->prev = p->prev;
1025
 
                    LeaveCriticalSection(&cleanup_helpers_cs);
1026
 
                    free(p);
1027
 
                }
1028
 
            }
1029
 
            break;
1030
 
    }
1031
 
    return TRUE;
1032
 
}
1033
 
#endif
1034
 
#define bottom_threads
1035
 
#include "elfgcchack.h"