libjabber/libxode.h

   1 #include <string.h>
   2 #include <stdlib.h>
   3 #include <sys/types.h>
   4 #include <stdio.h>
   5 #include <setjmp.h>
   6 #include <sys/stat.h>
   7 #include <fcntl.h>
   8 #include <errno.h>
   9 #include <signal.h>
  10 #include <syslog.h>
  11 #include <strings.h>
  12 #include <unistd.h>
  13 #include <sys/socket.h>
  14 #include <netinet/in.h>
  15 #include <netdb.h>
  16 #include <arpa/inet.h>
  17 #include <sys/time.h>
  18
  19 #include "xmlparse.h"
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif /* HAVE_CONFIG_H */
  23
  24 /*
  25 **  Arrange to use either varargs or stdargs
  26 */
  27
  28 #define MAXSHORTSTR     203             /* max short string length */
  29 #define QUAD_T  unsigned long long
  30
  31 #ifdef __STDC__
  32
  33 #include <stdarg.h>
  34
  35 # define VA_LOCAL_DECL  va_list ap;
  36 # define VA_START(f)    va_start(ap, f)
  37 # define VA_END         va_end(ap)
  38
  39 #else /* __STDC__ */
  40
  41 # include <varargs.h>
  42
  43 # define VA_LOCAL_DECL  va_list ap;
  44 # define VA_START(f)    va_start(ap)
  45 # define VA_END         va_end(ap)
  46
  47 #endif /* __STDC__ */
  48
  49
  50 #ifndef INCL_LIBXODE_H
  51 #define INCL_LIBXODE_H
  52
  53 #ifdef __cplusplus
  54 extern "C" {
  55 #endif
  56
  57
  58 #ifndef HAVE_SNPRINTF
  59 extern int ap_snprintf(char *, size_t, const char *, ...);
  60 #define snprintf ap_snprintf
  61 #endif
  62
  63 #ifndef HAVE_VSNPRINTF
  64 extern int ap_vsnprintf(char *, size_t, const char *, va_list ap);
  65 #define vsnprintf ap_vsnprintf
  66 #endif
  67
  68 #define ZONE zonestr(__FILE__,__LINE__)
  69 char *zonestr(char *file, int line);
  70
  71 /* --------------------------------------------------------- */
  72 /*                                                           */
  73 /* Pool-based memory management routines                     */
  74 /*                                                           */
  75 /* --------------------------------------------------------- */
  76
  77 #undef POOL_DEBUG
  78 /*
  79  flip these, this should be a prime number for top # of pools debugging
  80 #define POOL_DEBUG 40009
  81 */
  82
  83 /* pheap - singular allocation of memory */
  84 struct pheap
  85 {
  86     void *block;
  87     int size, used;
  88 };
  89
  90 /* pool_cleaner - callback type which is associated
  91    with a pool entry; invoked when the pool entry is
  92    free'd */
  93 typedef void (*pool_cleaner)(void *arg);
  94
  95 /* pfree - a linked list node which stores an
  96    allocation chunk, plus a callback */
  97 struct pfree
  98 {
  99     pool_cleaner f;
 100     void *arg;
 101     struct pheap *heap;
 102     struct pfree *next;
 103 };
 104
 105 /* pool - base node for a pool. Maintains a linked list
 106    of pool entries (pfree) */
 107 typedef struct pool_struct
 108 {
 109     int size;
 110     struct pfree *cleanup;
 111     struct pheap *heap;
 112 #ifdef POOL_DEBUG
 113     char name[8], zone[32];
 114     int lsize;
 115 } _pool, *pool;
 116 #define pool_new() _pool_new(ZONE)
 117 #define pool_heap(i) _pool_new_heap(i,ZONE)
 118 #else
 119 } _pool, *pool;
 120 #define pool_heap(i) _pool_new_heap(i,NULL)
 121 #define pool_new() _pool_new(NULL)
 122 #endif
 123
 124 pool _pool_new(char *zone); /* new pool :) */
 125 pool _pool_new_heap(int size, char *zone); /* creates a new memory pool with an initial heap size */
 126 void *pmalloc(pool p, int size); /* wrapper around malloc, takes from the pool, cleaned up automatically */
 127 void *pmalloc_x(pool p, int size, char c); /* Wrapper around pmalloc which prefils buffer with c */
 128 void *pmalloco(pool p, int size); /* YAPW for zeroing the block */
 129 char *pstrdup(pool p, const char *src); /* wrapper around strdup, gains mem from pool */
 130 void pool_stat(int full); /* print to stderr the changed pools and reset */
 131 char *pstrdupx(pool p, const char *src); /* temp stub */
 132 void pool_cleanup(pool p, pool_cleaner f, void *arg); /* calls f(arg) before the pool is freed during cleanup */
 133 void pool_free(pool p); /* calls the cleanup functions, frees all the data on the pool, and deletes the pool itself */
 134 int pool_size(pool p); /* returns total bytes allocated in this pool */
 135
 136
 137
 138
 139 /* --------------------------------------------------------- */
 140 /*                                                           */
 141 /* Socket helper stuff                                       */
 142 /*                                                           */
 143 /* --------------------------------------------------------- */
 144 #ifndef MAXHOSTNAMELEN
 145 #define MAXHOSTNAMELEN 64
 146 #endif
 147
 148 #define NETSOCKET_SERVER 0
 149 #define NETSOCKET_CLIENT 1
 150 #define NETSOCKET_UDP 2
 151
 152 #ifndef WIN32
 153 int make_netsocket(u_short port, char *host, int type, int ssl);
 154 int make_nb_netsocket(u_short port, char *host, int type, int ssl, int * state);
 155 void change_socket_to_blocking(int socket);
 156 struct in_addr *make_addr(char *host);
 157 int set_fd_close_on_exec(int fd, int flag);
 158 #endif
 159
 160
 161 /* --------------------------------------------------------- */
 162 /*                                                           */
 163 /* String management routines                                */
 164 /*                                                           */
 165 /* --------------------------------------------------------- */
 166 char *j_strdup(const char *str); /* provides NULL safe strdup wrapper */
 167 char *j_strcat(char *dest, char *txt); /* strcpy() clone */
 168 int j_strcmp(const char *a, const char *b); /* provides NULL safe strcmp wrapper */
 169 int j_strcasecmp(const char *a, const char *b); /* provides NULL safe strcasecmp wrapper */
 170 int j_strncmp(const char *a, const char *b, int i); /* provides NULL safe strncmp wrapper */
 171 int j_strncasecmp(const char *a, const char *b, int i); /* provides NULL safe strncasecmp wrapper */
 172 int j_strlen(const char *a); /* provides NULL safe strlen wrapper */
 173 int j_atoi(const char *a, int def); /* checks for NULL and uses default instead, convienence */
 174 void str_b64decode(char *str); /* what it says */
 175
 176
 177 /* --------------------------------------------------------- */
 178 /*                                                           */
 179 /* SHA calculations                                          */
 180 /*                                                           */
 181 /* --------------------------------------------------------- */
 182 #if (SIZEOF_INT == 4)
 183 typedef unsigned int uint32;
 184 #elif (SIZEOF_SHORT == 4)
 185 typedef unsigned short uint32;
 186 #else
 187 typedef unsigned int uint32;
 188 #endif /* HAVEUINT32 */
 189
 190 int sha_hash(int *data, int *hash);
 191 int sha_init(int *hash);
 192 char *shahash(char *str);       /* NOT THREAD SAFE */
 193 void shahash_r(const char* str, char hashbuf[40]); /* USE ME */
 194
 195 int strprintsha(char *dest, int *hashval);
 196
 197
 198 /* --------------------------------------------------------- */
 199 /*                                                           */
 200 /* Hashtable functions                                       */
 201 /*                                                           */
 202 /* --------------------------------------------------------- */
 203 typedef int (*KEYHASHFUNC)(const void *key);
 204 typedef int (*KEYCOMPAREFUNC)(const void *key1, const void *key2);
 205 typedef int (*TABLEWALKFUNC)(void *user_data, const void *key, void *data);
 206
 207 typedef void *HASHTABLE;
 208
 209 HASHTABLE ghash_create(int buckets, KEYHASHFUNC hash, KEYCOMPAREFUNC cmp);
 210 void ghash_destroy(HASHTABLE tbl);
 211 void *ghash_get(HASHTABLE tbl, const void *key);
 212 int ghash_put(HASHTABLE tbl, const void *key, void *value);
 213 int ghash_remove(HASHTABLE tbl, const void *key);
 214 int ghash_walk(HASHTABLE tbl, TABLEWALKFUNC func, void *user_data);
 215 int str_hash_code(const char *s);
 216
 217
 218 /* --------------------------------------------------------- */
 219 /*                                                           */
 220 /* XML escaping utils                                        */
 221 /*                                                           */
 222 /* --------------------------------------------------------- */
 223 char *strescape(pool p, char *buf); /* Escape <>&'" chars */
 224 char *strunescape(pool p, char *buf);
 225
 226
 227 /* --------------------------------------------------------- */
 228 /*                                                           */
 229 /* String pools (spool) functions                            */
 230 /*                                                           */
 231 /* --------------------------------------------------------- */
 232 struct spool_node
 233 {
 234     char *c;
 235     struct spool_node *next;
 236 };
 237
 238 typedef struct spool_struct
 239 {
 240     pool p;
 241     int len;
 242     struct spool_node *last;
 243     struct spool_node *first;
 244 } *spool;
 245
 246 spool spool_new(pool p); /* create a string pool */
 247 void spooler(spool s, ...); /* append all the char * args to the pool, terminate args with s again */
 248 char *spool_print(spool s); /* return a big string */
 249 void spool_add(spool s, char *str); /* add a single char to the pool */
 250 char *spools(pool p, ...); /* wrap all the spooler stuff in one function, the happy fun ball! */
 251
 252
 253 /* --------------------------------------------------------- */
 254 /*                                                           */
 255 /* xmlnodes - Document Object Model                          */
 256 /*                                                           */
 257 /* --------------------------------------------------------- */
 258 #define NTYPE_TAG    0
 259 #define NTYPE_ATTRIB 1
 260 #define NTYPE_CDATA  2
 261
 262 #define NTYPE_LAST   2
 263 #define NTYPE_UNDEF  -1
 264
 265 /* --------------------------------------------------------------------------
 266    Node structure. Do not use directly! Always use accessor macros
 267    and methods!
 268    -------------------------------------------------------------------------- */
 269 typedef struct xmlnode_t
 270 {
 271      char*               name;
 272      unsigned short      type;
 273      char*               data;
 274      int                 data_sz;
 275      int                 complete;
 276      pool               p;
 277      struct xmlnode_t*  parent;
 278      struct xmlnode_t*  firstchild;
 279      struct xmlnode_t*  lastchild;
 280      struct xmlnode_t*  prev;
 281      struct xmlnode_t*  next;
 282      struct xmlnode_t*  firstattrib;
 283      struct xmlnode_t*  lastattrib;
 284 } _xmlnode, *xmlnode;
 285
 286 /* Node creation routines */
 287 xmlnode  xmlnode_wrap(xmlnode x,const char* wrapper);
 288 xmlnode  xmlnode_new_tag(const char* name);
 289 xmlnode  xmlnode_new_tag_pool(pool p, const char* name);
 290 xmlnode  xmlnode_insert_tag(xmlnode parent, const char* name);
 291 xmlnode  xmlnode_insert_cdata(xmlnode parent, const char* CDATA, unsigned int size);
 292 xmlnode  xmlnode_insert_tag_node(xmlnode parent, xmlnode node);
 293 void     xmlnode_insert_node(xmlnode parent, xmlnode node);
 294 xmlnode  xmlnode_str(char *str, int len);
 295 xmlnode  xmlnode_file(char *file);
 296 xmlnode  xmlnode_dup(xmlnode x); /* duplicate x */
 297 xmlnode  xmlnode_dup_pool(pool p, xmlnode x);
 298
 299 /* Node Memory Pool */
 300 pool xmlnode_pool(xmlnode node);
 301 xmlnode _xmlnode_new(pool p, const char *name, unsigned int type);
 302
 303 /* Node editing */
 304 void xmlnode_hide(xmlnode child);
 305 void xmlnode_hide_attrib(xmlnode parent, const char *name);
 306
 307 /* Node deletion routine, also frees the node pool! */
 308 void xmlnode_free(xmlnode node);
 309
 310 /* Locates a child tag by name and returns it */
 311 xmlnode  xmlnode_get_tag(xmlnode parent, const char* name);
 312 char* xmlnode_get_tag_data(xmlnode parent, const char* name);
 313
 314 /* Attribute accessors */
 315 void     xmlnode_put_attrib(xmlnode owner, const char* name, const char* value);
 316 char*    xmlnode_get_attrib(xmlnode owner, const char* name);
 317 void     xmlnode_put_expat_attribs(xmlnode owner, const char** atts);
 318
 319 /* Bastard am I, but these are fun for internal use ;-) */
 320 void     xmlnode_put_vattrib(xmlnode owner, const char* name, void *value);
 321 void*    xmlnode_get_vattrib(xmlnode owner, const char* name);
 322
 323 /* Node traversal routines */
 324 xmlnode  xmlnode_get_firstattrib(xmlnode parent);
 325 xmlnode  xmlnode_get_firstchild(xmlnode parent);
 326 xmlnode  xmlnode_get_lastchild(xmlnode parent);
 327 xmlnode  xmlnode_get_nextsibling(xmlnode sibling);
 328 xmlnode  xmlnode_get_prevsibling(xmlnode sibling);
 329 xmlnode  xmlnode_get_parent(xmlnode node);
 330
 331 /* Node information routines */
 332 char*    xmlnode_get_name(xmlnode node);
 333 char*    xmlnode_get_data(xmlnode node);
 334 int      xmlnode_get_datasz(xmlnode node);
 335 int      xmlnode_get_type(xmlnode node);
 336
 337 int      xmlnode_has_children(xmlnode node);
 338 int      xmlnode_has_attribs(xmlnode node);
 339
 340 /* Node-to-string translation */
 341 char*    xmlnode2str(xmlnode node);
 342
 343 /* Node-to-terminated-string translation
 344    -- useful for interfacing w/ scripting langs */
 345 char*    xmlnode2tstr(xmlnode node);
 346
 347 int      xmlnode_cmp(xmlnode a, xmlnode b); /* compares a and b for equality */
 348
 349 int      xmlnode2file(char *file, xmlnode node); /* writes node to file */
 350
 351 /* Expat callbacks */
 352 void expat_startElement(void* userdata, const char* name, const char** atts);
 353 void expat_endElement(void* userdata, const char* name);
 354 void expat_charData(void* userdata, const char* s, int len);
 355
 356 /***********************
 357  * XSTREAM Section
 358  ***********************/
 359
 360 #define XSTREAM_MAXNODE 1000000
 361 #define XSTREAM_MAXDEPTH 100
 362
 363 #define XSTREAM_ROOT        0 /* root element */
 364 #define XSTREAM_NODE        1 /* normal node */
 365 #define XSTREAM_CLOSE       2 /* closed </stream:stream> */
 366 #define XSTREAM_ERR         4 /* parser error */
 367
 368 typedef void (*xstream_onNode)(int type, xmlnode x, void *arg); /* xstream event handler */
 369
 370 typedef struct xstream_struct
 371 {
 372     XML_Parser parser;
 373     xmlnode node;
 374     char *cdata;
 375     int cdata_len;
 376     pool p;
 377     xstream_onNode f;
 378     void *arg;
 379     int status;
 380     int depth;
 381 } *xstream, _xstream;
 382
 383 xstream xstream_new(pool p, xstream_onNode f, void *arg); /* create a new xstream */
 384 int xstream_eat(xstream xs, char *buff, int len); /* parse new data for this xstream, returns last XSTREAM_* status */
 385
 386 /* convience functions */
 387 xmlnode xstream_header(char *nspace, char *to, char *from);
 388 char *xstream_header_char(xmlnode x);
 389
 390 /* SHA.H */
 391 /*
 392  * The contents of this file are subject to the Mozilla Public
 393  * License Version 1.1 (the "License"); you may not use this file
 394  * except in compliance with the License. You may obtain a copy of
 395  * the License at http://www.mozilla.org/MPL/
 396  *
 397  * Software distributed under the License is distributed on an "AS
 398  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 399  * implied. See the License for the specific language governing
 400  * rights and limitations under the License.
 401  *
 402  * The Original Code is SHA 180-1 Header File
 403  *
 404  * The Initial Developer of the Original Code is Paul Kocher of
 405  * Cryptography Research.  Portions created by Paul Kocher are
 406  * Copyright (C) 1995-9 by Cryptography Research, Inc.  All
 407  * Rights Reserved.
 408  *
 409  * Contributor(s):
 410  *
 411  *     Paul Kocher
 412  *
 413  * Alternatively, the contents of this file may be used under the
 414  * terms of the GNU General Public License Version 2 or later (the
 415  * "GPL"), in which case the provisions of the GPL are applicable
 416  * instead of those above.  If you wish to allow use of your
 417  * version of this file only under the terms of the GPL and not to
 418  * allow others to use your version of this file under the MPL,
 419  * indicate your decision by deleting the provisions above and
 420  * replace them with the notice and other provisions required by
 421  * the GPL.  If you do not delete the provisions above, a recipient
 422  * may use your version of this file under either the MPL or the
 423  * GPL.
 424  */
 425
 426 typedef struct {
 427   uint32_t H[5];
 428   uint32_t W[80];
 429   int lenW;
 430   uint32_t sizeHi,sizeLo;
 431 } SHA_CTX;
 432
 433
 434 void shaInit(SHA_CTX *ctx);
 435 void shaUpdate(SHA_CTX *ctx, unsigned char *dataIn, int len);
 436 void shaFinal(SHA_CTX *ctx, unsigned char hashout[20]);
 437 void shaBlock(unsigned char *dataIn, int len, unsigned char hashout[20]);
 438
 439
 440 /* END SHA.H */
 441
 442 #ifdef __cplusplus
 443 }
 444 #endif
 445
 446 #endif /* INCL_LIBXODE_H */