#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <stdio.h>
#include <setjmp.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#ifndef __MINGW32__
#include <syslog.h>
#endif
#include <strings.h>
#include <unistd.h>
#include <sys/param.h>
#ifdef __MINGW32__
#include <winsock2.h>
#else
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#endif
#include <sys/time.h>
#include <stdarg.h>
#include <ctype.h>
#include <time.h>

#include "xmlparse.h"

#ifdef __MINGW32__
#include <glib.h>
#define snprintf g_snprintf
#define bzero(s,n) memset(s,0,n)
#endif

/*
**  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_LIB_H
#define INCL_LIB_H

#ifdef __cplusplus
extern "C" {
#endif

#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

#define ZONE zonestr(__FILE__,__LINE__)
	char *zonestr(char *file, int line);

/* --------------------------------------------------------- */
/*                                                           */
/* Pool-based memory management routines                     */
/*                                                           */
/* --------------------------------------------------------- */

#undef POOL_DEBUG
/*
 flip these, this should be a prime number for top # of pools debugging
#define POOL_DEBUG 40009 
*/

/* pheap - singular allocation of memory */
	struct pheap {
		void *block;
		int size, used;
	};

/* pool_cleaner - callback type which is associated
   with a pool entry; invoked when the pool entry is 
   free'd */
	typedef void (*pool_cleaner) (void *arg);

/* pfree - a linked list node which stores an
   allocation chunk, plus a callback */
	struct pfree {
		pool_cleaner f;
		void *arg;
		struct pheap *heap;
		struct pfree *next;
	};

/* pool - base node for a pool. Maintains a linked list
   of pool entries (pfree) */
	typedef struct pool_struct {
		int size;
		struct pfree *cleanup;
		struct pheap *heap;
#ifdef POOL_DEBUG
		char name[8], zone[32];
		int lsize;
	} _pool, *pool;
#define pool_new() _pool_new(ZONE)
#define pool_heap(i) _pool_new_heap(i,ZONE)
#else
	} _pool, *pool;
#define pool_heap(i) _pool_new_heap(i,NULL)
#define pool_new() _pool_new(NULL)
#endif

	pool _pool_new(char *zone);	/* new pool :) */
	pool _pool_new_heap(int size, char *zone);	/* creates a new memory pool with an initial heap size */
	void *pmalloc(pool p, int size);	/* wrapper around malloc, takes from the pool, cleaned up automatically */
	void *pmalloc_x(pool p, int size, char c);	/* Wrapper around pmalloc which prefils buffer with c */
	void *pmalloco(pool p, int size);	/* YAPW for zeroing the block */
	char *pstrdup(pool p, const char *src);	/* wrapper around strdup, gains mem from pool */
	void pool_stat(int full);	/* print to stderr the changed pools and reset */
	char *pstrdupx(pool p, const char *src);	/* temp stub */
	void pool_cleanup(pool p, pool_cleaner f, void *arg);	/* calls f(arg) before the pool is freed during cleanup */
	void pool_free(pool p);	/* calls the cleanup functions, frees all the data on the pool, and deletes the pool itself */
	int pool_size(pool p);	/* returns total bytes allocated in this pool */

/* --------------------------------------------------------- */
/*                                                           */
/* Socket helper stuff                                       */
/*                                                           */
/* --------------------------------------------------------- */
#ifndef MAXHOSTNAMELEN
#define MAXHOSTNAMELEN 64
#endif

#define NETSOCKET_SERVER 0
#define NETSOCKET_CLIENT 1
#define NETSOCKET_UDP 2

#ifndef WIN32
	int make_netsocket(u_short port, char *host, int type);
	struct in_addr *make_addr(char *host);
	int set_fd_close_on_exec(int fd, int flag);
#endif

/* --------------------------------------------------------- */
/*                                                           */
/* String management routines                                */
/*                                                           */
/* --------------------------------------------------------- */
	char *j_strdup(const char *str);	/* provides NULL safe strdup wrapper */
	char *j_strcat(char *dest, char *txt);	/* strcpy() clone */
	int j_strcmp(const char *a, const char *b);	/* provides NULL safe strcmp wrapper */
	int j_strcasecmp(const char *a, const char *b);	/* provides NULL safe strcasecmp wrapper */
	int j_strncmp(const char *a, const char *b, int i);	/* provides NULL safe strncmp wrapper */
	int j_strncasecmp(const char *a, const char *b, int i);	/* provides NULL safe strncasecmp wrapper */
	int j_strlen(const char *a);	/* provides NULL safe strlen wrapper */
	int j_atoi(const char *a, int def);	/* checks for NULL and uses default instead, convienence */
	void str_b64decode(char *str);	/* what it says */

/* --------------------------------------------------------- */
/*                                                           */
/* SHA calculations                                          */
/*                                                           */
/* --------------------------------------------------------- */
#if (SIZEOF_INT == 4)
	typedef unsigned int uint32;
#elif (SIZEOF_SHORT == 4)
	typedef unsigned short uint32;
#else
	typedef unsigned int uint32;
#endif				/* HAVEUINT32 */

	char *shahash(char *str);	/* NOT THREAD SAFE */
	void shahash_r(const char *str, char hashbuf[40]);	/* USE ME */

	int strprintsha(char *dest, int *hashval);

/* --------------------------------------------------------- */
/*                                                           */
/* Hashtable functions                                       */
/*                                                           */
/* --------------------------------------------------------- */
	typedef struct xhn_struct {
		struct xhn_struct *next;
		const char *key;
		void *val;
	} *xhn, _xhn;

	typedef struct xht_struct {
		pool p;
		int prime;
		struct xhn_struct *zen;
	} *xht, _xht;

	xht xhash_new(int prime);
	void xhash_put(xht h, const char *key, void *val);
	void *xhash_get(xht h, const char *key);
	void xhash_zap(xht h, const char *key);
	void xhash_free(xht h);
	typedef void (*xhash_walker) (xht h, const char *key, void *val,
		void *arg);
	void xhash_walk(xht h, xhash_walker w, void *arg);

/* --------------------------------------------------------- */
/*                                                           */
/* DEPRECIATED Hashtable functions                           */
/*                                                           */
/* --------------------------------------------------------- */
	typedef int (*KEYHASHFUNC) (const void *key);
	typedef int (*KEYCOMPAREFUNC) (const void *key1, const void *key2);
	typedef int (*TABLEWALKFUNC) (void *user_data, const void *key,
		void *data);

	typedef void *HASHTABLE;

	HASHTABLE ghash_create(int buckets, KEYHASHFUNC hash,
		KEYCOMPAREFUNC cmp);
	HASHTABLE ghash_create_pool(pool p, int buckets, KEYHASHFUNC hash,
		KEYCOMPAREFUNC cmp);
	void ghash_destroy(HASHTABLE tbl);
	void *ghash_get(HASHTABLE tbl, const void *key);
	int ghash_put(HASHTABLE tbl, const void *key, void *value);
	int ghash_remove(HASHTABLE tbl, const void *key);
	int ghash_walk(HASHTABLE tbl, TABLEWALKFUNC func, void *user_data);
	int str_hash_code(const char *s);

/* --------------------------------------------------------- */
/*                                                           */
/* XML escaping utils                                        */
/*                                                           */
/* --------------------------------------------------------- */
	char *strescape(pool p, char *buf);	/* Escape <>&'" chars */
	char *strunescape(pool p, char *buf);

/* --------------------------------------------------------- */
/*                                                           */
/* String pools (spool) functions                            */
/*                                                           */
/* --------------------------------------------------------- */
	struct spool_node {
		char *c;
		struct spool_node *next;
	};

	typedef struct spool_struct {
		pool p;
		int len;
		struct spool_node *last;
		struct spool_node *first;
	} *spool;

	spool spool_new(pool p);	/* create a string pool */
	void spooler(spool s, ...);	/* append all the char * args to the pool, terminate args with s again */
	char *spool_print(spool s);	/* return a big string */
	void spool_add(spool s, char *str);	/* add a single char to the pool */
	char *spools(pool p, ...);	/* wrap all the spooler stuff in one function, the happy fun ball! */

/* --------------------------------------------------------- */
/*                                                           */
/* xmlnodes - Document Object Model                          */
/*                                                           */
/* --------------------------------------------------------- */
#define NTYPE_TAG    0
#define NTYPE_ATTRIB 1
#define NTYPE_CDATA  2

#define NTYPE_LAST   2
#define NTYPE_UNDEF  -1

/* -------------------------------------------------------------------------- 
   Node structure. Do not use directly! Always use accessor macros 
   and methods!
   -------------------------------------------------------------------------- */
	typedef struct xmlnode_t {
		char *name;
		unsigned short type;
		char *data;
		int data_sz;
		int complete;
		pool p;
		struct xmlnode_t *parent;
		struct xmlnode_t *firstchild;
		struct xmlnode_t *lastchild;
		struct xmlnode_t *prev;
		struct xmlnode_t *next;
		struct xmlnode_t *firstattrib;
		struct xmlnode_t *lastattrib;
	} _xmlnode, *xmlnode;

/* Node creation routines */
	xmlnode xmlnode_wrap(xmlnode x, const char *wrapper);
	xmlnode xmlnode_new_tag(const char *name);
	xmlnode xmlnode_new_tag_pool(pool p, const char *name);
	xmlnode xmlnode_insert_tag(xmlnode parent, const char *name);
	xmlnode xmlnode_insert_cdata(xmlnode parent, const char *CDATA,
		unsigned int size);
	xmlnode xmlnode_insert_tag_node(xmlnode parent, xmlnode node);
	void xmlnode_insert_node(xmlnode parent, xmlnode node);
	xmlnode xmlnode_str(char *str, int len);
	xmlnode xmlnode_file(char *file);
	char *xmlnode_file_borked(char *file);	/* same as _file but returns the parsing error */
	xmlnode xmlnode_dup(xmlnode x);	/* duplicate x */
	xmlnode xmlnode_dup_pool(pool p, xmlnode x);

/* Node Memory Pool */
	pool xmlnode_pool(xmlnode node);
	xmlnode _xmlnode_new(pool p, const char *name, unsigned int type);

/* Node editing */
	void xmlnode_hide(xmlnode child);
	void xmlnode_hide_attrib(xmlnode parent, const char *name);

/* Node deletion routine, also frees the node pool! */
	void xmlnode_free(xmlnode node);

/* Locates a child tag by name and returns it */
	xmlnode xmlnode_get_tag(xmlnode parent, const char *name);
	char *xmlnode_get_tag_data(xmlnode parent, const char *name);

/* Attribute accessors */
	void xmlnode_put_attrib(xmlnode owner, const char *name,
		const char *value);
	char *xmlnode_get_attrib(xmlnode owner, const char *name);
	void xmlnode_put_expat_attribs(xmlnode owner, const char **atts);

/* Bastard am I, but these are fun for internal use ;-) */
	void xmlnode_put_vattrib(xmlnode owner, const char *name, void *value);
	void *xmlnode_get_vattrib(xmlnode owner, const char *name);

/* Node traversal routines */
	xmlnode xmlnode_get_firstattrib(xmlnode parent);
	xmlnode xmlnode_get_firstchild(xmlnode parent);
	xmlnode xmlnode_get_lastchild(xmlnode parent);
	xmlnode xmlnode_get_nextsibling(xmlnode sibling);
	xmlnode xmlnode_get_prevsibling(xmlnode sibling);
	xmlnode xmlnode_get_parent(xmlnode node);

/* Node information routines */
	char *xmlnode_get_name(xmlnode node);
	char *xmlnode_get_data(xmlnode node);
	int xmlnode_get_datasz(xmlnode node);
	int xmlnode_get_type(xmlnode node);

	int xmlnode_has_children(xmlnode node);
	int xmlnode_has_attribs(xmlnode node);

/* Node-to-string translation */
	char *xmlnode2str(xmlnode node);

/* Node-to-terminated-string translation 
   -- useful for interfacing w/ scripting langs */
	char *xmlnode2tstr(xmlnode node);

	int xmlnode_cmp(xmlnode a, xmlnode b);	/* compares a and b for equality */

	int xmlnode2file(char *file, xmlnode node);	/* writes node to file */

/* Expat callbacks */
	void expat_startElement(void *userdata, const char *name,
		const char **atts);
	void expat_endElement(void *userdata, const char *name);
	void expat_charData(void *userdata, const char *s, int len);

/***********************
 * XSTREAM Section
 ***********************/

#define XSTREAM_MAXNODE 1000000
#define XSTREAM_MAXDEPTH 100

#define XSTREAM_ROOT        0	/* root element */
#define XSTREAM_NODE        1	/* normal node */
#define XSTREAM_CLOSE       2	/* closed </stream:stream> */
#define XSTREAM_ERR         4	/* parser error */

	typedef void (*xstream_onNode) (int type, xmlnode x, void *arg);	/* xstream event handler */

	typedef struct xstream_struct {
		XML_Parser parser;
		xmlnode node;
		char *cdata;
		int cdata_len;
		pool p;
		xstream_onNode f;
		void *arg;
		int status;
		int depth;
	} *xstream, _xstream;

	xstream xstream_new(pool p, xstream_onNode f, void *arg);	/* create a new xstream */
	int xstream_eat(xstream xs, char *buff, int len);	/* parse new data for this xstream, returns last XSTREAM_* status */

/* convience functions */
	xmlnode xstream_header(char *namespace, char *to, char *from);
	char *xstream_header_char(xmlnode x);

	typedef struct {
		unsigned long H[5];
		unsigned long W[80];
		int lenW;
		unsigned long sizeHi, sizeLo;
	} j_SHA_CTX;

	void shaInit(j_SHA_CTX *ctx);
	void shaUpdate(j_SHA_CTX *ctx, unsigned char *dataIn, int len);
	void shaFinal(j_SHA_CTX *ctx, unsigned char hashout[20]);
	void shaBlock(unsigned char *dataIn, int len,
		unsigned char hashout[20]);

/********** END OLD libxode.h BEGIN OLD jabber.h *************/

/* --------------------------------------------------------- */
/*                                                           */
/* JID structures & constants                                */
/*                                                           */
/* --------------------------------------------------------- */
#define JID_RESOURCE 1
#define JID_USER     2
#define JID_SERVER   4

	typedef struct jid_struct {
		pool p;
		char *resource;
		char *user;
		char *server;
		char *full;
		struct jid_struct *next;	/* for lists of jids */
	} *jid;

	jid jid_new(pool p, char *idstr);	/* Creates a jabber id from the idstr */
	void jid_set(jid id, char *str, int item);	/* Individually sets jid components */
	char *jid_full(jid id);	/* Builds a string type=user/resource@server from the jid data */
	int jid_cmp(jid a, jid b);	/* Compares two jid's, returns 0 for perfect match */
	int jid_cmpx(jid a, jid b, int parts);	/* Compares just the parts specified as JID_|JID_ */
	jid jid_append(jid a, jid b);	/* Appending b to a (list), no dups */
	xmlnode jid_xres(jid id);	/* Returns xmlnode representation of the resource?query=string */
	xmlnode jid_nodescan(jid id, xmlnode x);	/* Scans the children of the node for a matching jid attribute */
	jid jid_user(jid a);	/* returns the same jid but just of the user@host part */

/* --------------------------------------------------------- */
/*                                                           */
/* JPacket structures & constants                            */
/*                                                           */
/* --------------------------------------------------------- */
#define JPACKET_UNKNOWN   0x00
#define JPACKET_MESSAGE   0x01
#define JPACKET_PRESENCE  0x02
#define JPACKET_IQ        0x04
#define JPACKET_S10N      0x08

#define JPACKET__UNKNOWN      0
#define JPACKET__NONE         1
#define JPACKET__ERROR        2
#define JPACKET__CHAT         3
#define JPACKET__GROUPCHAT    4
#define JPACKET__GET          5
#define JPACKET__SET          6
#define JPACKET__RESULT       7
#define JPACKET__SUBSCRIBE    8
#define JPACKET__SUBSCRIBED   9
#define JPACKET__UNSUBSCRIBE  10
#define JPACKET__UNSUBSCRIBED 11
#define JPACKET__AVAILABLE    12
#define JPACKET__UNAVAILABLE  13
#define JPACKET__PROBE        14
#define JPACKET__HEADLINE     15
#define JPACKET__INVISIBLE    16

	typedef struct jpacket_struct {
		unsigned char type;
		int subtype;
		int flag;
		void *aux1;
		xmlnode x;
		jid to;
		jid from;
		char *iqns;
		xmlnode iq;
		pool p;
	} *jpacket, _jpacket;

	jpacket jpacket_new(xmlnode x);	/* Creates a jabber packet from the xmlnode */
	jpacket jpacket_reset(jpacket p);	/* Resets the jpacket values based on the xmlnode */
	int jpacket_subtype(jpacket p);	/* Returns the subtype value (looks at xmlnode for it) */

/* --------------------------------------------------------- */
/*                                                           */
/* Presence Proxy DB structures & constants                  */
/*                                                           */
/* --------------------------------------------------------- */
	typedef struct ppdb_struct {
		jid id;		/* entry data */
		int pri;
		xmlnode x;
		struct ppdb_struct *user;	/* linked list for user@server */
		pool p;		/* db-level data */
		struct ppdb_struct *next;
	} _ppdb, *ppdb;

	ppdb ppdb_insert(ppdb db, jid id, xmlnode x);	/* Inserts presence into the proxy */
	xmlnode ppdb_primary(ppdb db, jid id);	/* Fetches the matching primary presence for the id */
	void ppdb_free(ppdb db);	/* Frees the db and all entries */
	xmlnode ppdb_get(ppdb db, jid id);	/* Called successively to return each presence xmlnode */
	/*   for the id and children, returns NULL at the end */

/* --------------------------------------------------------- */
/*                                                           */
/* Simple Jabber Rate limit functions                        */
/*                                                           */
/* --------------------------------------------------------- */
	typedef struct jlimit_struct {
		char *key;
		int start;
		int points;
		int maxt, maxp;
		pool p;
	} *jlimit, _jlimit;

	jlimit jlimit_new(int maxt, int maxp);
	void jlimit_free(jlimit r);
	int jlimit_check(jlimit r, char *key, int points);

// #define KARMA_DEBUG
// default to disable karma 
#define KARMA_READ_MAX(k) (abs(k)*100)	/* how much you are allowed to read off the sock */
#define KARMA_INIT 5		/* internal "init" value */
#define KARMA_HEARTBEAT 2	/* seconds to register for heartbeat */
#define KARMA_MAX 10		/* total max karma you can have */
#define KARMA_INC 1		/* how much to increment every KARMA_HEARTBEAT seconds */
#define KARMA_DEC 0		/* how much to penalize for reading KARMA_READ_MAX in
				   KARMA_HEARTBEAT seconds */
#define KARMA_PENALTY -5	/* where you go when you hit 0 karma */
#define KARMA_RESTORE 5		/* where you go when you payed your penelty or INIT */
#define KARMA_RESETMETER 0	/* Reset byte meter on restore default is falst */

	struct karma {
		int init;	/* struct initialized */
		int reset_meter;	/* reset the byte meter on restore */
		int val;	/* current karma value */
		long bytes;	/* total bytes read (in that time period) */
		int max;	/* max karma you can have */
		int inc, dec;	/* how much to increment/decrement */
		int penalty, restore;	/* what penalty (<0) or restore (>0) */
		time_t last_update;	/* time this was last incremented */
	};

	struct karma *karma_new(pool p);	/* creates a new karma object, with default values */
	void karma_copy(struct karma *new, struct karma *old);	/* makes a copy of old in new */
	void karma_increment(struct karma *k);	/* inteligently increments karma */
	void karma_decrement(struct karma *k, long bytes_read);	/* inteligently decrements karma */
	int karma_check(struct karma *k, long bytes_read);	/* checks to see if we have good karma */

/* --------------------------------------------------------- */
/*                                                           */
/* Error structures & constants                              */
/*                                                           */
/* --------------------------------------------------------- */
	typedef struct terror_struct {
		int code;
		char msg[64];
	} terror;

#define TERROR_BAD           (terror){400,"Bad Request"}
#define TERROR_AUTH          (terror){401,"Unauthorized"}
#define TERROR_PAY           (terror){402,"Payment Required"}
#define TERROR_FORBIDDEN     (terror){403,"Forbidden"}
#define TERROR_NOTFOUND      (terror){404,"Not Found"}
#define TERROR_NOTALLOWED    (terror){405,"Not Allowed"}
#define TERROR_NOTACCEPTABLE (terror){406,"Not Acceptable"}
#define TERROR_REGISTER      (terror){407,"Registration Required"}
#define TERROR_REQTIMEOUT    (terror){408,"Request Timeout"}
#define TERROR_CONFLICT      (terror){409,"Conflict"}

#define TERROR_INTERNAL   (terror){500,"Internal Server Error"}
#define TERROR_NOTIMPL    (terror){501,"Not Implemented"}
#define TERROR_EXTERNAL   (terror){502,"Remote Server Error"}
#define TERROR_UNAVAIL    (terror){503,"Service Unavailable"}
#define TERROR_EXTTIMEOUT (terror){504,"Remote Server Timeout"}
#define TERROR_DISCONNECTED (terror){510,"Disconnected"}

/* --------------------------------------------------------- */
/*                                                           */
/* Namespace constants                                       */
/*                                                           */
/* --------------------------------------------------------- */
#define NSCHECK(x,n) (j_strcmp(xmlnode_get_attrib(x,"xmlns"),n) == 0)

#define NS_CLIENT    "jabber:client"
#define NS_SERVER    "jabber:server"
#define NS_AUTH      "jabber:iq:auth"
#define NS_REGISTER  "jabber:iq:register"
#define NS_ROSTER    "jabber:iq:roster"
#define NS_OFFLINE   "jabber:x:offline"
#define NS_AGENT     "jabber:iq:agent"
#define NS_AGENTS    "jabber:iq:agents"
#define NS_DELAY     "jabber:x:delay"
#define NS_VERSION   "jabber:iq:version"
#define NS_TIME      "jabber:iq:time"
#define NS_VCARD     "vcard-temp"
#define NS_PRIVATE   "jabber:iq:private"
#define NS_SEARCH    "jabber:iq:search"
#define NS_OOB       "jabber:iq:oob"
#define NS_XOOB      "jabber:x:oob"
#define NS_ADMIN     "jabber:iq:admin"
#define NS_FILTER    "jabber:iq:filter"
#define NS_AUTH_0K   "jabber:iq:auth:0k"
#define NS_BROWSE    "jabber:iq:browse"
#define NS_EVENT     "jabber:x:event"
#define NS_CONFERENCE "jabber:iq:conference"
#define NS_SIGNED    "jabber:x:signed"
#define NS_ENCRYPTED "jabber:x:encrypted"
#define NS_GATEWAY   "jabber:iq:gateway"
#define NS_LAST      "jabber:iq:last"
#define NS_ENVELOPE  "jabber:x:envelope"
#define NS_EXPIRE    "jabber:x:expire"
#define NS_XHTML     "http://www.w3.org/1999/xhtml"

#define NS_XDBGINSERT "jabber:xdb:ginsert"
#define NS_XDBNSLIST  "jabber:xdb:nslist"

/* --------------------------------------------------------- */
/*                                                           */
/* JUtil functions                                           */
/*                                                           */
/* --------------------------------------------------------- */
	xmlnode jutil_presnew(int type, char *to, char *status);	/* Create a skeleton presence packet */
	xmlnode jutil_iqnew(int type, char *ns);	/* Create a skeleton iq packet */
	xmlnode jutil_msgnew(char *type, char *to, char *subj, char *body);
	/* Create a skeleton message packet */
	xmlnode jutil_header(char *xmlns, char *server);	/* Create a skeleton stream packet */
	int jutil_priority(xmlnode x);	/* Determine priority of this packet */
	void jutil_tofrom(xmlnode x);	/* Swaps to/from fields on a packet */
	xmlnode jutil_iqresult(xmlnode x);	/* Generate a skeleton iq/result, given a iq/query */
	char *jutil_timestamp(void);	/* Get stringified timestamp */
	void jutil_error(xmlnode x, terror E);	/* Append an <error> node to x */
	void jutil_delay(xmlnode msg, char *reason);	/* Append a delay packet to msg */
	char *jutil_regkey(char *key, char *seed);	/* pass a seed to generate a key, pass the key again to validate (returns it) */

#ifdef __cplusplus
}
#endif
#endif				/* INCL_LIB_H */