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 */
447