mirror of https://github.com/sipwise/kamailio.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
306 lines
9.7 KiB
306 lines
9.7 KiB
/*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* Jabber
|
|
* Copyright (C) 1998-1999 The Jabber Team http://jabber.org/
|
|
*/
|
|
|
|
/*! \file
|
|
* \ingroup xmpp
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <sys/types.h>
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
#include <syslog.h>
|
|
#include <strings.h>
|
|
#include <unistd.h>
|
|
#include <sys/time.h>
|
|
|
|
#include "expat.h"
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif /* HAVE_CONFIG_H */
|
|
|
|
/*
|
|
** Arrange to use either varargs or stdargs
|
|
*/
|
|
|
|
#define MAXSHORTSTR 203 /* max short string length */
|
|
#define QUAD_T unsigned long long
|
|
|
|
#ifdef __STDC__
|
|
|
|
#include <stdarg.h>
|
|
|
|
# define VA_LOCAL_DECL va_list ap;
|
|
# define VA_START(f) va_start(ap, f)
|
|
# define VA_END va_end(ap)
|
|
|
|
#else /* __STDC__ */
|
|
|
|
# include <varargs.h>
|
|
|
|
# define VA_LOCAL_DECL va_list ap;
|
|
# define VA_START(f) va_start(ap)
|
|
# define VA_END va_end(ap)
|
|
|
|
#endif /* __STDC__ */
|
|
|
|
|
|
#ifndef INCL_LIBXODE_H
|
|
#define INCL_LIBXODE_H
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#ifndef __OS_darwin
|
|
#ifndef HAVE_SNPRINTF
|
|
extern int ap_snprintf(char *, size_t, const char *, ...);
|
|
#define snprintf ap_snprintf
|
|
#endif
|
|
|
|
#ifndef HAVE_VSNPRINTF
|
|
extern int ap_vsnprintf(char *, size_t, const char *, va_list ap);
|
|
#define vsnprintf ap_vsnprintf
|
|
#endif
|
|
#endif
|
|
|
|
/* --------------------------------------------------------- */
|
|
/* */
|
|
/* Pool-based memory management routines */
|
|
/* */
|
|
/* --------------------------------------------------------- */
|
|
|
|
|
|
/* xode_pool_cleaner - callback type which is associated
|
|
with a pool entry; invoked when the pool entry is
|
|
free'd */
|
|
typedef void (*xode_pool_cleaner)(void *arg);
|
|
|
|
|
|
/* pheap - singular allocation of memory */
|
|
struct xode_pool_heap
|
|
{
|
|
void *block;
|
|
int size, used;
|
|
};
|
|
|
|
/* pool - base node for a pool. Maintains a linked list
|
|
of pool entries (pool_free) */
|
|
typedef struct xode_pool_struct
|
|
{
|
|
int size;
|
|
struct xode_pool_free *cleanup;
|
|
struct xode_pool_heap *heap;
|
|
} _xode_pool, *xode_pool;
|
|
|
|
/* pool creation routines */
|
|
xode_pool xode_pool_heap(int bytes);
|
|
xode_pool xode_pool_new(void);
|
|
|
|
/* pool wrappers for malloc */
|
|
void *xode_pool_malloc (xode_pool p, int size);
|
|
void *xode_pool_mallocx (xode_pool p, int size, char c);
|
|
void *xode_pool_malloco (xode_pool p, int size);
|
|
|
|
/* wrapper around strdup, gains mem from pool */
|
|
char *xode_pool_strdup (xode_pool p, const char *src);
|
|
|
|
/* calls f(arg) before the pool is freed during cleanup */
|
|
void xode_pool_cleanup (xode_pool p, xode_pool_cleaner f, void *arg);
|
|
|
|
/* pool wrapper for free, called on a pool */
|
|
void xode_pool_free (xode_pool p);
|
|
|
|
/* returns total bytes allocated in this pool */
|
|
int xode_pool_size (xode_pool p);
|
|
|
|
/* --------------------------------------------------------- */
|
|
/* */
|
|
/* XML escaping utils */
|
|
/* */
|
|
/* --------------------------------------------------------- */
|
|
char *xode_strescape(xode_pool p, char *buf); /* Escape <>&'" chars */
|
|
char *xode_strunescape(xode_pool p, char *buf);
|
|
|
|
|
|
/* --------------------------------------------------------- */
|
|
/* */
|
|
/* String pools (spool) functions */
|
|
/* */
|
|
/* --------------------------------------------------------- */
|
|
struct xode_spool_node
|
|
{
|
|
char *c;
|
|
struct xode_spool_node *next;
|
|
};
|
|
|
|
typedef struct xode_spool_struct
|
|
{
|
|
xode_pool p;
|
|
int len;
|
|
struct xode_spool_node *last;
|
|
struct xode_spool_node *first;
|
|
} *xode_spool;
|
|
|
|
xode_spool xode_spool_new ( void ); /* create a string pool on a new pool */
|
|
xode_spool xode_spool_newfrompool ( xode_pool p ); /* create a string pool from an existing pool */
|
|
xode_pool xode_spool_getpool ( const xode_spool s ); /* returns the xode_pool used by this xode_spool */
|
|
void xode_spooler ( xode_spool s, ... ); /* append all the char * args to the pool, terminate args with s again */
|
|
char *xode_spool_tostr ( xode_spool s ); /* return a big string */
|
|
void xode_spool_add ( xode_spool s, char *str ); /* add a single char to the pool */
|
|
char *xode_spool_str ( xode_pool p, ... ); /* wrap all the spooler stuff in one function, the happy fun ball! */
|
|
int xode_spool_getlen ( const xode_spool s ); /* returns the total length of the string contained in the pool */
|
|
void xode_spool_free ( xode_spool s ); /* Free's the pool associated with the xode_spool */
|
|
|
|
|
|
/* --------------------------------------------------------- */
|
|
/* */
|
|
/* xodes - Document Object Model */
|
|
/* */
|
|
/* --------------------------------------------------------- */
|
|
#define XODE_TYPE_TAG 0
|
|
#define XODE_TYPE_ATTRIB 1
|
|
#define XODE_TYPE_CDATA 2
|
|
|
|
#define XODE_TYPE_LAST 2
|
|
#define XODE_TYPE_UNDEF -1
|
|
|
|
/* --------------------------------------------------------------------------
|
|
Node structure. Do not use directly! Always use accessors macros
|
|
and methods!
|
|
-------------------------------------------------------------------------- */
|
|
typedef struct xode_struct
|
|
{
|
|
char* name;
|
|
unsigned short type;
|
|
char* data;
|
|
int data_sz;
|
|
int complete;
|
|
xode_pool p;
|
|
struct xode_struct* parent;
|
|
struct xode_struct* firstchild;
|
|
struct xode_struct* lastchild;
|
|
struct xode_struct* prev;
|
|
struct xode_struct* next;
|
|
struct xode_struct* firstattrib;
|
|
struct xode_struct* lastattrib;
|
|
} _xode, *xode;
|
|
|
|
/* Node creation routines */
|
|
xode xode_wrap(xode x,const char* wrapper);
|
|
xode xode_new(const char* name);
|
|
xode xode_new_tag(const char* name);
|
|
xode xode_new_frompool(xode_pool p, const char* name);
|
|
xode xode_insert_tag(xode parent, const char* name);
|
|
xode xode_insert_cdata(xode parent, const char* CDATA, unsigned int size);
|
|
xode xode_insert_tagnode(xode parent, xode node);
|
|
void xode_insert_node(xode parent, xode node);
|
|
xode xode_from_str(char *str, int len);
|
|
xode xode_from_strx(char *str, int len, int *err, int *pos);
|
|
xode xode_from_file(char *file);
|
|
xode xode_dup(xode x); /* duplicate x */
|
|
xode xode_dup_frompool(xode_pool p, xode x);
|
|
|
|
/* Node Memory Pool */
|
|
xode_pool xode_get_pool(xode node);
|
|
|
|
/* Node editing */
|
|
void xode_hide(xode child);
|
|
void xode_hide_attrib(xode parent, const char *name);
|
|
|
|
/* Node deletion routine, also frees the node pool! */
|
|
void xode_free(xode node);
|
|
|
|
/* Locates a child tag by name and returns it */
|
|
xode xode_get_tag(xode parent, const char* name);
|
|
char* xode_get_tagdata(xode parent, const char* name);
|
|
|
|
/* Attribute accessors */
|
|
void xode_put_attrib(xode owner, const char* name, const char* value);
|
|
char* xode_get_attrib(xode owner, const char* name);
|
|
|
|
/* Bastard am I, but these are fun for internal use ;-) */
|
|
void xode_put_vattrib(xode owner, const char* name, void *value);
|
|
void* xode_get_vattrib(xode owner, const char* name);
|
|
|
|
/* Node traversal routines */
|
|
xode xode_get_firstattrib(xode parent);
|
|
xode xode_get_firstchild(xode parent);
|
|
xode xode_get_lastchild(xode parent);
|
|
xode xode_get_nextsibling(xode sibling);
|
|
xode xode_get_prevsibling(xode sibling);
|
|
xode xode_get_parent(xode node);
|
|
|
|
/* Node information routines */
|
|
char* xode_get_name(xode node);
|
|
char* xode_get_data(xode node);
|
|
int xode_get_datasz(xode node);
|
|
int xode_get_type(xode node);
|
|
|
|
int xode_has_children(xode node);
|
|
int xode_has_attribs(xode node);
|
|
|
|
/* Node-to-string translation */
|
|
char* xode_to_str(xode node);
|
|
char* xode_to_prettystr(xode node); /* Puts \t and \n to make a human-easily readable string */
|
|
|
|
int xode_cmp(xode a, xode b); /* compares a and b for equality */
|
|
|
|
int xode_to_file(char *file, xode node); /* writes node to file */
|
|
|
|
|
|
/***********************
|
|
* XSTREAM Section
|
|
***********************/
|
|
|
|
#define XODE_STREAM_MAXNODE 1000000
|
|
#define XODE_STREAM_MAXDEPTH 100
|
|
|
|
#define XODE_STREAM_ROOT 0 /* root element */
|
|
#define XODE_STREAM_NODE 1 /* normal node */
|
|
#define XODE_STREAM_CLOSE 2 /* closed root node */
|
|
#define XODE_STREAM_ERROR 4 /* parser error */
|
|
|
|
typedef void (*xode_stream_onNode)(int type, xode x, void *arg); /* xstream event handler */
|
|
|
|
typedef struct xode_stream_struct
|
|
{
|
|
XML_Parser parser;
|
|
xode node;
|
|
char *cdata;
|
|
int cdata_len;
|
|
xode_pool p;
|
|
xode_stream_onNode f;
|
|
void *arg;
|
|
int status;
|
|
int depth;
|
|
} *xode_stream, _xode_stream;
|
|
|
|
xode_stream xode_stream_new(xode_pool p, xode_stream_onNode f, void *arg); /* create a new xstream */
|
|
int xode_stream_eat(xode_stream xs, char *buff, int len); /* parse new data for this xstream, returns last XSTREAM_* status */
|
|
|
|
/* convenience functions */
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* INCL_LIBXODE_H */
|