libxml.h File Reference

#include <libxml/xmlstring.h>
#include "config.h"
#include <libxml/xmlversion.h>
#include <stdio.h>

Include dependency graph for libxml.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	_LARGEFILE_SOURCE
#define	_FILE_OFFSET_BITS   64
#define	XML_IGNORE_PEDANTIC_WARNINGS
#define	XML_POP_WARNINGS
#define	LIBXML_STATIC

Functions
void	__xmlIOErr (int domain, int code, const char *extra)
void	__xmlLoaderErr (void *ctx, const char *msg, const char *filename) LIBXML_ATTR_FORMAT(2
void void	__xmlGlobalInitMutexLock (void)
void	__xmlGlobalInitMutexUnlock (void)
void	__xmlGlobalInitMutexDestroy (void)
int	__xmlInitializeDict (void)
int	__xmlRandom (void)
XMLPUBFUN xmlChar *XMLCALL	xmlEscapeFormatString (xmlChar **msg)
int	xmlInputReadCallbackNop (void *context, char *buffer, int len)

Variables
int	__xmlRegisterCallbacks

Macro Definition Documentation

_FILE_OFFSET_BITS

#define _FILE_OFFSET_BITS   64

Definition at line 19 of file libxml.h.

_LARGEFILE_SOURCE

#define _LARGEFILE_SOURCE

Definition at line 16 of file libxml.h.

LIBXML_STATIC

#define LIBXML_STATIC

Definition at line 125 of file libxml.h.

XML_IGNORE_PEDANTIC_WARNINGS

#define XML_IGNORE_PEDANTIC_WARNINGS

Definition at line 71 of file libxml.h.

XML_POP_WARNINGS

#define XML_POP_WARNINGS

Definition at line 72 of file libxml.h.

Function Documentation

__xmlGlobalInitMutexDestroy()

void __xmlGlobalInitMutexDestroy

(

void

)

xmlGlobalInitMutexDestroy

Makes sure that the global initialization mutex is destroyed before application termination.

Definition at line 526 of file threads.c.

{
#ifdef HAVE_PTHREAD_H
#elif defined HAVE_WIN32_THREADS
    if (global_init_lock != NULL) {
        DeleteCriticalSection(global_init_lock);
        free(global_init_lock);
        global_init_lock = NULL;
    }
#endif
}

Referenced by xmlCleanupGlobals().

__xmlGlobalInitMutexLock()

void void __xmlGlobalInitMutexLock

(

void

)

xmlGlobalInitMutexLock

Makes sure that the global initialization mutex is initialized and locks it.

Definition at line 427 of file threads.c.

{
    /* Make sure the global init lock is initialized and then lock it. */
#ifdef HAVE_PTHREAD_H
    /* The mutex is statically initialized, so we just lock it. */
#ifdef XML_PTHREAD_WEAK
    if (pthread_mutex_lock == NULL)
        return;
#endif /* XML_PTHREAD_WEAK */
    pthread_mutex_lock(&global_init_lock);
#elif defined HAVE_WIN32_THREADS
    LPCRITICAL_SECTION cs;

    /* Create a new critical section */
    if (global_init_lock == NULL) {
        cs = malloc(sizeof(CRITICAL_SECTION));
        if (cs == NULL) {
            xmlGenericError(xmlGenericErrorContext,
                            "xmlGlobalInitMutexLock: out of memory\n");
            return;
        }
        InitializeCriticalSection(cs);

        /* Swap it into the global_init_lock */
#ifdef InterlockedCompareExchangePointer
        InterlockedCompareExchangePointer((void **) &global_init_lock,
                                          cs, NULL);
#else /* Use older void* version */
        InterlockedCompareExchange((void **) &global_init_lock,
                                   (void *) cs, NULL);
#endif /* InterlockedCompareExchangePointer */

        /* If another thread successfully recorded its critical
         * section in the global_init_lock then discard the one
         * allocated by this thread. */
        if (global_init_lock != cs) {
            DeleteCriticalSection(cs);
            free(cs);
        }
    }

    /* Lock the chosen critical section */
    EnterCriticalSection(global_init_lock);
#elif defined HAVE_BEOS_THREADS
    int32 sem;

    /* Allocate a new semaphore */
    sem = create_sem(1, "xmlGlobalinitMutex");

    while (global_init_lock == -1) {
        if (atomic_add(&global_init_count, 1) == 0) {
            global_init_lock = sem;
        } else {
            snooze(1);
            atomic_add(&global_init_count, -1);
        }
    }

    /* If another thread successfully recorded its critical
     * section in the global_init_lock then discard the one
     * allocated by this thread. */
    if (global_init_lock != sem)
        delete_sem(sem);

    /* Acquire the chosen semaphore */
    if (acquire_sem(global_init_lock) != B_NO_ERROR) {
#ifdef DEBUG_THREADS
        xmlGenericError(xmlGenericErrorContext,
                        "xmlGlobalInitMutexLock():BeOS:Couldn't acquire semaphore\n");
#endif
    }
#endif
}

Referenced by xmlInitParser().

__xmlGlobalInitMutexUnlock()

void __xmlGlobalInitMutexUnlock

(

void

)

Definition at line 502 of file threads.c.

{
#ifdef HAVE_PTHREAD_H
#ifdef XML_PTHREAD_WEAK
    if (pthread_mutex_unlock == NULL)
        return;
#endif /* XML_PTHREAD_WEAK */
    pthread_mutex_unlock(&global_init_lock);
#elif defined HAVE_WIN32_THREADS
    if (global_init_lock != NULL) {
    LeaveCriticalSection(global_init_lock);
    }
#elif defined HAVE_BEOS_THREADS
    release_sem(global_init_lock);
#endif
}

Referenced by xmlInitParser().

__xmlInitializeDict()

int __xmlInitializeDict

(

void

)

__xmlInitializeDict:

This function is not public Do the dictionary mutex initialization. this function is not thread safe, initialization should normally be done once at setup when called from xmlOnceInit() we may also land in this code if thread support is not compiled in

Returns 0 if initialization was already done, and 1 if that call led to the initialization

Definition at line 175 of file dict.c.

                              {
    if (xmlDictInitialized)
        return(1);

    if ((xmlDictMutex = xmlNewRMutex()) == NULL)
        return(0);
    xmlRMutexLock(xmlDictMutex);

#ifdef DICT_RANDOMIZATION
#ifdef HAVE_RAND_R
    rand_seed = time(NULL);
    rand_r(& rand_seed);
#else
    srand(time(NULL));
#endif
#endif
    xmlDictInitialized = 1;
    xmlRMutexUnlock(xmlDictMutex);
    return(1);
}

Referenced by __xmlRandom(), xmlDictCreate(), xmlDictFree(), and xmlDictReference().

__xmlIOErr()

void __xmlIOErr	(	int	domain,
		int	code,
		const char *	extra
	)

__xmlLoaderErr()

void __xmlLoaderErr	(	void *	ctx,
		const char *	msg,
		const char *	filename
	)

Referenced by xmlNewInputFromFile().

__xmlRandom()

int __xmlRandom

(

void

)

Definition at line 197 of file dict.c.

                      {
    int ret;

    if (xmlDictInitialized == 0)
        __xmlInitializeDict();

    xmlRMutexLock(xmlDictMutex);
#ifdef HAVE_RAND_R
    ret = rand_r(& rand_seed);
#else
    ret = rand();
#endif
    xmlRMutexUnlock(xmlDictMutex);
    return(ret);
}

Referenced by xmlDictCreate(), and xmlHashCreate().

xmlEscapeFormatString()

XMLPUBFUN xmlChar* XMLCALL xmlEscapeFormatString

(

xmlChar **

msg

)

xmlEscapeFormatString: @msg: a pointer to the string in which to escape '' characters. Must be a heap-allocated buffer created by libxml2 that may be returned, or that may be freed and replaced.

Replaces the string pointed to by 'msg' with an escaped string. Returns the same string with all '' characters escaped.

Definition at line 1001 of file xmlstring.c.

{
    xmlChar *msgPtr = NULL;
    xmlChar *result = NULL;
    xmlChar *resultPtr = NULL;
    size_t count = 0;
    size_t msgLen = 0;
    size_t resultLen = 0;

    if (!msg || !*msg)
        return(NULL);

    for (msgPtr = *msg; *msgPtr != '\0'; ++msgPtr) {
        ++msgLen;
        if (*msgPtr == '%')
            ++count;
    }

    if (count == 0)
        return(*msg);

    resultLen = msgLen + count + 1;
    result = (xmlChar *) xmlMallocAtomic(resultLen * sizeof(xmlChar));
    if (result == NULL) {
        /* Clear *msg to prevent format string vulnerabilities in
           out-of-memory situations. */
        xmlFree(*msg);
        *msg = NULL;
        xmlErrMemory(NULL, NULL);
        return(NULL);
    }

    for (msgPtr = *msg, resultPtr = result; *msgPtr != '\0'; ++msgPtr, ++resultPtr) {
        *resultPtr = *msgPtr;
        if (*msgPtr == '%')
            *(++resultPtr) = '%';
    }
    result[resultLen - 1] = '\0';

    xmlFree(*msg);
    *msg = result;

    return *msg;
}

xmlInputReadCallbackNop()

int xmlInputReadCallbackNop	(	void *	context,
		char *	buffer,
		int	len
	)

Referenced by xmlGROW().

Variable Documentation

__xmlRegisterCallbacks

int __xmlRegisterCallbacks

Definition at line 53 of file tree.c.

Referenced by xmlDeregisterNodeDefault(), xmlRegisterNodeDefault(), xmlSAX2AttributeNs(), xmlSAX2StartElementNs(), xmlThrDefDeregisterNodeDefault(), and xmlThrDefRegisterNodeDefault().