|
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 unsigned long H[5]; |
|
428 unsigned long W[80]; |
|
429 int lenW; |
|
430 unsigned long 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 */ |