Mercurial > repos > ktnyt > gembassy

comparison GEMBASSY-1.0.3/gsoap/stdsoap2.c @ 0:8300eb051bea draft

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial upload
author ktnyt
date Fri, 26 Jun 2015 05:19:29 -0400
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:8300eb051bea
1 /*
2 stdsoap2.c[pp] 2.8.17r
3
4 gSOAP runtime engine
5
6 gSOAP XML Web services tools
7 Copyright (C) 2000-2013, Robert van Engelen, Genivia Inc., All Rights Reserved.
8 This part of the software is released under ONE of the following licenses:
9 GPL, or the gSOAP public license, or Genivia's license for commercial use.
10 --------------------------------------------------------------------------------
11 Contributors:
12
13 Wind River Systems Inc., for the following additions under gSOAP public license:
14 - vxWorks compatible options
15 --------------------------------------------------------------------------------
16 gSOAP public license.
17
18 The contents of this file are subject to the gSOAP Public License Version 1.3
19 (the "License"); you may not use this file except in compliance with the
20 License. You may obtain a copy of the License at
21 http://www.cs.fsu.edu/~engelen/soaplicense.html
22 Software distributed under the License is distributed on an "AS IS" basis,
23 WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
24 for the specific language governing rights and limitations under the License.
25
26 The Initial Developer of the Original Code is Robert A. van Engelen.
27 Copyright (C) 2000-2013, Robert van Engelen, Genivia Inc., All Rights Reserved.
28 --------------------------------------------------------------------------------
29 GPL license.
30
31 This program is free software; you can redistribute it and/or modify it under
32 the terms of the GNU General Public License as published by the Free Software
33 Foundation; either version 2 of the License, or (at your option) any later
34 version.
35
36 This program is distributed in the hope that it will be useful, but WITHOUT ANY
37 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
38 PARTICULAR PURPOSE. See the GNU General Public License for more details.
39
40 You should have received a copy of the GNU General Public License along with
41 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
42 Place, Suite 330, Boston, MA 02111-1307 USA
43
44 Author contact information:
45 engelen@genivia.com / engelen@acm.org
46
47 This program is released under the GPL with the additional exemption that
48 compiling, linking, and/or using OpenSSL is allowed.
49 --------------------------------------------------------------------------------
50 A commercial use license is available from Genivia, Inc., contact@genivia.com
51 --------------------------------------------------------------------------------
52 */
53
54 #define GSOAP_LIB_VERSION 20817
55
56 #ifdef AS400
57 # pragma convert(819) /* EBCDIC to ASCII */
58 #endif
59
60 #include "stdsoap2.h"
61 #if defined(VXWORKS) && defined(WM_SECURE_KEY_STORAGE)
62 #include <ipcom_key_db.h>
63 #endif
64 #if GSOAP_VERSION != GSOAP_LIB_VERSION
65 # error "GSOAP VERSION MISMATCH IN LIBRARY: PLEASE REINSTALL PACKAGE"
66 #endif
67
68 #ifdef __BORLANDC__
69 # pragma warn -8060
70 #else
71 # ifdef WIN32
72 # ifdef UNDER_CE
73 # pragma comment(lib, "ws2.lib") /* WinCE */
74 # else
75 # pragma comment(lib, "ws2_32.lib")
76 # endif
77 # pragma warning(disable : 4996) /* disable deprecation warnings */
78 # endif
79 #endif
80
81 #ifdef __cplusplus
82 SOAP_SOURCE_STAMP("@(#) stdsoap2.cpp ver 2.8.17r 2013-12-18 00:00:00 GMT")
83 extern "C" {
84 #else
85 SOAP_SOURCE_STAMP("@(#) stdsoap2.c ver 2.8.17r 2013-12-18 00:00:00 GMT")
86 #endif
87
88 /* 8bit character representing unknown/nonrepresentable character data (e.g. not supported by current locale with multibyte support enabled) */
89 #ifndef SOAP_UNKNOWN_CHAR
90 #define SOAP_UNKNOWN_CHAR (127)
91 #endif
92
93 /* EOF=-1 */
94 #define SOAP_LT (soap_wchar)(-2) /* XML-specific '<' */
95 #define SOAP_TT (soap_wchar)(-3) /* XML-specific '</' */
96 #define SOAP_GT (soap_wchar)(-4) /* XML-specific '>' */
97 #define SOAP_QT (soap_wchar)(-5) /* XML-specific '"' */
98 #define SOAP_AP (soap_wchar)(-6) /* XML-specific ''' */
99
100 #define soap_blank(c) ((c)+1 > 0 && (c) <= 32)
101 #define soap_notblank(c) ((c) > 32)
102
103 #if defined(WIN32) && !defined(UNDER_CE)
104 #define soap_hash_ptr(p) ((PtrToUlong(p) >> 3) & (SOAP_PTRHASH - 1))
105 #else
106 #define soap_hash_ptr(p) ((size_t)(((unsigned long)(p) >> 3) & (SOAP_PTRHASH-1)))
107 #endif
108
109 #if !defined(WITH_LEAN) || defined(SOAP_DEBUG)
110 static void soap_init_logs(struct soap*);
111 #endif
112 #ifdef SOAP_DEBUG
113 static void soap_close_logfile(struct soap*, int);
114 static void soap_set_logfile(struct soap*, int, const char*);
115 #endif
116
117 #ifdef SOAP_MEM_DEBUG
118 static void soap_init_mht(struct soap*);
119 static void soap_free_mht(struct soap*);
120 static void soap_track_unlink(struct soap*, const void*);
121 #endif
122
123 #ifndef PALM_2
124 static int soap_set_error(struct soap*, const char*, const char*, const char*, const char*, int);
125 static int soap_copy_fault(struct soap*, const char*, const char*, const char*, const char*);
126 static int soap_getattrval(struct soap*, char*, size_t, soap_wchar);
127 #endif
128
129 #ifndef PALM_1
130 static void soap_free_ns(struct soap *soap);
131 static soap_wchar soap_char(struct soap*);
132 static soap_wchar soap_get_pi(struct soap*);
133 static int soap_isxdigit(int);
134 static void *fplugin(struct soap*, const char*);
135 static size_t soap_count_attachments(struct soap *soap);
136 static int soap_try_connect_command(struct soap*, int http_command, const char *endpoint, const char *action);
137 #ifdef WITH_NTLM
138 static int soap_ntlm_handshake(struct soap *soap, int command, const char *endpoint, const char *host, int port);
139 #endif
140 #ifndef WITH_NOIDREF
141 static int soap_has_copies(struct soap*, const char*, const char*);
142 static void soap_init_iht(struct soap*);
143 static void soap_free_iht(struct soap*);
144 static void soap_init_pht(struct soap*);
145 static void soap_free_pht(struct soap*);
146 #endif
147 #endif
148
149 #ifndef WITH_LEAN
150 static const char *soap_set_validation_fault(struct soap*, const char*, const char*);
151 static int soap_isnumeric(struct soap*, const char*);
152 static struct soap_nlist *soap_push_ns(struct soap *soap, const char *id, const char *ns, short utilized);
153 static void soap_utilize_ns(struct soap *soap, const char *tag);
154 #endif
155
156 #ifndef WITH_LEANER
157 #ifndef PALM_1
158 static struct soap_multipart *soap_new_multipart(struct soap*, struct soap_multipart**, struct soap_multipart**, char*, size_t);
159 static int soap_putdimefield(struct soap*, const char*, size_t);
160 static char *soap_getdimefield(struct soap*, size_t);
161 static void soap_select_mime_boundary(struct soap*);
162 static int soap_valid_mime_boundary(struct soap*);
163 static void soap_resolve_attachment(struct soap*, struct soap_multipart*);
164 #endif
165 #endif
166
167 #ifdef WITH_GZIP
168 static int soap_getgziphdr(struct soap*);
169 #endif
170
171 #ifdef WITH_OPENSSL
172 # ifndef SOAP_SSL_RSA_BITS
173 # define SOAP_SSL_RSA_BITS 2048
174 # endif
175 static int soap_ssl_init_done = 0;
176 static int ssl_auth_init(struct soap*);
177 static int ssl_verify_callback(int, X509_STORE_CTX*);
178 static int ssl_verify_callback_allow_expired_certificate(int, X509_STORE_CTX*);
179 static int ssl_password(char*, int, int, void *);
180 #endif
181
182 #ifdef WITH_GNUTLS
183 # ifndef SOAP_SSL_RSA_BITS
184 # define SOAP_SSL_RSA_BITS 2048
185 # endif
186 static int soap_ssl_init_done = 0;
187 static const char *ssl_verify(struct soap *soap, const char *host);
188 # if defined(HAVE_PTHREAD_H)
189 # include <pthread.h>
190 /* make GNUTLS thread safe with pthreads */
191 GCRY_THREAD_OPTION_PTHREAD_IMPL;
192 # elif defined(HAVE_PTH_H)
193 #include <pth.h>
194 /* make GNUTLS thread safe with PTH */
195 GCRY_THREAD_OPTION_PTH_IMPL;
196 # endif
197 #endif
198
199 #if !defined(WITH_NOHTTP) || !defined(WITH_LEANER)
200 #ifndef PALM_1
201 static const char *soap_decode(char*, size_t, const char*, const char*);
202 #endif
203 #endif
204
205 #ifndef WITH_NOHTTP
206 #ifndef PALM_1
207 static soap_wchar soap_getchunkchar(struct soap*);
208 static const char *http_error(struct soap*, int);
209 static int http_get(struct soap*);
210 static int http_405(struct soap*);
211 static int http_200(struct soap*);
212 static int http_post(struct soap*, const char*, const char*, int, const char*, const char*, size_t);
213 static int http_send_header(struct soap*, const char*);
214 static int http_post_header(struct soap*, const char*, const char*);
215 static int http_response(struct soap*, int, size_t);
216 static int http_parse(struct soap*);
217 static int http_parse_header(struct soap*, const char*, const char*);
218 #endif
219 #endif
220
221 #ifndef WITH_NOIO
222
223 #ifndef PALM_1
224 static int fsend(struct soap*, const char*, size_t);
225 static size_t frecv(struct soap*, char*, size_t);
226 static int tcp_init(struct soap*);
227 static const char *tcp_error(struct soap*);
228 #ifndef WITH_IPV6
229 static int tcp_gethost(struct soap*, const char *addr, struct in_addr *inaddr);
230 #endif
231 static SOAP_SOCKET tcp_connect(struct soap*, const char *endpoint, const char *host, int port);
232 static SOAP_SOCKET tcp_accept(struct soap*, SOAP_SOCKET, struct sockaddr*, int*);
233 static int tcp_select(struct soap*, SOAP_SOCKET, int, int);
234 static int tcp_disconnect(struct soap*);
235 static int tcp_closesocket(struct soap*, SOAP_SOCKET);
236 static int tcp_shutdownsocket(struct soap*, SOAP_SOCKET, int);
237 static const char *soap_strerror(struct soap*);
238 #endif
239
240 #define SOAP_TCP_SELECT_RCV 0x1
241 #define SOAP_TCP_SELECT_SND 0x2
242 #define SOAP_TCP_SELECT_ERR 0x4
243 #define SOAP_TCP_SELECT_ALL 0x7
244
245 #if defined(WIN32)
246 #define SOAP_SOCKBLOCK(fd) \
247 { u_long blocking = 0; \
248 ioctlsocket(fd, FIONBIO, &blocking); \
249 }
250 #define SOAP_SOCKNONBLOCK(fd) \
251 { u_long nonblocking = 1; \
252 ioctlsocket(fd, FIONBIO, &nonblocking); \
253 }
254 #elif defined(VXWORKS)
255 #define SOAP_SOCKBLOCK(fd) \
256 { u_long blocking = 0; \
257 ioctl(fd, FIONBIO, (int)(&blocking)); \
258 }
259 #define SOAP_SOCKNONBLOCK(fd) \
260 { u_long nonblocking = 1; \
261 ioctl(fd, FIONBIO, (int)(&nonblocking)); \
262 }
263 #elif defined(__VMS)
264 #define SOAP_SOCKBLOCK(fd) \
265 { int blocking = 0; \
266 ioctl(fd, FIONBIO, &blocking); \
267 }
268 #define SOAP_SOCKNONBLOCK(fd) \
269 { int nonblocking = 1; \
270 ioctl(fd, FIONBIO, &nonblocking); \
271 }
272 #elif defined(PALM)
273 #define SOAP_SOCKBLOCK(fd) fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0)&~O_NONBLOCK);
274 #define SOAP_SOCKNONBLOCK(fd) fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0)|O_NONBLOCK);
275 #elif defined(SYMBIAN)
276 #define SOAP_SOCKBLOCK(fd) \
277 { long blocking = 0; \
278 ioctl(fd, 0/*FIONBIO*/, &blocking); \
279 }
280 #define SOAP_SOCKNONBLOCK(fd) \
281 { long nonblocking = 1; \
282 ioctl(fd, 0/*FIONBIO*/, &nonblocking); \
283 }
284 #else
285 #define SOAP_SOCKBLOCK(fd) fcntl(fd, F_SETFL, fcntl(fd, F_GETFL)&~O_NONBLOCK);
286 #define SOAP_SOCKNONBLOCK(fd) fcntl(fd, F_SETFL, fcntl(fd, F_GETFL)|O_NONBLOCK);
287 #endif
288
289 #endif
290
291 #if defined(PALM) && !defined(PALM_2)
292 unsigned short errno;
293 #endif
294
295 #ifndef PALM_1
296 static const char soap_env1[42] = "http://schemas.xmlsoap.org/soap/envelope/";
297 static const char soap_enc1[42] = "http://schemas.xmlsoap.org/soap/encoding/";
298 static const char soap_env2[40] = "http://www.w3.org/2003/05/soap-envelope";
299 static const char soap_enc2[40] = "http://www.w3.org/2003/05/soap-encoding";
300 static const char soap_rpc[35] = "http://www.w3.org/2003/05/soap-rpc";
301 #endif
302
303 #ifndef PALM_1
304 const union soap_double_nan soap_double_nan = {{0xFFFFFFFF, 0xFFFFFFFF}};
305 const char soap_base64o[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
306 const char soap_base64i[81] = "\76XXX\77\64\65\66\67\70\71\72\73\74\75XXXXXXX\00\01\02\03\04\05\06\07\10\11\12\13\14\15\16\17\20\21\22\23\24\25\26\27\30\31XXXXXX\32\33\34\35\36\37\40\41\42\43\44\45\46\47\50\51\52\53\54\55\56\57\60\61\62\63";
307 #endif
308
309 #ifndef WITH_LEAN
310 static const char soap_indent[11] = "\n\t\t\t\t\t\t\t\t\t";
311 /* Alternative indentation form for SOAP_XML_INDENT:
312 static const char soap_indent[21] = "\n ";
313 */
314 #endif
315
316 #ifndef SOAP_CANARY
317 # define SOAP_CANARY (0xC0DE)
318 #endif
319
320 static const char soap_padding[4] = "\0\0\0";
321 #define SOAP_STR_PADDING (soap_padding)
322 #define SOAP_STR_EOS (soap_padding)
323 #define SOAP_NON_NULL (soap_padding)
324
325 #ifndef WITH_LEAN
326 static const struct soap_code_map html_entity_codes[] = /* entities for XHTML parsing */
327 { { 160, "nbsp" },
328 { 161, "iexcl" },
329 { 162, "cent" },
330 { 163, "pound" },
331 { 164, "curren" },
332 { 165, "yen" },
333 { 166, "brvbar" },
334 { 167, "sect" },
335 { 168, "uml" },
336 { 169, "copy" },
337 { 170, "ordf" },
338 { 171, "laquo" },
339 { 172, "not" },
340 { 173, "shy" },
341 { 174, "reg" },
342 { 175, "macr" },
343 { 176, "deg" },
344 { 177, "plusmn" },
345 { 178, "sup2" },
346 { 179, "sup3" },
347 { 180, "acute" },
348 { 181, "micro" },
349 { 182, "para" },
350 { 183, "middot" },
351 { 184, "cedil" },
352 { 185, "sup1" },
353 { 186, "ordm" },
354 { 187, "raquo" },
355 { 188, "frac14" },
356 { 189, "frac12" },
357 { 190, "frac34" },
358 { 191, "iquest" },
359 { 192, "Agrave" },
360 { 193, "Aacute" },
361 { 194, "Acirc" },
362 { 195, "Atilde" },
363 { 196, "Auml" },
364 { 197, "Aring" },
365 { 198, "AElig" },
366 { 199, "Ccedil" },
367 { 200, "Egrave" },
368 { 201, "Eacute" },
369 { 202, "Ecirc" },
370 { 203, "Euml" },
371 { 204, "Igrave" },
372 { 205, "Iacute" },
373 { 206, "Icirc" },
374 { 207, "Iuml" },
375 { 208, "ETH" },
376 { 209, "Ntilde" },
377 { 210, "Ograve" },
378 { 211, "Oacute" },
379 { 212, "Ocirc" },
380 { 213, "Otilde" },
381 { 214, "Ouml" },
382 { 215, "times" },
383 { 216, "Oslash" },
384 { 217, "Ugrave" },
385 { 218, "Uacute" },
386 { 219, "Ucirc" },
387 { 220, "Uuml" },
388 { 221, "Yacute" },
389 { 222, "THORN" },
390 { 223, "szlig" },
391 { 224, "agrave" },
392 { 225, "aacute" },
393 { 226, "acirc" },
394 { 227, "atilde" },
395 { 228, "auml" },
396 { 229, "aring" },
397 { 230, "aelig" },
398 { 231, "ccedil" },
399 { 232, "egrave" },
400 { 233, "eacute" },
401 { 234, "ecirc" },
402 { 235, "euml" },
403 { 236, "igrave" },
404 { 237, "iacute" },
405 { 238, "icirc" },
406 { 239, "iuml" },
407 { 240, "eth" },
408 { 241, "ntilde" },
409 { 242, "ograve" },
410 { 243, "oacute" },
411 { 244, "ocirc" },
412 { 245, "otilde" },
413 { 246, "ouml" },
414 { 247, "divide" },
415 { 248, "oslash" },
416 { 249, "ugrave" },
417 { 250, "uacute" },
418 { 251, "ucirc" },
419 { 252, "uuml" },
420 { 253, "yacute" },
421 { 254, "thorn" },
422 { 255, "yuml" },
423 { 0, NULL }
424 };
425 #endif
426
427 #ifndef WITH_NOIO
428 #ifndef WITH_LEAN
429 static const struct soap_code_map h_error_codes[] =
430 {
431 #ifdef HOST_NOT_FOUND
432 { HOST_NOT_FOUND, "Host not found" },
433 #endif
434 #ifdef TRY_AGAIN
435 { TRY_AGAIN, "Try Again" },
436 #endif
437 #ifdef NO_RECOVERY
438 { NO_RECOVERY, "No Recovery" },
439 #endif
440 #ifdef NO_DATA
441 { NO_DATA, "No Data" },
442 #endif
443 #ifdef NO_ADDRESS
444 { NO_ADDRESS, "No Address" },
445 #endif
446 { 0, NULL }
447 };
448 #endif
449 #endif
450
451 #ifndef WITH_NOHTTP
452 #ifndef WITH_LEAN
453 static const struct soap_code_map h_http_error_codes[] =
454 { { 200, "OK" },
455 { 201, "Created" },
456 { 202, "Accepted" },
457 { 203, "Non-Authoritative Information" },
458 { 204, "No Content" },
459 { 205, "Reset Content" },
460 { 206, "Partial Content" },
461 { 300, "Multiple Choices" },
462 { 301, "Moved Permanently" },
463 { 302, "Found" },
464 { 303, "See Other" },
465 { 304, "Not Modified" },
466 { 305, "Use Proxy" },
467 { 307, "Temporary Redirect" },
468 { 400, "Bad Request" },
469 { 401, "Unauthorized" },
470 { 402, "Payment Required" },
471 { 403, "Forbidden" },
472 { 404, "Not Found" },
473 { 405, "Method Not Allowed" },
474 { 406, "Not Acceptable" },
475 { 407, "Proxy Authentication Required" },
476 { 408, "Request Time-out" },
477 { 409, "Conflict" },
478 { 410, "Gone" },
479 { 411, "Length Required" },
480 { 412, "Precondition Failed" },
481 { 413, "Request Entity Too Large" },
482 { 414, "Request-URI Too Large" },
483 { 415, "Unsupported Media Type" },
484 { 416, "Requested range not satisfiable" },
485 { 417, "Expectation Failed" },
486 { 500, "Internal Server Error" },
487 { 501, "Not Implemented" },
488 { 502, "Bad Gateway" },
489 { 503, "Service Unavailable" },
490 { 504, "Gateway Time-out" },
491 { 505, "HTTP Version not supported" },
492 { 0, NULL }
493 };
494 #endif
495 #endif
496
497 #ifdef WITH_OPENSSL
498 static const struct soap_code_map h_ssl_error_codes[] =
499 {
500 #define _SSL_ERROR(e) { e, #e }
501 _SSL_ERROR(SSL_ERROR_SSL),
502 _SSL_ERROR(SSL_ERROR_ZERO_RETURN),
503 _SSL_ERROR(SSL_ERROR_WANT_READ),
504 _SSL_ERROR(SSL_ERROR_WANT_WRITE),
505 _SSL_ERROR(SSL_ERROR_WANT_CONNECT),
506 _SSL_ERROR(SSL_ERROR_WANT_X509_LOOKUP),
507 _SSL_ERROR(SSL_ERROR_SYSCALL),
508 { 0, NULL }
509 };
510 #endif
511
512 #ifndef WITH_LEANER
513 static const struct soap_code_map mime_codes[] =
514 { { SOAP_MIME_7BIT, "7bit" },
515 { SOAP_MIME_8BIT, "8bit" },
516 { SOAP_MIME_BINARY, "binary" },
517 { SOAP_MIME_QUOTED_PRINTABLE, "quoted-printable" },
518 { SOAP_MIME_BASE64, "base64" },
519 { SOAP_MIME_IETF_TOKEN, "ietf-token" },
520 { SOAP_MIME_X_TOKEN, "x-token" },
521 { 0, NULL }
522 };
523 #endif
524
525 #ifdef WIN32
526 static int tcp_done = 0;
527 #endif
528
529 #if defined(HP_UX) && defined(HAVE_GETHOSTBYNAME_R)
530 extern int h_errno;
531 #endif
532
533 /******************************************************************************/
534 #ifndef WITH_NOIO
535 #ifndef PALM_1
536 static int
537 fsend(struct soap *soap, const char *s, size_t n)
538 { register int nwritten, err;
539 SOAP_SOCKET sk;
540 #if defined(__cplusplus) && !defined(WITH_LEAN) && !defined(WITH_COMPAT)
541 if (soap->os)
542 { soap->os->write(s, (std::streamsize)n);
543 if (soap->os->good())
544 return SOAP_OK;
545 soap->errnum = 0;
546 return SOAP_EOF;
547 }
548 #endif
549 sk = soap->sendsk;
550 if (!soap_valid_socket(sk))
551 sk = soap->socket;
552 while (n)
553 { if (soap_valid_socket(sk))
554 {
555 if (soap->send_timeout)
556 { for (;;)
557 { register int r;
558 #ifdef WITH_OPENSSL
559 if (soap->ssl)
560 r = tcp_select(soap, sk, SOAP_TCP_SELECT_ALL, soap->send_timeout);
561 else
562 #endif
563 #ifdef WITH_GNUTLS
564 if (soap->session)
565 r = tcp_select(soap, sk, SOAP_TCP_SELECT_ALL, soap->send_timeout);
566 else
567 #endif
568 r = tcp_select(soap, sk, SOAP_TCP_SELECT_SND | SOAP_TCP_SELECT_ERR, soap->send_timeout);
569 if (r > 0)
570 break;
571 if (!r)
572 return SOAP_EOF;
573 err = soap->errnum;
574 if (!err)
575 return soap->error;
576 if (err != SOAP_EAGAIN && err != SOAP_EWOULDBLOCK)
577 return SOAP_EOF;
578 }
579 }
580 #ifdef WITH_OPENSSL
581 if (soap->ssl)
582 nwritten = SSL_write(soap->ssl, s, (int)n);
583 else if (soap->bio)
584 nwritten = BIO_write(soap->bio, s, (int)n);
585 else
586 #endif
587 #ifdef WITH_GNUTLS
588 if (soap->session)
589 nwritten = gnutls_record_send(soap->session, s, n);
590 else
591 #endif
592 #ifndef WITH_LEAN
593 if ((soap->omode & SOAP_IO_UDP))
594 { if (soap->peerlen)
595 nwritten = sendto(sk, (char*)s, (SOAP_WINSOCKINT)n, soap->socket_flags, (struct sockaddr*)&soap->peer, (SOAP_WINSOCKINT)soap->peerlen);
596 else
597 nwritten = send(sk, s, (SOAP_WINSOCKINT)n, soap->socket_flags);
598 /* retry and back-off algorithm */
599 /* TODO: this is not very clear from specs so verify and limit conditions under which we should loop (e.g. ENOBUFS) */
600 if (nwritten < 0)
601 { int udp_repeat;
602 int udp_delay;
603 if ((soap->connect_flags & SO_BROADCAST))
604 udp_repeat = 2; /* SOAP-over-UDP MULTICAST_UDP_REPEAT - 1 */
605 else
606 udp_repeat = 1; /* SOAP-over-UDP UNICAST_UDP_REPEAT - 1 */
607 udp_delay = ((unsigned int)soap_random % 201) + 50; /* UDP_MIN_DELAY .. UDP_MAX_DELAY */
608 do
609 { tcp_select(soap, sk, SOAP_TCP_SELECT_ERR, -1000 * udp_delay);
610 if (soap->peerlen)
611 nwritten = sendto(sk, (char*)s, (SOAP_WINSOCKINT)n, soap->socket_flags, (struct sockaddr*)&soap->peer, (SOAP_WINSOCKINT)soap->peerlen);
612 else
613 nwritten = send(sk, s, (SOAP_WINSOCKINT)n, soap->socket_flags);
614 udp_delay <<= 1;
615 if (udp_delay > 500) /* UDP_UPPER_DELAY */
616 udp_delay = 500;
617 }
618 while (nwritten < 0 && --udp_repeat > 0);
619 }
620 if (nwritten < 0)
621 { err = soap_socket_errno(sk);
622 if (err && err != SOAP_EINTR)
623 { soap->errnum = err;
624 return SOAP_EOF;
625 }
626 nwritten = 0; /* and call write() again */
627 }
628 }
629 else
630 #endif
631 #if !defined(PALM) && !defined(AS400)
632 nwritten = send(sk, s, (int)n, soap->socket_flags);
633 #else
634 nwritten = send(sk, (void*)s, n, soap->socket_flags);
635 #endif
636 if (nwritten <= 0)
637 {
638 register int r = 0;
639 err = soap_socket_errno(sk);
640 #ifdef WITH_OPENSSL
641 if (soap->ssl && (r = SSL_get_error(soap->ssl, nwritten)) != SSL_ERROR_NONE && r != SSL_ERROR_WANT_READ && r != SSL_ERROR_WANT_WRITE)
642 { soap->errnum = err;
643 return SOAP_EOF;
644 }
645 #endif
646 #ifdef WITH_GNUTLS
647 if (soap->session)
648 { if (nwritten == GNUTLS_E_INTERRUPTED)
649 err = SOAP_EINTR;
650 else if (nwritten == GNUTLS_E_AGAIN)
651 err = SOAP_EAGAIN;
652 }
653 #endif
654 if (err == SOAP_EWOULDBLOCK || err == SOAP_EAGAIN)
655 {
656 #if defined(WITH_OPENSSL)
657 if (soap->ssl && r == SSL_ERROR_WANT_READ)
658 r = tcp_select(soap, sk, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_ERR, soap->send_timeout ? soap->send_timeout : -10000);
659 else
660 #elif defined(WITH_GNUTLS)
661 if (soap->session && !gnutls_record_get_direction(soap->session))
662 r = tcp_select(soap, sk, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_ERR, soap->send_timeout ? soap->send_timeout : -10000);
663 else
664 #endif
665 r = tcp_select(soap, sk, SOAP_TCP_SELECT_SND | SOAP_TCP_SELECT_ERR, soap->send_timeout ? soap->send_timeout : -10000);
666 if (!r && soap->send_timeout)
667 return SOAP_EOF;
668 if (r < 0)
669 return SOAP_EOF;
670 }
671 else if (err && err != SOAP_EINTR)
672 { soap->errnum = err;
673 return SOAP_EOF;
674 }
675 nwritten = 0; /* and call write() again */
676 }
677 }
678 else
679 {
680 #ifdef WITH_FASTCGI
681 nwritten = fwrite((void*)s, 1, n, stdout);
682 fflush(stdout);
683 #else
684 #ifdef UNDER_CE
685 nwritten = fwrite(s, 1, n, soap->sendfd);
686 #else
687 #ifdef VXWORKS
688 #ifdef WMW_RPM_IO
689 if (soap->rpmreqid)
690 nwritten = (httpBlockPut(soap->rpmreqid, (char*)s, n) == 0) ? n : -1;
691 else
692 #endif
693 nwritten = fwrite(s, sizeof(char), n, fdopen(soap->sendfd, "w"));
694 #else
695 #ifdef WIN32
696 nwritten = _write(soap->sendfd, s, (unsigned int)n);
697 #else
698 nwritten = write(soap->sendfd, s, (unsigned int)n);
699 #endif
700 #endif
701 #endif
702 #endif
703 if (nwritten <= 0)
704 {
705 #ifndef WITH_FASTCGI
706 err = soap_errno;
707 #else
708 err = EOF;
709 #endif
710 if (err && err != SOAP_EINTR && err != SOAP_EWOULDBLOCK && err != SOAP_EAGAIN)
711 { soap->errnum = err;
712 return SOAP_EOF;
713 }
714 nwritten = 0; /* and call write() again */
715 }
716 }
717 n -= nwritten;
718 s += nwritten;
719 }
720 return SOAP_OK;
721 }
722 #endif
723 #endif
724
725 /******************************************************************************/
726 #ifndef PALM_1
727 SOAP_FMAC1
728 int
729 SOAP_FMAC2
730 soap_send_raw(struct soap *soap, const char *s, size_t n)
731 { if (!n)
732 return SOAP_OK;
733 #ifndef WITH_LEANER
734 if (soap->fpreparesend && (soap->mode & SOAP_IO) != SOAP_IO_STORE && (soap->mode & SOAP_IO_LENGTH) && (soap->error = soap->fpreparesend(soap, s, n)))
735 return soap->error;
736 if (soap->ffiltersend && (soap->error = soap->ffiltersend(soap, &s, &n)))
737 return soap->error;
738 #endif
739 if (soap->mode & SOAP_IO_LENGTH)
740 soap->count += n;
741 else if (soap->mode & SOAP_IO)
742 { register size_t i = SOAP_BUFLEN - soap->bufidx;
743 while (n >= i)
744 { memcpy(soap->buf + soap->bufidx, s, i);
745 soap->bufidx = SOAP_BUFLEN;
746 if (soap_flush(soap))
747 return soap->error;
748 s += i;
749 n -= i;
750 i = SOAP_BUFLEN;
751 }
752 memcpy(soap->buf + soap->bufidx, s, n);
753 soap->bufidx += n;
754 }
755 else
756 return soap_flush_raw(soap, s, n);
757 return SOAP_OK;
758 }
759 #endif
760
761 /******************************************************************************/
762 #ifndef PALM_1
763 SOAP_FMAC1
764 int
765 SOAP_FMAC2
766 soap_flush(struct soap *soap)
767 { register size_t n = soap->bufidx;
768 if (n)
769 {
770 #ifndef WITH_LEANER
771 if ((soap->mode & SOAP_IO) == SOAP_IO_STORE)
772 { register int r;
773 if (soap->fpreparesend && (r = soap->fpreparesend(soap, soap->buf, n)))
774 return soap->error = r;
775 }
776 #endif
777 soap->bufidx = 0;
778 #ifdef WITH_ZLIB
779 if (soap->mode & SOAP_ENC_ZLIB)
780 { soap->d_stream->next_in = (Byte*)soap->buf;
781 soap->d_stream->avail_in = (unsigned int)n;
782 #ifdef WITH_GZIP
783 soap->z_crc = crc32(soap->z_crc, (Byte*)soap->buf, (unsigned int)n);
784 #endif
785 do
786 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflating %u bytes\n", soap->d_stream->avail_in));
787 if (deflate(soap->d_stream, Z_NO_FLUSH) != Z_OK)
788 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unable to deflate: %s\n", soap->d_stream->msg ? soap->d_stream->msg : SOAP_STR_EOS));
789 return soap->error = SOAP_ZLIB_ERROR;
790 }
791 if (!soap->d_stream->avail_out)
792 { if (soap_flush_raw(soap, soap->z_buf, SOAP_BUFLEN))
793 return soap->error;
794 soap->d_stream->next_out = (Byte*)soap->z_buf;
795 soap->d_stream->avail_out = SOAP_BUFLEN;
796 }
797 } while (soap->d_stream->avail_in);
798 }
799 else
800 #endif
801 return soap_flush_raw(soap, soap->buf, n);
802 }
803 return SOAP_OK;
804 }
805 #endif
806
807 /******************************************************************************/
808 #ifndef PALM_1
809 SOAP_FMAC1
810 int
811 SOAP_FMAC2
812 soap_flush_raw(struct soap *soap, const char *s, size_t n)
813 { if ((soap->mode & SOAP_IO) == SOAP_IO_STORE)
814 { register char *t;
815 if (!(t = (char*)soap_push_block(soap, NULL, n)))
816 return soap->error = SOAP_EOM;
817 memcpy(t, s, n);
818 return SOAP_OK;
819 }
820 #ifndef WITH_LEANER
821 if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK)
822 { char t[16];
823 #ifdef HAVE_SNPRINTF
824 soap_snprintf(t, sizeof(t), &"\r\n%lX\r\n"[soap->chunksize ? 0 : 2], (unsigned long)n);
825 #else
826 sprintf(t, &"\r\n%lX\r\n"[soap->chunksize ? 0 : 2], (unsigned long)n);
827 #endif
828 DBGMSG(SENT, t, strlen(t));
829 if ((soap->error = soap->fsend(soap, t, strlen(t))))
830 return soap->error;
831 soap->chunksize += n;
832 }
833 DBGMSG(SENT, s, n);
834 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Send %u bytes to socket=%d/fd=%d\n", (unsigned int)n, soap->socket, soap->sendfd));
835 #endif
836 return soap->error = soap->fsend(soap, s, n);
837 }
838 #endif
839
840 /******************************************************************************/
841 #ifndef PALM_1
842 SOAP_FMAC1
843 int
844 SOAP_FMAC2
845 soap_send(struct soap *soap, const char *s)
846 { if (s)
847 return soap_send_raw(soap, s, strlen(s));
848 return SOAP_OK;
849 }
850 #endif
851
852 /******************************************************************************/
853 #ifndef WITH_LEANER
854 #ifndef PALM_1
855 SOAP_FMAC1
856 int
857 SOAP_FMAC2
858 soap_send2(struct soap *soap, const char *s1, const char *s2)
859 { if (soap_send(soap, s1))
860 return soap->error;
861 return soap_send(soap, s2);
862 }
863 #endif
864 #endif
865
866 /******************************************************************************/
867 #ifndef WITH_LEANER
868 #ifndef PALM_1
869 SOAP_FMAC1
870 int
871 SOAP_FMAC2
872 soap_send3(struct soap *soap, const char *s1, const char *s2, const char *s3)
873 { if (soap_send(soap, s1)
874 || soap_send(soap, s2))
875 return soap->error;
876 return soap_send(soap, s3);
877 }
878 #endif
879 #endif
880
881 /******************************************************************************/
882 #ifndef WITH_NOIO
883 #ifndef PALM_1
884 static size_t
885 frecv(struct soap *soap, char *s, size_t n)
886 { register int r;
887 register int retries = 100; /* max 100 retries with non-blocking sockets */
888 SOAP_SOCKET sk;
889 soap->errnum = 0;
890 #if defined(__cplusplus) && !defined(WITH_LEAN) && !defined(WITH_COMPAT)
891 if (soap->is)
892 { if (soap->is->good())
893 return soap->is->read(s, (std::streamsize)n).gcount();
894 return 0;
895 }
896 #endif
897 sk = soap->recvsk;
898 if (!soap_valid_socket(sk))
899 sk = soap->socket;
900 if (soap_valid_socket(sk))
901 { for (;;)
902 {
903 #ifdef WITH_OPENSSL
904 register int err = 0;
905 #endif
906 #ifdef WITH_OPENSSL
907 if (soap->recv_timeout && !soap->ssl) /* SSL: sockets are nonblocking */
908 #else
909 if (soap->recv_timeout)
910 #endif
911 { for (;;)
912 { r = tcp_select(soap, sk, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_ERR, soap->recv_timeout);
913 if (r > 0)
914 break;
915 if (!r)
916 return 0;
917 r = soap->errnum;
918 if (r != SOAP_EAGAIN && r != SOAP_EWOULDBLOCK)
919 return 0;
920 }
921 }
922 #ifdef WITH_OPENSSL
923 if (soap->ssl)
924 { r = SSL_read(soap->ssl, s, (int)n);
925 if (r > 0)
926 return (size_t)r;
927 err = SSL_get_error(soap->ssl, r);
928 if (err != SSL_ERROR_NONE && err != SSL_ERROR_WANT_READ && err != SSL_ERROR_WANT_WRITE)
929 return 0;
930 }
931 else if (soap->bio)
932 { r = BIO_read(soap->bio, s, (int)n);
933 if (r > 0)
934 return (size_t)r;
935 return 0;
936 }
937 else
938 #endif
939 #ifdef WITH_GNUTLS
940 if (soap->session)
941 { r = (int)gnutls_record_recv(soap->session, s, n);
942 if (r >= 0)
943 return (size_t)r;
944 }
945 else
946 #endif
947 {
948 #ifndef WITH_LEAN
949 if ((soap->omode & SOAP_IO_UDP))
950 { SOAP_SOCKLEN_T k = (SOAP_SOCKLEN_T)sizeof(soap->peer);
951 memset((void*)&soap->peer, 0, sizeof(soap->peer));
952 r = recvfrom(sk, s, (SOAP_WINSOCKINT)n, soap->socket_flags, (struct sockaddr*)&soap->peer, &k); /* portability note: see SOAP_SOCKLEN_T definition in stdsoap2.h */
953 soap->peerlen = (size_t)k;
954 #ifndef WITH_IPV6
955 soap->ip = ntohl(soap->peer.sin_addr.s_addr);
956 #endif
957 }
958 else
959 #endif
960 r = recv(sk, s, (int)n, soap->socket_flags);
961 #ifdef PALM
962 /* CycleSyncDisplay(curStatusMsg); */
963 #endif
964 if (r >= 0)
965 return (size_t)r;
966 r = soap_socket_errno(sk);
967 if (r != SOAP_EINTR && r != SOAP_EAGAIN && r != SOAP_EWOULDBLOCK)
968 { soap->errnum = r;
969 return 0;
970 }
971 }
972 #if defined(WITH_OPENSSL)
973 if (soap->ssl && err == SSL_ERROR_WANT_WRITE)
974 r = tcp_select(soap, sk, SOAP_TCP_SELECT_SND | SOAP_TCP_SELECT_ERR, soap->recv_timeout ? soap->recv_timeout : 5);
975 else
976 #elif defined(WITH_GNUTLS)
977 if (soap->session && gnutls_record_get_direction(soap->session))
978 r = tcp_select(soap, sk, SOAP_TCP_SELECT_SND | SOAP_TCP_SELECT_ERR, soap->recv_timeout ? soap->recv_timeout : 5);
979 else
980 #endif
981 r = tcp_select(soap, sk, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_ERR, soap->recv_timeout ? soap->recv_timeout : 5);
982 if (!r && soap->recv_timeout)
983 return 0;
984 if (r < 0)
985 { r = soap->errnum;
986 if (r != SOAP_EAGAIN && r != SOAP_EWOULDBLOCK)
987 return 0;
988 }
989 if (retries-- <= 0)
990 return 0;
991 #ifdef PALM
992 r = soap_socket_errno(sk);
993 if (r != SOAP_EINTR && retries-- <= 0)
994 { soap->errnum = r;
995 return 0;
996 }
997 #endif
998 }
999 }
1000 #ifdef WITH_FASTCGI
1001 return fread(s, 1, n, stdin);
1002 #else
1003 #ifdef UNDER_CE
1004 return fread(s, 1, n, soap->recvfd);
1005 #else
1006 #ifdef WMW_RPM_IO
1007 if (soap->rpmreqid)
1008 r = httpBlockRead(soap->rpmreqid, s, n);
1009 else
1010 #endif
1011 #ifdef WIN32
1012 r = _read(soap->recvfd, s, (unsigned int)n);
1013 #else
1014 r = read(soap->recvfd, s, (unsigned int)n);
1015 #endif
1016 if (r >= 0)
1017 return (size_t)r;
1018 soap->errnum = soap_errno;
1019 return 0;
1020 #endif
1021 #endif
1022 }
1023 #endif
1024 #endif
1025
1026 /******************************************************************************/
1027 #ifndef WITH_NOHTTP
1028 #ifndef PALM_1
1029 static soap_wchar
1030 soap_getchunkchar(struct soap *soap)
1031 { if (soap->bufidx < soap->buflen)
1032 return soap->buf[soap->bufidx++];
1033 soap->bufidx = 0;
1034 soap->buflen = soap->chunkbuflen = soap->frecv(soap, soap->buf, SOAP_BUFLEN);
1035 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Read %u bytes from socket=%d/fd=%d\n", (unsigned int)soap->buflen, soap->socket, soap->recvfd));
1036 DBGMSG(RECV, soap->buf, soap->buflen);
1037 if (soap->buflen)
1038 return soap->buf[soap->bufidx++];
1039 return EOF;
1040 }
1041 #endif
1042 #endif
1043
1044 /******************************************************************************/
1045 #ifndef PALM_1
1046 static int
1047 soap_isxdigit(int c)
1048 { return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f');
1049 }
1050 #endif
1051
1052 /******************************************************************************/
1053 #ifndef PALM_1
1054 SOAP_FMAC1
1055 int
1056 SOAP_FMAC2
1057 soap_recv_raw(struct soap *soap)
1058 { register size_t ret;
1059 #if !defined(WITH_LEANER) || defined(WITH_ZLIB)
1060 register int r;
1061 #endif
1062 #ifdef WITH_ZLIB
1063 if (soap->mode & SOAP_ENC_ZLIB)
1064 { if (soap->d_stream->next_out == Z_NULL)
1065 { soap->bufidx = soap->buflen = 0;
1066 return EOF;
1067 }
1068 if (soap->d_stream->avail_in || !soap->d_stream->avail_out)
1069 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflating\n"));
1070 soap->d_stream->next_out = (Byte*)soap->buf;
1071 soap->d_stream->avail_out = SOAP_BUFLEN;
1072 r = inflate(soap->d_stream, Z_NO_FLUSH);
1073 if (r == Z_NEED_DICT && soap->z_dict)
1074 r = inflateSetDictionary(soap->d_stream, (const Bytef*)soap->z_dict, soap->z_dict_len);
1075 if (r == Z_OK || r == Z_STREAM_END)
1076 { soap->bufidx = 0;
1077 ret = soap->buflen = SOAP_BUFLEN - soap->d_stream->avail_out;
1078 if (soap->zlib_in == SOAP_ZLIB_GZIP)
1079 soap->z_crc = crc32(soap->z_crc, (Byte*)soap->buf, (unsigned int)ret);
1080 if (r == Z_STREAM_END)
1081 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflated %lu->%lu bytes\n", soap->d_stream->total_in, soap->d_stream->total_out));
1082 soap->z_ratio_in = (float)soap->d_stream->total_in / (float)soap->d_stream->total_out;
1083 soap->d_stream->next_out = Z_NULL;
1084 }
1085 if (ret)
1086 { soap->count += ret;
1087 DBGLOG(RECV, SOAP_MESSAGE(fdebug, "\n---- decompressed ----\n"));
1088 DBGMSG(RECV, soap->buf, ret);
1089 DBGLOG(RECV, SOAP_MESSAGE(fdebug, "\n----\n"));
1090 #ifndef WITH_LEANER
1091 if (soap->fpreparerecv && (r = soap->fpreparerecv(soap, soap->buf, ret)))
1092 return soap->error = r;
1093 #endif
1094 return SOAP_OK;
1095 }
1096 }
1097 else if (r != Z_BUF_ERROR)
1098 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflate error: %s\n", soap->d_stream->msg ? soap->d_stream->msg : SOAP_STR_EOS));
1099 soap->d_stream->next_out = Z_NULL;
1100 return soap->error = SOAP_ZLIB_ERROR;
1101 }
1102 }
1103 zlib_again:
1104 if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK && !soap->chunksize)
1105 { memcpy(soap->buf, soap->z_buf, SOAP_BUFLEN);
1106 soap->buflen = soap->z_buflen;
1107 }
1108 DBGLOG(RECV, SOAP_MESSAGE(fdebug, "\n---- compressed ----\n"));
1109 }
1110 #endif
1111 #ifndef WITH_NOHTTP
1112 if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK) /* read HTTP chunked transfer */
1113 { for (;;)
1114 { register soap_wchar c;
1115 char *t, tmp[17];
1116 if (soap->chunksize)
1117 { soap->buflen = ret = soap->frecv(soap, soap->buf, soap->chunksize > SOAP_BUFLEN ? SOAP_BUFLEN : soap->chunksize);
1118 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Getting chunk: read %u bytes\n", (unsigned int)ret));
1119 DBGMSG(RECV, soap->buf, ret);
1120 soap->bufidx = 0;
1121 soap->chunksize -= ret;
1122 break;
1123 }
1124 t = tmp;
1125 if (!soap->chunkbuflen)
1126 { soap->chunkbuflen = ret = soap->frecv(soap, soap->buf, SOAP_BUFLEN);
1127 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Read %u bytes (chunked) from socket=%d\n", (unsigned int)ret, soap->socket));
1128 DBGMSG(RECV, soap->buf, ret);
1129 soap->bufidx = 0;
1130 if (!ret)
1131 { soap->ahead = EOF;
1132 return EOF;
1133 }
1134 }
1135 else
1136 soap->bufidx = soap->buflen;
1137 soap->buflen = soap->chunkbuflen;
1138 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Getting chunk size (idx=%u len=%u)\n", (unsigned int)soap->bufidx, (unsigned int)soap->buflen));
1139 while (!soap_isxdigit((int)(c = soap_getchunkchar(soap))))
1140 { if ((int)c == EOF)
1141 { soap->ahead = EOF;
1142 return EOF;
1143 }
1144 }
1145 do
1146 *t++ = (char)c;
1147 while (soap_isxdigit((int)(c = soap_getchunkchar(soap))) && (size_t)(t - tmp) < sizeof(tmp)-1);
1148 while ((int)c != EOF && c != '\n')
1149 c = soap_getchunkchar(soap);
1150 if ((int)c == EOF)
1151 { soap->ahead = EOF;
1152 return EOF;
1153 }
1154 *t = '\0';
1155 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunk size = %s (hex)\n", tmp));
1156 soap->chunksize = (size_t)soap_strtoul(tmp, &t, 16);
1157 if (!soap->chunksize)
1158 { soap->bufidx = soap->buflen = soap->chunkbuflen = 0;
1159 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of chunked message\n"));
1160 while ((int)c != EOF && c != '\n')
1161 c = soap_getchunkchar(soap);
1162 ret = 0;
1163 soap->ahead = EOF;
1164 break;
1165 }
1166 soap->buflen = soap->bufidx + soap->chunksize;
1167 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Moving buf len to idx=%u len=%u (%s)\n", (unsigned int)soap->bufidx, (unsigned int)soap->buflen, tmp));
1168 if (soap->buflen > soap->chunkbuflen)
1169 { soap->buflen = soap->chunkbuflen;
1170 soap->chunksize -= soap->buflen - soap->bufidx;
1171 soap->chunkbuflen = 0;
1172 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Passed end of buffer for chunked HTTP (%u bytes left)\n", (unsigned int)(soap->buflen - soap->bufidx)));
1173 }
1174 else if (soap->chunkbuflen)
1175 soap->chunksize = 0;
1176 ret = soap->buflen - soap->bufidx;
1177 if (ret)
1178 break;
1179 }
1180 }
1181 else
1182 #endif
1183 { soap->bufidx = 0;
1184 soap->buflen = ret = soap->frecv(soap, soap->buf, SOAP_BUFLEN);
1185 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Read %u bytes from socket=%d/fd=%d\n", (unsigned int)ret, soap->socket, soap->recvfd));
1186 DBGMSG(RECV, soap->buf, ret);
1187 }
1188 #ifdef WITH_ZLIB
1189 if (soap->mode & SOAP_ENC_ZLIB)
1190 { memcpy(soap->z_buf, soap->buf, SOAP_BUFLEN);
1191 soap->d_stream->next_in = (Byte*)(soap->z_buf + soap->bufidx);
1192 soap->d_stream->avail_in = (unsigned int)ret;
1193 soap->d_stream->next_out = (Byte*)soap->buf;
1194 soap->d_stream->avail_out = SOAP_BUFLEN;
1195 r = inflate(soap->d_stream, Z_NO_FLUSH);
1196 if (r == Z_NEED_DICT && soap->z_dict)
1197 r = inflateSetDictionary(soap->d_stream, (const Bytef*)soap->z_dict, soap->z_dict_len);
1198 if (r == Z_OK || r == Z_STREAM_END)
1199 { soap->bufidx = 0;
1200 soap->z_buflen = soap->buflen;
1201 soap->buflen = SOAP_BUFLEN - soap->d_stream->avail_out;
1202 if (soap->zlib_in == SOAP_ZLIB_GZIP)
1203 soap->z_crc = crc32(soap->z_crc, (Byte*)soap->buf, (unsigned int)soap->buflen);
1204 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflated %u bytes\n", (unsigned int)soap->buflen));
1205 if (ret && !soap->buflen && r != Z_STREAM_END)
1206 goto zlib_again;
1207 ret = soap->buflen;
1208 if (r == Z_STREAM_END)
1209 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflated total %lu->%lu bytes\n", soap->d_stream->total_in, soap->d_stream->total_out));
1210 soap->z_ratio_in = (float)soap->d_stream->total_in / (float)soap->d_stream->total_out;
1211 soap->d_stream->next_out = Z_NULL;
1212 }
1213 DBGLOG(RECV, SOAP_MESSAGE(fdebug, "\n---- decompressed ----\n"));
1214 DBGMSG(RECV, soap->buf, ret);
1215 #ifndef WITH_LEANER
1216 if (soap->fpreparerecv && (r = soap->fpreparerecv(soap, soap->buf, ret)))
1217 return soap->error = r;
1218 #endif
1219 }
1220 else
1221 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unable to inflate: (%d) %s\n", r, soap->d_stream->msg ? soap->d_stream->msg : SOAP_STR_EOS));
1222 soap->d_stream->next_out = Z_NULL;
1223 return soap->error = SOAP_ZLIB_ERROR;
1224 }
1225 }
1226 #endif
1227 #ifndef WITH_LEANER
1228 if (soap->fpreparerecv
1229 #ifdef WITH_ZLIB
1230 && soap->zlib_in == SOAP_ZLIB_NONE
1231 #endif
1232 && (r = soap->fpreparerecv(soap, soap->buf + soap->bufidx, ret)))
1233 return soap->error = r;
1234 #endif
1235 soap->count += ret;
1236 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Read count=%lu (+%lu)\n", (unsigned long)soap->count, (unsigned long)ret));
1237 return !ret;
1238 }
1239 #endif
1240
1241 /******************************************************************************/
1242 #ifndef PALM_1
1243 SOAP_FMAC1
1244 int
1245 SOAP_FMAC2
1246 soap_recv(struct soap *soap)
1247 {
1248 #ifndef WITH_LEANER
1249 if (soap->mode & SOAP_ENC_DIME)
1250 { if (soap->dime.buflen)
1251 { char *s;
1252 int i;
1253 unsigned char tmp[12];
1254 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DIME hdr for chunked DIME is in buffer\n"));
1255 soap->count += soap->dime.buflen - soap->buflen;
1256 soap->buflen = soap->dime.buflen;
1257 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Skip padding (%ld bytes)\n", -(long)soap->dime.size&3));
1258 for (i = -(long)soap->dime.size&3; i > 0; i--)
1259 { soap->bufidx++;
1260 if (soap->bufidx >= soap->buflen)
1261 if (soap_recv_raw(soap))
1262 return EOF;
1263 }
1264 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get DIME hdr for next chunk\n"));
1265 s = (char*)tmp;
1266 for (i = 12; i > 0; i--)
1267 { *s++ = soap->buf[soap->bufidx++];
1268 if (soap->bufidx >= soap->buflen)
1269 if (soap_recv_raw(soap))
1270 return EOF;
1271 }
1272 soap->dime.flags = tmp[0] & 0x7;
1273 soap->dime.size = ((size_t)tmp[8] << 24) | ((size_t)tmp[9] << 16) | ((size_t)tmp[10] << 8) | ((size_t)tmp[11]);
1274 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get DIME chunk (%u bytes)\n", (unsigned int)soap->dime.size));
1275 if (soap->dime.flags & SOAP_DIME_CF)
1276 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "More chunking\n"));
1277 soap->dime.chunksize = soap->dime.size;
1278 if (soap->buflen - soap->bufidx >= soap->dime.size)
1279 { soap->dime.buflen = soap->buflen;
1280 soap->buflen = soap->bufidx + soap->dime.chunksize;
1281 }
1282 else
1283 soap->dime.chunksize -= soap->buflen - soap->bufidx;
1284 }
1285 else
1286 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Last chunk\n"));
1287 soap->dime.buflen = 0;
1288 soap->dime.chunksize = 0;
1289 }
1290 soap->count = soap->buflen - soap->bufidx;
1291 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "%u bytes remaining\n", (unsigned int)soap->count));
1292 return SOAP_OK;
1293 }
1294 if (soap->dime.chunksize)
1295 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get next DIME hdr for chunked DIME (%u bytes chunk)\n", (unsigned int)soap->dime.chunksize));
1296 if (soap_recv_raw(soap))
1297 return EOF;
1298 if (soap->buflen - soap->bufidx >= soap->dime.chunksize)
1299 { soap->dime.buflen = soap->buflen;
1300 soap->count -= soap->buflen - soap->bufidx - soap->dime.chunksize;
1301 soap->buflen = soap->bufidx + soap->dime.chunksize;
1302 }
1303 else
1304 soap->dime.chunksize -= soap->buflen - soap->bufidx;
1305 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "%lu bytes remaining, count=%lu\n", (unsigned long)(soap->buflen-soap->bufidx), (unsigned long)soap->count));
1306 return SOAP_OK;
1307 }
1308 }
1309 while (soap->ffilterrecv)
1310 { int err, last = soap->filterstop;
1311 if (last)
1312 soap->bufidx = soap->buflen = 0;
1313 if ((err = soap->ffilterrecv(soap, soap->buf, &soap->buflen, sizeof(soap->buf))))
1314 return soap->error = err;
1315 if (soap->buflen)
1316 { soap->bufidx = 0;
1317 soap->filterstop = last;
1318 return SOAP_OK;
1319 }
1320 if (last)
1321 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Returning postponed error %d\n", last));
1322 soap->filterstop = SOAP_OK;
1323 return last;
1324 }
1325 soap->filterstop = soap_recv_raw(soap); /* do not call again after EOF */
1326 }
1327 #endif
1328 return soap_recv_raw(soap);
1329 }
1330 #endif
1331
1332 /******************************************************************************/
1333 #ifndef PALM_1
1334 SOAP_FMAC1
1335 soap_wchar
1336 SOAP_FMAC2
1337 soap_getchar(struct soap *soap)
1338 { register soap_wchar c;
1339 c = soap->ahead;
1340 if (c)
1341 { if (c != EOF)
1342 soap->ahead = 0;
1343 return c;
1344 }
1345 return soap_get1(soap);
1346 }
1347 #endif
1348
1349 /******************************************************************************/
1350 #ifndef PALM_1
1351 SOAP_FMAC1
1352 const struct soap_code_map*
1353 SOAP_FMAC2
1354 soap_code(const struct soap_code_map *code_map, const char *str)
1355 { if (code_map && str)
1356 { while (code_map->string)
1357 { if (!strcmp(str, code_map->string)) /* case sensitive */
1358 return code_map;
1359 code_map++;
1360 }
1361 }
1362 return NULL;
1363 }
1364 #endif
1365
1366 /******************************************************************************/
1367 #ifndef PALM_1
1368 SOAP_FMAC1
1369 long
1370 SOAP_FMAC2
1371 soap_code_int(const struct soap_code_map *code_map, const char *str, long other)
1372 { if (code_map)
1373 { while (code_map->string)
1374 { if (!soap_tag_cmp(str, code_map->string)) /* case insensitive */
1375 return code_map->code;
1376 code_map++;
1377 }
1378 }
1379 return other;
1380 }
1381 #endif
1382
1383 /******************************************************************************/
1384 #ifndef PALM_1
1385 SOAP_FMAC1
1386 const char*
1387 SOAP_FMAC2
1388 soap_code_str(const struct soap_code_map *code_map, long code)
1389 { if (!code_map)
1390 return NULL;
1391 while (code_map->code != code && code_map->string)
1392 code_map++;
1393 return code_map->string;
1394 }
1395 #endif
1396
1397 /******************************************************************************/
1398 #ifndef PALM_1
1399 SOAP_FMAC1
1400 long
1401 SOAP_FMAC2
1402 soap_code_bits(const struct soap_code_map *code_map, const char *str)
1403 { register long bits = 0;
1404 if (code_map)
1405 { while (str && *str)
1406 { const struct soap_code_map *p;
1407 for (p = code_map; p->string; p++)
1408 { register size_t n = strlen(p->string);
1409 if (!strncmp(p->string, str, n) && soap_blank((soap_wchar)str[n]))
1410 { bits |= p->code;
1411 str += n;
1412 while (*str > 0 && *str <= 32)
1413 str++;
1414 break;
1415 }
1416 }
1417 if (!p->string)
1418 return 0;
1419 }
1420 }
1421 return bits;
1422 }
1423 #endif
1424
1425 /******************************************************************************/
1426 #ifndef PALM_1
1427 SOAP_FMAC1
1428 const char*
1429 SOAP_FMAC2
1430 soap_code_list(struct soap *soap, const struct soap_code_map *code_map, long code)
1431 { register char *t = soap->tmpbuf;
1432 if (code_map)
1433 { while (code_map->string)
1434 { if (code_map->code & code)
1435 { register const char *s = code_map->string;
1436 if (t != soap->tmpbuf)
1437 *t++ = ' ';
1438 while (*s && t < soap->tmpbuf + sizeof(soap->tmpbuf) - 1)
1439 *t++ = *s++;
1440 if (t == soap->tmpbuf + sizeof(soap->tmpbuf) - 1)
1441 break;
1442 }
1443 code_map++;
1444 }
1445 }
1446 *t = '\0';
1447 return soap->tmpbuf;
1448 }
1449 #endif
1450
1451 /******************************************************************************/
1452 #ifndef PALM_1
1453 static soap_wchar
1454 soap_char(struct soap *soap)
1455 { char tmp[8];
1456 register int i;
1457 register soap_wchar c;
1458 register char *s = tmp;
1459 for (i = 0; i < 7; i++)
1460 { c = soap_get1(soap);
1461 if (c == ';' || (int)c == EOF)
1462 break;
1463 *s++ = (char)c;
1464 }
1465 *s = '\0';
1466 if (*tmp == '#')
1467 { if (tmp[1] == 'x' || tmp[1] == 'X')
1468 return (soap_wchar)soap_strtol(tmp + 2, NULL, 16);
1469 return (soap_wchar)soap_strtol(tmp + 1, NULL, 10);
1470 }
1471 if (!strcmp(tmp, "lt"))
1472 return '<';
1473 if (!strcmp(tmp, "gt"))
1474 return '>';
1475 if (!strcmp(tmp, "amp"))
1476 return '&';
1477 if (!strcmp(tmp, "quot"))
1478 return '"';
1479 if (!strcmp(tmp, "apos"))
1480 return '\'';
1481 #ifndef WITH_LEAN
1482 return (soap_wchar)soap_code_int(html_entity_codes, tmp, SOAP_UNKNOWN_CHAR);
1483 #else
1484 return SOAP_UNKNOWN_CHAR; /* use this to represent unknown code */
1485 #endif
1486 }
1487 #endif
1488
1489 /******************************************************************************/
1490 #ifdef WITH_LEAN
1491 #ifndef PALM_1
1492 soap_wchar
1493 soap_get0(struct soap *soap)
1494 { if (soap->bufidx >= soap->buflen && soap_recv(soap))
1495 return EOF;
1496 return (unsigned char)soap->buf[soap->bufidx];
1497 }
1498 #endif
1499 #endif
1500
1501 /******************************************************************************/
1502 #ifdef WITH_LEAN
1503 #ifndef PALM_1
1504 soap_wchar
1505 soap_get1(struct soap *soap)
1506 { if (soap->bufidx >= soap->buflen && soap_recv(soap))
1507 return EOF;
1508 return (unsigned char)soap->buf[soap->bufidx++];
1509 }
1510 #endif
1511 #endif
1512
1513 /******************************************************************************/
1514 #ifndef PALM_1
1515 SOAP_FMAC1
1516 soap_wchar
1517 SOAP_FMAC2
1518 soap_get(struct soap *soap)
1519 { register soap_wchar c;
1520 c = soap->ahead;
1521 if (c)
1522 { if ((int)c != EOF)
1523 soap->ahead = 0;
1524 }
1525 else
1526 c = soap_get1(soap);
1527 while ((int)c != EOF)
1528 { if (soap->cdata)
1529 { if (c == ']')
1530 { c = soap_get1(soap);
1531 if (c == ']')
1532 { c = soap_get0(soap);
1533 if (c == '>')
1534 { soap->cdata = 0;
1535 c = soap_get1(soap);
1536 c = soap_get1(soap);
1537 }
1538 else
1539 { soap_unget(soap, ']');
1540 return ']';
1541 }
1542 }
1543 else
1544 { soap_revget1(soap);
1545 return ']';
1546 }
1547 }
1548 else
1549 return c;
1550 }
1551 switch (c)
1552 { case '<':
1553 do c = soap_get1(soap);
1554 while (soap_blank(c));
1555 if (c == '!' || c == '?' || c == '%')
1556 { register int k = 1;
1557 if (c == '!')
1558 { c = soap_get1(soap);
1559 if (c == '[')
1560 { do c = soap_get1(soap);
1561 while ((int)c != EOF && c != '[');
1562 if ((int)c == EOF)
1563 break;
1564 soap->cdata = 1;
1565 c = soap_get1(soap);
1566 continue;
1567 }
1568 if (c == '-' && (c = soap_get1(soap)) == '-')
1569 { do
1570 { c = soap_get1(soap);
1571 if (c == '-' && (c = soap_get1(soap)) == '-')
1572 break;
1573 } while ((int)c != EOF);
1574 }
1575 }
1576 else if (c == '?')
1577 c = soap_get_pi(soap);
1578 while ((int)c != EOF)
1579 { if (c == '<')
1580 k++;
1581 else if (c == '>')
1582 { if (--k <= 0)
1583 break;
1584 }
1585 c = soap_get1(soap);
1586 }
1587 if ((int)c == EOF)
1588 break;
1589 c = soap_get1(soap);
1590 continue;
1591 }
1592 if (c == '/')
1593 return SOAP_TT;
1594 soap_revget1(soap);
1595 return SOAP_LT;
1596 case '>':
1597 return SOAP_GT;
1598 case '"':
1599 return SOAP_QT;
1600 case '\'':
1601 return SOAP_AP;
1602 case '&':
1603 return soap_char(soap) | 0x80000000;
1604 }
1605 break;
1606 }
1607 return c;
1608 }
1609 #endif
1610
1611 /******************************************************************************/
1612 #ifndef PALM_1
1613 static soap_wchar
1614 soap_get_pi(struct soap *soap)
1615 { char buf[64];
1616 register char *s = buf;
1617 register int i = sizeof(buf);
1618 register soap_wchar c = soap_getchar(soap);
1619 /* This is a quick way to parse XML PI and we could use a callback instead to
1620 * enable applications to intercept processing instructions */
1621 while ((int)c != EOF && c != '?')
1622 { if (--i > 0)
1623 { if (soap_blank(c))
1624 c = ' ';
1625 *s++ = (char)c;
1626 }
1627 c = soap_getchar(soap);
1628 }
1629 *s = '\0';
1630 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "XML PI <?%s?>\n", buf));
1631 if (!strncmp(buf, "xml ", 4))
1632 { s = strstr(buf, " encoding=");
1633 if (s && s[10])
1634 { if (!soap_tag_cmp(s + 11, "iso-8859-1*")
1635 || !soap_tag_cmp(s + 11, "latin1*"))
1636 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Switching to latin1 encoding\n"));
1637 soap->mode |= SOAP_ENC_LATIN;
1638 }
1639 else if (!soap_tag_cmp(s + 11, "utf-8*"))
1640 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Switching to utf-8 encoding\n"));
1641 soap->mode &= ~SOAP_ENC_LATIN;
1642 }
1643 }
1644 }
1645 if ((int)c != EOF)
1646 c = soap_getchar(soap);
1647 return c;
1648 }
1649 #endif
1650
1651 /******************************************************************************/
1652 #ifndef WITH_LEANER
1653 #ifndef PALM_1
1654 SOAP_FMAC1
1655 int
1656 SOAP_FMAC2
1657 soap_move(struct soap *soap, size_t n)
1658 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Moving %lu bytes forward\n", (unsigned long)n));
1659 for (; n; n--)
1660 if ((int)soap_getchar(soap) == EOF)
1661 return SOAP_EOF;
1662 return SOAP_OK;
1663 }
1664 #endif
1665 #endif
1666
1667 /******************************************************************************/
1668 #ifndef WITH_LEANER
1669 #ifndef PALM_1
1670 SOAP_FMAC1
1671 size_t
1672 SOAP_FMAC2
1673 soap_tell(struct soap *soap)
1674 { return soap->count - soap->buflen + soap->bufidx - (soap->ahead != 0);
1675 }
1676 #endif
1677 #endif
1678
1679 /******************************************************************************/
1680 #ifndef PALM_1
1681 SOAP_FMAC1
1682 int
1683 SOAP_FMAC2
1684 soap_pututf8(struct soap *soap, register unsigned long c)
1685 { char tmp[16];
1686 if (c < 0x80 && c > 0)
1687 { *tmp = (char)c;
1688 return soap_send_raw(soap, tmp, 1);
1689 }
1690 #ifndef WITH_LEAN
1691 if (c >= 0x80)
1692 { register char *t = tmp;
1693 if (c < 0x0800)
1694 *t++ = (char)(0xC0 | ((c >> 6) & 0x1F));
1695 else
1696 { if (c < 0x010000)
1697 *t++ = (char)(0xE0 | ((c >> 12) & 0x0F));
1698 else
1699 { if (c < 0x200000)
1700 *t++ = (char)(0xF0 | ((c >> 18) & 0x07));
1701 else
1702 { if (c < 0x04000000)
1703 *t++ = (char)(0xF8 | ((c >> 24) & 0x03));
1704 else
1705 { *t++ = (char)(0xFC | ((c >> 30) & 0x01));
1706 *t++ = (char)(0x80 | ((c >> 24) & 0x3F));
1707 }
1708 *t++ = (char)(0x80 | ((c >> 18) & 0x3F));
1709 }
1710 *t++ = (char)(0x80 | ((c >> 12) & 0x3F));
1711 }
1712 *t++ = (char)(0x80 | ((c >> 6) & 0x3F));
1713 }
1714 *t++ = (char)(0x80 | (c & 0x3F));
1715 *t = '\0';
1716 }
1717 else
1718 #endif
1719 #ifdef HAVE_SNPRINTF
1720 soap_snprintf(tmp, sizeof(tmp), "&#%lu;", c);
1721 #else
1722 sprintf(tmp, "&#%lu;", c);
1723 #endif
1724 return soap_send(soap, tmp);
1725 }
1726 #endif
1727
1728 /******************************************************************************/
1729 #ifndef PALM_1
1730 SOAP_FMAC1
1731 soap_wchar
1732 SOAP_FMAC2
1733 soap_getutf8(struct soap *soap)
1734 { register soap_wchar c, c1, c2, c3, c4;
1735 c = soap->ahead;
1736 if (c >= 0x80)
1737 soap->ahead = 0;
1738 else
1739 c = soap_get(soap);
1740 if (c < 0x80 || c > 0xFF || (soap->mode & SOAP_ENC_LATIN))
1741 return c;
1742 c1 = soap_get1(soap);
1743 if (c1 < 0x80)
1744 { soap_revget1(soap); /* doesn't look like this is UTF8 */
1745 return c;
1746 }
1747 c1 &= 0x3F;
1748 if (c < 0xE0)
1749 return ((soap_wchar)(c & 0x1F) << 6) | c1;
1750 c2 = (soap_wchar)soap_get1(soap) & 0x3F;
1751 if (c < 0xF0)
1752 return ((soap_wchar)(c & 0x0F) << 12) | (c1 << 6) | c2;
1753 c3 = (soap_wchar)soap_get1(soap) & 0x3F;
1754 if (c < 0xF8)
1755 return ((soap_wchar)(c & 0x07) << 18) | (c1 << 12) | (c2 << 6) | c3;
1756 c4 = (soap_wchar)soap_get1(soap) & 0x3F;
1757 if (c < 0xFC)
1758 return ((soap_wchar)(c & 0x03) << 24) | (c1 << 18) | (c2 << 12) | (c3 << 6) | c4;
1759 return ((soap_wchar)(c & 0x01) << 30) | (c1 << 24) | (c2 << 18) | (c3 << 12) | (c4 << 6) | (soap_wchar)(soap_get1(soap) & 0x3F);
1760 }
1761 #endif
1762
1763 /******************************************************************************/
1764 #ifndef PALM_1
1765 SOAP_FMAC1
1766 int
1767 SOAP_FMAC2
1768 soap_puthex(struct soap *soap, const unsigned char *s, int n)
1769 { char d[2];
1770 register int i;
1771 #ifdef WITH_DOM
1772 if ((soap->mode & SOAP_XML_DOM) && soap->dom)
1773 { if (!(soap->dom->data = soap_s2hex(soap, s, NULL, n)))
1774 return soap->error;
1775 return SOAP_OK;
1776 }
1777 #endif
1778 for (i = 0; i < n; i++)
1779 { register int m = *s++;
1780 d[0] = (char)((m >> 4) + (m > 159 ? '7' : '0'));
1781 m &= 0x0F;
1782 d[1] = (char)(m + (m > 9 ? '7' : '0'));
1783 if (soap_send_raw(soap, d, 2))
1784 return soap->error;
1785 }
1786 return SOAP_OK;
1787 }
1788 #endif
1789
1790 /******************************************************************************/
1791 #ifndef PALM_1
1792 SOAP_FMAC1
1793 unsigned char*
1794 SOAP_FMAC2
1795 soap_gethex(struct soap *soap, int *n)
1796 {
1797 #ifdef WITH_DOM
1798 if ((soap->mode & SOAP_XML_DOM) && soap->dom)
1799 { soap->dom->data = soap_string_in(soap, 0, -1, -1);
1800 return (unsigned char*)soap_hex2s(soap, soap->dom->data, NULL, 0, n);
1801 }
1802 #endif
1803 #ifdef WITH_FAST
1804 soap->labidx = 0;
1805 for (;;)
1806 { register char *s;
1807 register size_t i, k;
1808 if (soap_append_lab(soap, NULL, 0))
1809 return NULL;
1810 s = soap->labbuf + soap->labidx;
1811 k = soap->lablen - soap->labidx;
1812 soap->labidx = soap->lablen;
1813 for (i = 0; i < k; i++)
1814 { register char d1, d2;
1815 register soap_wchar c;
1816 c = soap_get(soap);
1817 if (soap_isxdigit(c))
1818 { d1 = (char)c;
1819 c = soap_get(soap);
1820 if (soap_isxdigit(c))
1821 d2 = (char)c;
1822 else
1823 { soap->error = SOAP_TYPE;
1824 return NULL;
1825 }
1826 }
1827 else
1828 { unsigned char *p;
1829 soap_unget(soap, c);
1830 if (n)
1831 *n = (int)(soap->lablen + i - k);
1832 p = (unsigned char*)soap_malloc(soap, soap->lablen + i - k);
1833 if (p)
1834 memcpy(p, soap->labbuf, soap->lablen + i - k);
1835 return p;
1836 }
1837 *s++ = (char)(((d1 >= 'A' ? (d1 & 0x7) + 9 : d1 - '0') << 4) + (d2 >= 'A' ? (d2 & 0x7) + 9 : d2 - '0'));
1838 }
1839 }
1840 #else
1841 if (soap_new_block(soap) == NULL)
1842 return NULL;
1843 for (;;)
1844 { register int i;
1845 register char *s = (char*)soap_push_block(soap, NULL, SOAP_BLKLEN);
1846 if (!s)
1847 { soap_end_block(soap, NULL);
1848 return NULL;
1849 }
1850 for (i = 0; i < SOAP_BLKLEN; i++)
1851 { register char d1, d2;
1852 register soap_wchar c = soap_get(soap);
1853 if (soap_isxdigit(c))
1854 { d1 = (char)c;
1855 c = soap_get(soap);
1856 if (soap_isxdigit(c))
1857 d2 = (char)c;
1858 else
1859 { soap_end_block(soap, NULL);
1860 soap->error = SOAP_TYPE;
1861 return NULL;
1862 }
1863 }
1864 else
1865 { unsigned char *p;
1866 soap_unget(soap, c);
1867 if (n)
1868 *n = (int)soap_size_block(soap, NULL, i);
1869 p = (unsigned char*)soap_save_block(soap, NULL, 0);
1870 return p;
1871 }
1872 *s++ = ((d1 >= 'A' ? (d1 & 0x7) + 9 : d1 - '0') << 4) + (d2 >= 'A' ? (d2 & 0x7) + 9 : d2 - '0');
1873 }
1874 }
1875 #endif
1876 }
1877 #endif
1878
1879 /******************************************************************************/
1880 #ifndef PALM_1
1881 SOAP_FMAC1
1882 int
1883 SOAP_FMAC2
1884 soap_putbase64(struct soap *soap, const unsigned char *s, int n)
1885 { register int i;
1886 register unsigned long m;
1887 char d[4];
1888 if (!s)
1889 return SOAP_OK;
1890 #ifdef WITH_DOM
1891 if ((soap->mode & SOAP_XML_DOM) && soap->dom)
1892 { if (!(soap->dom->data = soap_s2base64(soap, s, NULL, n)))
1893 return soap->error;
1894 return SOAP_OK;
1895 }
1896 #endif
1897 for (; n > 2; n -= 3, s += 3)
1898 { m = s[0];
1899 m = (m << 8) | s[1];
1900 m = (m << 8) | s[2];
1901 for (i = 4; i > 0; m >>= 6)
1902 d[--i] = soap_base64o[m & 0x3F];
1903 if (soap_send_raw(soap, d, 4))
1904 return soap->error;
1905 }
1906 if (n > 0)
1907 { m = 0;
1908 for (i = 0; i < n; i++)
1909 m = (m << 8) | *s++;
1910 for (; i < 3; i++)
1911 m <<= 8;
1912 for (i++; i > 0; m >>= 6)
1913 d[--i] = soap_base64o[m & 0x3F];
1914 for (i = 3; i > n; i--)
1915 d[i] = '=';
1916 if (soap_send_raw(soap, d, 4))
1917 return soap->error;
1918 }
1919 return SOAP_OK;
1920 }
1921 #endif
1922
1923 /******************************************************************************/
1924 #ifndef PALM_1
1925 SOAP_FMAC1
1926 unsigned char*
1927 SOAP_FMAC2
1928 soap_getbase64(struct soap *soap, int *n, int malloc_flag)
1929 { (void)malloc_flag;
1930 #ifdef WITH_DOM
1931 if ((soap->mode & SOAP_XML_DOM) && soap->dom)
1932 { soap->dom->data = soap_string_in(soap, 0, -1, -1);
1933 return (unsigned char*)soap_base642s(soap, soap->dom->data, NULL, 0, n);
1934 }
1935 #endif
1936 #ifdef WITH_FAST
1937 soap->labidx = 0;
1938 for (;;)
1939 { register size_t i, k;
1940 register char *s;
1941 if (soap_append_lab(soap, NULL, 2))
1942 return NULL;
1943 s = soap->labbuf + soap->labidx;
1944 k = soap->lablen - soap->labidx;
1945 soap->labidx = 3 * (soap->lablen / 3);
1946 if (!s)
1947 return NULL;
1948 if (k > 2)
1949 { for (i = 0; i < k - 2; i += 3)
1950 { register unsigned long m = 0;
1951 register int j = 0;
1952 do
1953 { register soap_wchar c = soap_get(soap);
1954 if (c < SOAP_AP)
1955 c &= 0x7FFFFFFF;
1956 if (c == '=' || c < 0)
1957 { unsigned char *p;
1958 switch (j)
1959 { case 2:
1960 *s++ = (char)((m >> 4) & 0xFF);
1961 i++;
1962 break;
1963 case 3:
1964 *s++ = (char)((m >> 10) & 0xFF);
1965 *s++ = (char)((m >> 2) & 0xFF);
1966 i += 2;
1967 }
1968 if (n)
1969 *n = (int)(soap->lablen + i - k);
1970 p = (unsigned char*)soap_malloc(soap, soap->lablen + i - k);
1971 if (p)
1972 memcpy(p, soap->labbuf, soap->lablen + i - k);
1973 if (c >= 0)
1974 { while ((int)((c = soap_get(soap)) != EOF) && c != SOAP_LT && c != SOAP_TT)
1975 ;
1976 }
1977 soap_unget(soap, c);
1978 return p;
1979 }
1980 c -= '+';
1981 if (c >= 0 && c <= 79)
1982 { register int b = soap_base64i[c];
1983 if (b >= 64)
1984 { soap->error = SOAP_TYPE;
1985 return NULL;
1986 }
1987 m = (m << 6) + b;
1988 j++;
1989 }
1990 else if (!soap_blank(c + '+'))
1991 { soap->error = SOAP_TYPE;
1992 return NULL;
1993 }
1994 } while (j < 4);
1995 *s++ = (char)((m >> 16) & 0xFF);
1996 *s++ = (char)((m >> 8) & 0xFF);
1997 *s++ = (char)(m & 0xFF);
1998 }
1999 }
2000 }
2001 #else
2002 if (soap_new_block(soap) == NULL)
2003 return NULL;
2004 for (;;)
2005 { register int i;
2006 register char *s = (char*)soap_push_block(soap, NULL, 3 * SOAP_BLKLEN); /* must be multiple of 3 */
2007 if (!s)
2008 { soap_end_block(soap, NULL);
2009 return NULL;
2010 }
2011 for (i = 0; i < SOAP_BLKLEN; i++)
2012 { register unsigned long m = 0;
2013 register int j = 0;
2014 do
2015 { register soap_wchar c = soap_get(soap);
2016 if (c == '=' || c < 0)
2017 { unsigned char *p;
2018 i *= 3;
2019 switch (j)
2020 { case 2:
2021 *s++ = (char)((m >> 4) & 0xFF);
2022 i++;
2023 break;
2024 case 3:
2025 *s++ = (char)((m >> 10) & 0xFF);
2026 *s++ = (char)((m >> 2) & 0xFF);
2027 i += 2;
2028 }
2029 if (n)
2030 *n = (int)soap_size_block(soap, NULL, i);
2031 p = (unsigned char*)soap_save_block(soap, NULL, 0);
2032 if (c >= 0)
2033 { while ((int)((c = soap_get(soap)) != EOF) && c != SOAP_LT && c != SOAP_TT)
2034 ;
2035 }
2036 soap_unget(soap, c);
2037 return p;
2038 }
2039 c -= '+';
2040 if (c >= 0 && c <= 79)
2041 { int b = soap_base64i[c];
2042 if (b >= 64)
2043 { soap->error = SOAP_TYPE;
2044 return NULL;
2045 }
2046 m = (m << 6) + b;
2047 j++;
2048 }
2049 else if (!soap_blank(c))
2050 { soap->error = SOAP_TYPE;
2051 return NULL;
2052 }
2053 } while (j < 4);
2054 *s++ = (char)((m >> 16) & 0xFF);
2055 *s++ = (char)((m >> 8) & 0xFF);
2056 *s++ = (char)(m & 0xFF);
2057 }
2058 }
2059 #endif
2060 }
2061 #endif
2062
2063 /******************************************************************************/
2064 #ifndef WITH_LEANER
2065 #ifndef PALM_1
2066 SOAP_FMAC1
2067 int
2068 SOAP_FMAC2
2069 soap_xop_forward(struct soap *soap, unsigned char **ptr, int *size, char **id, char **type, char **options)
2070 { /* Check MTOM xop:Include element (within hex/base64Binary) */
2071 /* TODO: this code to be obsoleted with new import/xop.h conventions */
2072 short body = soap->body; /* should save type too? */
2073 if (!soap_peek_element(soap))
2074 { if (!soap_element_begin_in(soap, "xop:Include", 0, NULL))
2075 { if (soap_dime_forward(soap, ptr, size, id, type, options)
2076 || (soap->body && soap_element_end_in(soap, "xop:Include")))
2077 return soap->error;
2078 }
2079 }
2080 soap->body = body;
2081 return SOAP_OK;
2082 }
2083 #endif
2084 #endif
2085
2086 /******************************************************************************/
2087 #ifndef WITH_LEANER
2088 #ifndef PALM_1
2089 SOAP_FMAC1
2090 int
2091 SOAP_FMAC2
2092 soap_dime_forward(struct soap *soap, unsigned char **ptr, int *size, char **id, char **type, char **options)
2093 { struct soap_xlist *xp;
2094 *ptr = NULL;
2095 *size = 0;
2096 *id = NULL;
2097 *type = NULL;
2098 *options = NULL;
2099 if (!*soap->href)
2100 return SOAP_OK;
2101 *id = soap_strdup(soap, soap->href);
2102 xp = (struct soap_xlist*)SOAP_MALLOC(soap, sizeof(struct soap_xlist));
2103 if (!xp)
2104 return soap->error = SOAP_EOM;
2105 xp->next = soap->xlist;
2106 xp->ptr = ptr;
2107 xp->size = size;
2108 xp->id = *id;
2109 xp->type = type;
2110 xp->options = options;
2111 soap->xlist = xp;
2112 return SOAP_OK;
2113 }
2114 #endif
2115 #endif
2116
2117 /******************************************************************************/
2118 #ifndef PALM_1
2119 SOAP_FMAC1
2120 char *
2121 SOAP_FMAC2
2122 soap_strdup(struct soap *soap, const char *s)
2123 { char *t = NULL;
2124 if (s && (t = (char*)soap_malloc(soap, strlen(s) + 1)))
2125 strcpy(t, s);
2126 return t;
2127 }
2128 #endif
2129
2130 /******************************************************************************/
2131 #ifndef PALM_1
2132 SOAP_FMAC1
2133 wchar_t *
2134 SOAP_FMAC2
2135 soap_wstrdup(struct soap *soap, const wchar_t *s)
2136 { wchar_t *t = NULL;
2137 if (s)
2138 { size_t n = 0;
2139 while (s[n])
2140 n++;
2141 if ((t = (wchar_t*)soap_malloc(soap, sizeof(wchar_t)*(n+1))))
2142 memcpy(t, s, sizeof(wchar_t)*(n+1));
2143 }
2144 return t;
2145 }
2146 #endif
2147
2148 /******************************************************************************/
2149 #ifndef PALM_1
2150 SOAP_FMAC1
2151 struct soap_blist*
2152 SOAP_FMAC2
2153 soap_new_block(struct soap *soap)
2154 { struct soap_blist *p;
2155 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "New block sequence (prev=%p)\n", soap->blist));
2156 if (!(p = (struct soap_blist*)SOAP_MALLOC(soap, sizeof(struct soap_blist))))
2157 { soap->error = SOAP_EOM;
2158 return NULL;
2159 }
2160 p->next = soap->blist;
2161 p->ptr = NULL;
2162 p->size = 0;
2163 soap->blist = p;
2164 return p;
2165 }
2166 #endif
2167
2168 /******************************************************************************/
2169 #ifndef PALM_1
2170 SOAP_FMAC1
2171 void*
2172 SOAP_FMAC2
2173 soap_push_block(struct soap *soap, struct soap_blist *b, size_t n)
2174 { char *p;
2175 if (!b)
2176 b = soap->blist;
2177 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push block of %u bytes (%u bytes total)\n", (unsigned int)n, (unsigned int)b->size + (unsigned int)n));
2178 if (!(p = (char*)SOAP_MALLOC(soap, n + sizeof(char*) + sizeof(size_t))))
2179 { soap->error = SOAP_EOM;
2180 return NULL;
2181 }
2182 *(char**)p = b->ptr;
2183 *(size_t*)(p + sizeof(char*)) = n;
2184 b->ptr = p;
2185 b->size += n;
2186 return p + sizeof(char*) + sizeof(size_t);
2187 }
2188 #endif
2189
2190 /******************************************************************************/
2191 #ifndef PALM_1
2192 SOAP_FMAC1
2193 void
2194 SOAP_FMAC2
2195 soap_pop_block(struct soap *soap, struct soap_blist *b)
2196 { char *p;
2197 if (!b)
2198 b = soap->blist;
2199 if (!b->ptr)
2200 return;
2201 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Pop block\n"));
2202 p = b->ptr;
2203 b->size -= *(size_t*)(p + sizeof(char*));
2204 b->ptr = *(char**)p;
2205 SOAP_FREE(soap, p);
2206 }
2207 #endif
2208
2209 /******************************************************************************/
2210 #ifndef PALM_1
2211 SOAP_FMAC1
2212 void
2213 SOAP_FMAC2
2214 soap_update_pointers(struct soap *soap, char *start, char *end, char *p1, char *p2)
2215 {
2216 #ifndef WITH_NOIDREF
2217 int i;
2218 register struct soap_ilist *ip = NULL;
2219 register struct soap_flist *fp = NULL;
2220 #ifndef WITH_LEANER
2221 register struct soap_xlist *xp = NULL;
2222 #endif
2223 register void *p, **q;
2224 for (i = 0; i < SOAP_IDHASH; i++)
2225 { for (ip = soap->iht[i]; ip; ip = ip->next)
2226 { if (ip->ptr && (char*)ip->ptr >= start && (char*)ip->ptr < end)
2227 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Update id='%s' %p -> %p\n", ip->id, ip->ptr, (char*)ip->ptr + (p1-p2)));
2228 ip->ptr = (char*)ip->ptr + (p1-p2);
2229 }
2230 for (q = &ip->link; q; q = (void**)p)
2231 { p = *q;
2232 if (p && (char*)p >= start && (char*)p < end)
2233 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Link update id='%s' %p\n", ip->id, p));
2234 *q = (char*)p + (p1-p2);
2235 }
2236 }
2237 for (q = &ip->copy; q; q = (void**)p)
2238 { p = *q;
2239 if (p && (char*)p >= start && (char*)p < end)
2240 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy chain update id='%s' %p\n", ip->id, p));
2241 *q = (char*)p + (p1-p2);
2242 }
2243 }
2244 for (fp = ip->flist; fp; fp = fp->next)
2245 { if ((char*)fp->ptr >= start && (char*)fp->ptr < end)
2246 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy list update id='%s' %p\n", ip->id, fp));
2247 fp->ptr = (char*)fp->ptr + (p1-p2);
2248 }
2249 }
2250 }
2251 }
2252 #ifndef WITH_LEANER
2253 for (xp = soap->xlist; xp; xp = xp->next)
2254 { if (xp->ptr && (char*)xp->ptr >= start && (char*)xp->ptr < end)
2255 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Update id='%s' %p -> %p\n", xp->id ? xp->id : SOAP_STR_EOS, xp->ptr, (char*)xp->ptr + (p1-p2)));
2256 xp->ptr = (unsigned char**)((char*)xp->ptr + (p1-p2));
2257 xp->size = (int*)((char*)xp->size + (p1-p2));
2258 xp->type = (char**)((char*)xp->type + (p1-p2));
2259 xp->options = (char**)((char*)xp->options + (p1-p2));
2260 }
2261 }
2262 #endif
2263 #else
2264 (void)soap; (void)start; (void)end; (void)p1; (void)p2;
2265 #endif
2266 }
2267 #endif
2268
2269 /******************************************************************************/
2270 #ifndef WITH_NOIDREF
2271 #ifndef PALM_1
2272 static int
2273 soap_has_copies(struct soap *soap, register const char *start, register const char *end)
2274 { register int i;
2275 register struct soap_ilist *ip = NULL;
2276 register struct soap_flist *fp = NULL;
2277 register const char *p;
2278 for (i = 0; i < SOAP_IDHASH; i++)
2279 { for (ip = soap->iht[i]; ip; ip = ip->next)
2280 { for (p = (const char*)ip->copy; p; p = *(const char**)p)
2281 if (p >= start && p < end)
2282 return SOAP_ERR;
2283 for (fp = ip->flist; fp; fp = fp->next)
2284 if ((const char*)fp->ptr >= start && (const char*)fp->ptr < end)
2285 return SOAP_ERR;
2286 }
2287 }
2288 return SOAP_OK;
2289 }
2290 #endif
2291 #endif
2292
2293 /******************************************************************************/
2294 #ifndef WITH_NOIDREF
2295 #ifndef PALM_1
2296 SOAP_FMAC1
2297 int
2298 SOAP_FMAC2
2299 soap_resolve(struct soap *soap)
2300 { register int i;
2301 register struct soap_ilist *ip = NULL;
2302 register struct soap_flist *fp = NULL;
2303 short flag;
2304 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolving forwarded data\n"));
2305 for (i = 0; i < SOAP_IDHASH; i++)
2306 { for (ip = soap->iht[i]; ip; ip = ip->next)
2307 { if (ip->ptr)
2308 { register void *p, **q, *r;
2309 q = (void**)ip->link;
2310 ip->link = NULL;
2311 r = ip->ptr;
2312 DBGLOG(TEST, if (q) SOAP_MESSAGE(fdebug, "Traversing link chain to resolve id='%s'\n", ip->id));
2313 while (q)
2314 { p = *q;
2315 *q = r;
2316 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "... link %p -> %p\n", q, r));
2317 q = (void**)p;
2318 }
2319 }
2320 else if (*ip->id == '#')
2321 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Missing data for id='%s'\n", ip->id));
2322 strcpy(soap->id, ip->id + 1);
2323 return soap->error = SOAP_MISSING_ID;
2324 }
2325 }
2326 }
2327 do
2328 { flag = 0;
2329 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolution phase\n"));
2330 for (i = 0; i < SOAP_IDHASH; i++)
2331 { for (ip = soap->iht[i]; ip; ip = ip->next)
2332 { if (ip->ptr && !soap_has_copies(soap, (const char*)ip->ptr, (const char*)ip->ptr + ip->size))
2333 { if (ip->copy)
2334 { register void *p, **q = (void**)ip->copy;
2335 DBGLOG(TEST, if (q) SOAP_MESSAGE(fdebug, "Traversing copy chain to resolve id='%s'\n", ip->id));
2336 ip->copy = NULL;
2337 do
2338 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "... copy %p -> %p (%u bytes)\n", ip->ptr, q, (unsigned int)ip->size));
2339 p = *q;
2340 memcpy(q, ip->ptr, ip->size);
2341 q = (void**)p;
2342 } while (q);
2343 flag = 1;
2344 }
2345 for (fp = ip->flist; fp; fp = ip->flist)
2346 { register unsigned int k = fp->level;
2347 register void *p = ip->ptr;
2348 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolving forwarded data type=%d location=%p level=%u,%u id='%s'\n", ip->type, p, ip->level, fp->level, ip->id));
2349 while (ip->level < k)
2350 { register void **q = (void**)soap_malloc(soap, sizeof(void*));
2351 if (!q)
2352 return soap->error;
2353 *q = p;
2354 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Descending one level, new location=%p holds=%p...\n", q, *q));
2355 p = (void*)q;
2356 k--;
2357 }
2358 if (fp->fcopy)
2359 fp->fcopy(soap, ip->type, fp->type, fp->ptr, fp->len, p, ip->size);
2360 else
2361 soap_fcopy(soap, ip->type, fp->type, fp->ptr, fp->len, p, ip->size);
2362 ip->flist = fp->next;
2363 SOAP_FREE(soap, fp);
2364 flag = 1;
2365 }
2366 }
2367 }
2368 }
2369 } while (flag);
2370 #ifdef SOAP_DEBUG
2371 for (i = 0; i < SOAP_IDHASH; i++)
2372 { for (ip = soap->iht[i]; ip; ip = ip->next)
2373 { if (ip->copy || ip->flist)
2374 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolution error: forwarded data for id='%s' could not be propagated, please report this problem to the developers\n", ip->id));
2375 }
2376 }
2377 }
2378 #endif
2379 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolution done\n"));
2380 return SOAP_OK;
2381 }
2382 #endif
2383 #endif
2384
2385 /******************************************************************************/
2386 #ifndef PALM_1
2387 SOAP_FMAC1
2388 size_t
2389 SOAP_FMAC2
2390 soap_size_block(struct soap *soap, struct soap_blist *b, size_t n)
2391 { if (!b)
2392 b = soap->blist;
2393 if (b->ptr)
2394 { b->size -= *(size_t*)(b->ptr + sizeof(char*)) - n;
2395 *(size_t*)(b->ptr + sizeof(char*)) = n;
2396 }
2397 return b->size;
2398 }
2399 #endif
2400
2401 /******************************************************************************/
2402 #ifndef PALM_1
2403 SOAP_FMAC1
2404 char*
2405 SOAP_FMAC2
2406 soap_first_block(struct soap *soap, struct soap_blist *b)
2407 { char *p, *q, *r;
2408 if (!b)
2409 b = soap->blist;
2410 p = b->ptr;
2411 if (!p)
2412 return NULL;
2413 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "First block\n"));
2414 r = NULL;
2415 do
2416 { q = *(char**)p;
2417 *(char**)p = r;
2418 r = p;
2419 p = q;
2420 } while (p);
2421 b->ptr = r;
2422 return r + sizeof(char*) + sizeof(size_t);
2423 }
2424 #endif
2425
2426 /******************************************************************************/
2427 #ifndef PALM_1
2428 SOAP_FMAC1
2429 char*
2430 SOAP_FMAC2
2431 soap_next_block(struct soap *soap, struct soap_blist *b)
2432 { char *p;
2433 if (!b)
2434 b = soap->blist;
2435 p = b->ptr;
2436 if (p)
2437 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Next block\n"));
2438 b->ptr = *(char**)p;
2439 SOAP_FREE(soap, p);
2440 if (b->ptr)
2441 return b->ptr + sizeof(char*) + sizeof(size_t);
2442 }
2443 return NULL;
2444 }
2445 #endif
2446
2447 /******************************************************************************/
2448 #ifndef PALM_1
2449 SOAP_FMAC1
2450 size_t
2451 SOAP_FMAC2
2452 soap_block_size(struct soap *soap, struct soap_blist *b)
2453 { if (!b)
2454 b = soap->blist;
2455 return *(size_t*)(b->ptr + sizeof(char*));
2456 }
2457 #endif
2458
2459 /******************************************************************************/
2460 #ifndef PALM_1
2461 SOAP_FMAC1
2462 void
2463 SOAP_FMAC2
2464 soap_end_block(struct soap *soap, struct soap_blist *b)
2465 { char *p, *q;
2466 if (!b)
2467 b = soap->blist;
2468 if (b)
2469 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of block sequence, free all remaining blocks\n"));
2470 for (p = b->ptr; p; p = q)
2471 { q = *(char**)p;
2472 SOAP_FREE(soap, p);
2473 }
2474 if (soap->blist == b)
2475 soap->blist = b->next;
2476 else
2477 { struct soap_blist *bp;
2478 for (bp = soap->blist; bp; bp = bp->next)
2479 { if (bp->next == b)
2480 { bp->next = b->next;
2481 break;
2482 }
2483 }
2484 }
2485 SOAP_FREE(soap, b);
2486 }
2487 DBGLOG(TEST, if (soap->blist) SOAP_MESSAGE(fdebug, "Restore previous block sequence\n"));
2488 }
2489 #endif
2490
2491 /******************************************************************************/
2492 #ifndef PALM_1
2493 SOAP_FMAC1
2494 char*
2495 SOAP_FMAC2
2496 soap_save_block(struct soap *soap, struct soap_blist *b, char *p, int flag)
2497 { register size_t n;
2498 register char *q, *s;
2499 if (!b)
2500 b = soap->blist;
2501 if (b->size)
2502 { if (!p)
2503 p = (char*)soap_malloc(soap, b->size);
2504 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Save all blocks in contiguous memory space of %u bytes (%p->%p)\n", (unsigned int)b->size, b->ptr, p));
2505 if (p)
2506 { for (s = p, q = soap_first_block(soap, b); q; q = soap_next_block(soap, b))
2507 { n = soap_block_size(soap, b);
2508 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy %u bytes from %p to %p\n", (unsigned int)n, q, s));
2509 #ifndef WITH_NOIDREF
2510 if (flag)
2511 soap_update_pointers(soap, q, q + n, s, q);
2512 #endif
2513 memcpy(s, q, n);
2514 s += n;
2515 }
2516 }
2517 else
2518 soap->error = SOAP_EOM;
2519 }
2520 soap_end_block(soap, b);
2521 return p;
2522 }
2523 #endif
2524
2525 /******************************************************************************/
2526 #ifndef PALM_2
2527 SOAP_FMAC1
2528 char *
2529 SOAP_FMAC2
2530 soap_putsize(struct soap *soap, const char *type, int size)
2531 { return soap_putsizes(soap, type, &size, 1);
2532 }
2533 #endif
2534
2535 /******************************************************************************/
2536 #ifndef PALM_2
2537 SOAP_FMAC1
2538 char *
2539 SOAP_FMAC2
2540 soap_putsizes(struct soap *soap, const char *type, const int *size, int dim)
2541 { return soap_putsizesoffsets(soap, type, size, NULL, dim);
2542 }
2543 #endif
2544
2545 /******************************************************************************/
2546 #ifndef PALM_2
2547 SOAP_FMAC1
2548 char *
2549 SOAP_FMAC2
2550 soap_putsizesoffsets(struct soap *soap, const char *type, const int *size, const int *offset, int dim)
2551 { register int i;
2552 register size_t l;
2553 if (!type || strlen(type) + 13 > sizeof(soap->type)) /* prevent overruns */
2554 return NULL;
2555 if (soap->version == 2)
2556 {
2557 #ifdef HAVE_SNPRINTF
2558 soap_snprintf(soap->type, sizeof(soap->type) - 1, "%s[%d", type, size[0]);
2559 #else
2560 sprintf(soap->type, "%s[%d", type, size[0]);
2561 #endif
2562 for (i = 1; i < dim; i++)
2563 {
2564 #ifdef HAVE_SNPRINTF
2565 l = strlen(soap->type);
2566 soap_snprintf(soap->type + l, sizeof(soap->type) - l - 1, " %d", size[i]);
2567 #else
2568 if ((l = strlen(soap->type)) + 13 > sizeof(soap->type))
2569 return NULL;
2570 sprintf(soap->type + l, " %d", size[i]);
2571 #endif
2572 }
2573 }
2574 else
2575 { if (offset)
2576 {
2577 #ifdef HAVE_SNPRINTF
2578 soap_snprintf(soap->type, sizeof(soap->type) - 1, "%s[%d", type, size[0] + offset[0]);
2579 #else
2580 sprintf(soap->type, "%s[%d", type, size[0] + offset[0]);
2581 #endif
2582 for (i = 1; i < dim; i++)
2583 {
2584 #ifdef HAVE_SNPRINTF
2585 l = strlen(soap->type);
2586 soap_snprintf(soap->type + l, sizeof(soap->type) - l - 1, ",%d", size[i] + offset[i]);
2587 #else
2588 if ((l = strlen(soap->type)) + 13 > sizeof(soap->type))
2589 return NULL;
2590 sprintf(soap->type + l, ",%d", size[i] + offset[i]);
2591 #endif
2592 }
2593 }
2594 else
2595 {
2596 #ifdef HAVE_SNPRINTF
2597 soap_snprintf(soap->type, sizeof(soap->type) - 1, "%s[%d", type, size[0]);
2598 #else
2599 sprintf(soap->type, "%s[%d", type, size[0]);
2600 #endif
2601 for (i = 1; i < dim; i++)
2602 {
2603 #ifdef HAVE_SNPRINTF
2604 l = strlen(soap->type);
2605 soap_snprintf(soap->type + l, sizeof(soap->type) - l - 1, ",%d", size[i]);
2606 #else
2607 if ((l = strlen(soap->type)) + 13 > sizeof(soap->type))
2608 return NULL;
2609 sprintf(soap->type + l, ",%d", size[i]);
2610 #endif
2611 }
2612 }
2613 }
2614 strcat(soap->type, "]");
2615 return soap->type;
2616 }
2617 #endif
2618
2619 /******************************************************************************/
2620 #ifndef PALM_2
2621 SOAP_FMAC1
2622 char *
2623 SOAP_FMAC2
2624 soap_putoffset(struct soap *soap, int offset)
2625 { return soap_putoffsets(soap, &offset, 1);
2626 }
2627 #endif
2628
2629 /******************************************************************************/
2630 #ifndef PALM_2
2631 SOAP_FMAC1
2632 char *
2633 SOAP_FMAC2
2634 soap_putoffsets(struct soap *soap, const int *offset, int dim)
2635 { register int i;
2636 register size_t l;
2637 #ifdef HAVE_SNPRINTF
2638 soap_snprintf(soap->arrayOffset, sizeof(soap->arrayOffset) - 1, "[%d", offset[0]);
2639 #else
2640 if (sizeof(soap->arrayOffset) < 13) /* prevent overruns */
2641 return NULL;
2642 sprintf(soap->arrayOffset, "[%d", offset[0]);
2643 #endif
2644 for (i = 1; i < dim; i++)
2645 {
2646 #ifdef HAVE_SNPRINTF
2647 l = strlen(soap->arrayOffset);
2648 soap_snprintf(soap->arrayOffset + l, sizeof(soap->arrayOffset) - l - 1, ",%d", offset[i]);
2649 #else
2650 if ((l = strlen(soap->arrayOffset)) + 13 > sizeof(soap->arrayOffset))
2651 return NULL;
2652 sprintf(soap->arrayOffset + l, ",%d", offset[i]);
2653 #endif
2654 }
2655 strcat(soap->arrayOffset, "]");
2656 return soap->arrayOffset;
2657 }
2658 #endif
2659
2660 /******************************************************************************/
2661 #ifndef PALM_2
2662 SOAP_FMAC1
2663 int
2664 SOAP_FMAC2
2665 soap_size(const int *size, int dim)
2666 { register int i, n = size[0];
2667 for (i = 1; i < dim; i++)
2668 n *= size[i];
2669 return n;
2670 }
2671 #endif
2672
2673 /******************************************************************************/
2674 #ifndef PALM_2
2675 SOAP_FMAC1
2676 int
2677 SOAP_FMAC2
2678 soap_getoffsets(const char *attr, const int *size, int *offset, int dim)
2679 { register int i, j = 0;
2680 if (offset)
2681 for (i = 0; i < dim && attr && *attr; i++)
2682 { attr++;
2683 j *= size[i];
2684 j += offset[i] = (int)soap_strtol(attr, NULL, 10);
2685 attr = strchr(attr, ',');
2686 }
2687 else
2688 for (i = 0; i < dim && attr && *attr; i++)
2689 { attr++;
2690 j *= size[i];
2691 j += (int)soap_strtol(attr, NULL, 10);
2692 attr = strchr(attr, ',');
2693 }
2694 return j;
2695 }
2696 #endif
2697
2698 /******************************************************************************/
2699 #ifndef PALM_2
2700 SOAP_FMAC1
2701 int
2702 SOAP_FMAC2
2703 soap_getsize(const char *attr1, const char *attr2, int *j)
2704 { register int n, k;
2705 char *s;
2706 *j = 0;
2707 if (!*attr1)
2708 return -1;
2709 if (*attr1 == '[')
2710 attr1++;
2711 n = 1;
2712 for (;;)
2713 { k = (int)soap_strtol(attr1, &s, 10);
2714 n *= k;
2715 if (k < 0 || n > SOAP_MAXARRAYSIZE || s == attr1)
2716 return -1;
2717 attr1 = strchr(s, ',');
2718 if (!attr1)
2719 attr1 = strchr(s, ' ');
2720 if (attr2 && *attr2)
2721 { attr2++;
2722 *j *= k;
2723 k = (int)soap_strtol(attr2, &s, 10);
2724 *j += k;
2725 if (k < 0)
2726 return -1;
2727 attr2 = s;
2728 }
2729 if (!attr1)
2730 break;
2731 attr1++;
2732 }
2733 return n - *j;
2734 }
2735 #endif
2736
2737 /******************************************************************************/
2738 #ifndef PALM_2
2739 SOAP_FMAC1
2740 int
2741 SOAP_FMAC2
2742 soap_getsizes(const char *attr, int *size, int dim)
2743 { register int i, k, n;
2744 if (!*attr)
2745 return -1;
2746 i = (int)strlen(attr);
2747 n = 1;
2748 do
2749 { for (i = i-1; i >= 0; i--)
2750 if (attr[i] == '[' || attr[i] == ',' || attr[i] == ' ')
2751 break;
2752 k = (int)soap_strtol(attr + i + 1, NULL, 10);
2753 n *= size[--dim] = k;
2754 if (k < 0 || n > SOAP_MAXARRAYSIZE)
2755 return -1;
2756 } while (i >= 0 && attr[i] != '[');
2757 return n;
2758 }
2759 #endif
2760
2761 /******************************************************************************/
2762 #ifndef PALM_2
2763 SOAP_FMAC1
2764 int
2765 SOAP_FMAC2
2766 soap_getposition(const char *attr, int *pos)
2767 { register int i, n;
2768 if (!*attr)
2769 return -1;
2770 n = 0;
2771 i = 1;
2772 do
2773 { pos[n++] = (int)soap_strtol(attr + i, NULL, 10);
2774 while (attr[i] && attr[i] != ',' && attr[i] != ']')
2775 i++;
2776 if (attr[i] == ',')
2777 i++;
2778 } while (n < SOAP_MAXDIMS && attr[i] && attr[i] != ']');
2779 return n;
2780 }
2781 #endif
2782
2783 /******************************************************************************/
2784 #ifndef PALM_2
2785 SOAP_FMAC1
2786 struct soap_nlist *
2787 SOAP_FMAC2
2788 soap_push_namespace(struct soap *soap, const char *id, const char *ns)
2789 { register struct soap_nlist *np;
2790 register struct Namespace *p;
2791 register short i = -1;
2792 register size_t n, k;
2793 n = strlen(id);
2794 k = strlen(ns) + 1;
2795 p = soap->local_namespaces;
2796 if (p)
2797 { for (i = 0; p->id; p++, i++)
2798 { if (p->ns && !strcmp(ns, p->ns))
2799 break;
2800 if (p->out)
2801 { if (!strcmp(ns, p->out))
2802 break;
2803 }
2804 else if (p->in)
2805 { if (!soap_tag_cmp(ns, p->in))
2806 { if ((p->out = (char*)SOAP_MALLOC(soap, k)))
2807 strcpy(p->out, ns);
2808 break;
2809 }
2810 }
2811 }
2812 if (!p || !p->id)
2813 i = -1;
2814 }
2815 if (i >= 0)
2816 k = 0;
2817 np = (struct soap_nlist*)SOAP_MALLOC(soap, sizeof(struct soap_nlist) + n + k);
2818 if (!np)
2819 { soap->error = SOAP_EOM;
2820 return NULL;
2821 }
2822 np->next = soap->nlist;
2823 soap->nlist = np;
2824 np->level = soap->level;
2825 np->index = i;
2826 strcpy((char*)np->id, id);
2827 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push namespace binding (level=%u) '%s' '%s'\n", soap->level, id, ns));
2828 if (i < 0)
2829 { np->ns = strcpy((char*)np->id + n + 1, ns);
2830 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push NOT OK: no match found for '%s' in namespace mapping table (added to stack anyway)\n", ns));
2831 }
2832 else
2833 { np->ns = NULL;
2834 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push OK ('%s' matches '%s' in namespace table)\n", id, p->id));
2835 }
2836 return np;
2837 }
2838 #endif
2839
2840 /******************************************************************************/
2841 #ifndef PALM_2
2842 SOAP_FMAC1
2843 void
2844 SOAP_FMAC2
2845 soap_pop_namespace(struct soap *soap)
2846 { register struct soap_nlist *np, *nq;
2847 for (np = soap->nlist; np && np->level >= soap->level; np = nq)
2848 { nq = np->next;
2849 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Pop namespace binding (level=%u) '%s'\n", soap->level, np->id));
2850 SOAP_FREE(soap, np);
2851 }
2852 soap->nlist = np;
2853 }
2854 #endif
2855
2856 /******************************************************************************/
2857 #ifndef PALM_2
2858 SOAP_FMAC1
2859 int
2860 SOAP_FMAC2
2861 soap_match_namespace(struct soap *soap, const char *id1, const char *id2, size_t n1, size_t n2)
2862 { register struct soap_nlist *np = soap->nlist;
2863 const char *s;
2864 while (np && (strncmp(np->id, id1, n1) || np->id[n1]))
2865 np = np->next;
2866 if (np)
2867 { if (!(soap->mode & SOAP_XML_IGNORENS))
2868 if (np->index < 0
2869 || ((s = soap->local_namespaces[np->index].id) && (strncmp(s, id2, n2) || (s[n2] && s[n2] != '_'))))
2870 return SOAP_NAMESPACE;
2871 return SOAP_OK;
2872 }
2873 if (n1 == 0)
2874 return (soap->mode & SOAP_XML_IGNORENS) ? SOAP_OK : SOAP_NAMESPACE;
2875 if ((n1 == 3 && n1 == n2 && !strncmp(id1, "xml", 3) && !strncmp(id1, id2, 3))
2876 || (soap->mode & SOAP_XML_IGNORENS))
2877 return SOAP_OK;
2878 return soap->error = SOAP_SYNTAX_ERROR;
2879 }
2880 #endif
2881
2882 /******************************************************************************/
2883 #ifndef PALM_2
2884 SOAP_FMAC1
2885 const char*
2886 SOAP_FMAC2
2887 soap_current_namespace(struct soap *soap, const char *tag)
2888 { register struct soap_nlist *np;
2889 register const char *s;
2890 if (!tag || !strncmp(tag, "xml", 3))
2891 return NULL;
2892 np = soap->nlist;
2893 if (!(s = strchr(tag, ':')))
2894 { while (np && *np->id) /* find default namespace, if present */
2895 np = np->next;
2896 }
2897 else
2898 { while (np && (strncmp(np->id, tag, s - tag) || np->id[s - tag]))
2899 np = np->next;
2900 if (!np)
2901 soap->error = SOAP_NAMESPACE;
2902 }
2903 if (np)
2904 { if (np->index >= 0)
2905 return soap->namespaces[np->index].ns;
2906 if (np->ns)
2907 return soap_strdup(soap, np->ns);
2908 }
2909 return NULL;
2910 }
2911 #endif
2912
2913 /******************************************************************************/
2914 #ifndef PALM_2
2915 SOAP_FMAC1
2916 int
2917 SOAP_FMAC2
2918 soap_tag_cmp(const char *s, const char *t)
2919 { for (;;)
2920 { register int c1 = *s;
2921 register int c2 = *t;
2922 if (!c1 || c1 == '"')
2923 break;
2924 if (c2 != '-')
2925 { if (c1 != c2)
2926 { if (c1 >= 'A' && c1 <= 'Z')
2927 c1 += 'a' - 'A';
2928 if (c2 >= 'A' && c2 <= 'Z')
2929 c2 += 'a' - 'A';
2930 }
2931 if (c1 != c2)
2932 { if (c2 != '*')
2933 return 1;
2934 c2 = *++t;
2935 if (!c2)
2936 return 0;
2937 if (c2 >= 'A' && c2 <= 'Z')
2938 c2 += 'a' - 'A';
2939 for (;;)
2940 { c1 = *s;
2941 if (!c1 || c1 == '"')
2942 break;
2943 if (c1 >= 'A' && c1 <= 'Z')
2944 c1 += 'a' - 'A';
2945 if (c1 == c2 && !soap_tag_cmp(s + 1, t + 1))
2946 return 0;
2947 s++;
2948 }
2949 break;
2950 }
2951 }
2952 s++;
2953 t++;
2954 }
2955 if (*t == '*' && !t[1])
2956 return 0;
2957 return *t;
2958 }
2959 #endif
2960
2961 /******************************************************************************/
2962 #ifndef PALM_2
2963 SOAP_FMAC1
2964 int
2965 SOAP_FMAC2
2966 soap_match_tag(struct soap *soap, const char *tag1, const char *tag2)
2967 { register const char *s, *t;
2968 register int err;
2969 if (!tag1 || !tag2 || !*tag2)
2970 return SOAP_OK;
2971 s = strchr(tag1, ':');
2972 t = strchr(tag2, ':');
2973 if (t)
2974 { if (s)
2975 { if (t[1] && SOAP_STRCMP(s + 1, t + 1))
2976 return SOAP_TAG_MISMATCH;
2977 if (t != tag2 && (err = soap_match_namespace(soap, tag1, tag2, s - tag1, t - tag2)))
2978 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Tags '%s' and '%s' match but namespaces differ\n", tag1, tag2));
2979 if (err == SOAP_NAMESPACE)
2980 return SOAP_TAG_MISMATCH;
2981 return err;
2982 }
2983 }
2984 else if (!t[1])
2985 { err = soap_match_namespace(soap, tag1, tag2, 0, t - tag2);
2986 if (err == SOAP_NAMESPACE)
2987 return SOAP_TAG_MISMATCH;
2988 }
2989 else if (SOAP_STRCMP(tag1, t + 1))
2990 { return SOAP_TAG_MISMATCH;
2991 }
2992 else if (t != tag2 && (err = soap_match_namespace(soap, tag1, tag2, 0, t - tag2)))
2993 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Tags '%s' and '%s' match but namespaces differ\n", tag1, tag2));
2994 if (err == SOAP_NAMESPACE)
2995 return SOAP_TAG_MISMATCH;
2996 return err;
2997 }
2998 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Tags and (default) namespaces match: '%s' '%s'\n", tag1, tag2));
2999 return SOAP_OK;
3000 }
3001 if (s)
3002 { if (SOAP_STRCMP(s + 1, tag2))
3003 return SOAP_TAG_MISMATCH;
3004 }
3005 else if (SOAP_STRCMP(tag1, tag2))
3006 return SOAP_TAG_MISMATCH;
3007 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Tags match: '%s' '%s'\n", tag1, tag2));
3008 return SOAP_OK;
3009 }
3010 #endif
3011
3012 /******************************************************************************/
3013 #ifndef PALM_2
3014 SOAP_FMAC1
3015 int
3016 SOAP_FMAC2
3017 soap_match_array(struct soap *soap, const char *type)
3018 { if (*soap->arrayType)
3019 if (soap_match_tag(soap, soap->arrayType, type)
3020 && soap_match_tag(soap, soap->arrayType, "xsd:anyType")
3021 && soap_match_tag(soap, soap->arrayType, "xsd:ur-type")
3022 )
3023 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Array type mismatch: '%s' '%s'\n", soap->arrayType, type));
3024 return SOAP_TAG_MISMATCH;
3025 }
3026 return SOAP_OK;
3027 }
3028 #endif
3029
3030 /******************************************************************************\
3031 *
3032 * SSL/TLS
3033 *
3034 \******************************************************************************/
3035
3036 /******************************************************************************/
3037 #ifdef WITH_OPENSSL
3038 #ifndef PALM_2
3039 SOAP_FMAC1
3040 int
3041 SOAP_FMAC2
3042 soap_rand()
3043 { unsigned char buf[4];
3044 if (!soap_ssl_init_done)
3045 soap_ssl_init();
3046 RAND_pseudo_bytes(buf, 4);
3047 return *(int*)buf;
3048 }
3049 #endif
3050 #endif
3051
3052 /******************************************************************************/
3053 #if defined(WITH_OPENSSL) || defined(WITH_GNUTLS)
3054 #ifndef PALM_2
3055 SOAP_FMAC1
3056 int
3057 SOAP_FMAC2
3058 #if defined(VXWORKS) && defined(WM_SECURE_KEY_STORAGE)
3059 soap_ssl_server_context(struct soap *soap, unsigned short flags, const char *keyfile, const char *keyid, const char *password, const char *cafile, const char *capath, const char *dhfile, const char *randfile, const char *sid)
3060 #else
3061 soap_ssl_server_context(struct soap *soap, unsigned short flags, const char *keyfile, const char *password, const char *cafile, const char *capath, const char *dhfile, const char *randfile, const char *sid)
3062 #endif
3063 { int err;
3064 soap->keyfile = keyfile;
3065 #if defined(VXWORKS) && defined(WM_SECURE_KEY_STORAGE)
3066 soap->keyid = keyid;
3067 #endif
3068 soap->password = password;
3069 soap->cafile = cafile;
3070 soap->capath = capath;
3071 soap->crlfile = NULL;
3072 #ifdef WITH_OPENSSL
3073 soap->dhfile = dhfile;
3074 soap->randfile = randfile;
3075 #endif
3076 soap->ssl_flags = flags | (dhfile == NULL ? SOAP_SSL_RSA : 0);
3077 #ifdef WITH_GNUTLS
3078 if (dhfile)
3079 { char *s;
3080 int n = (int)soap_strtoul(dhfile, &s, 10);
3081 if (!soap->dh_params)
3082 gnutls_dh_params_init(&soap->dh_params);
3083 /* if dhfile is numeric, treat it as a key length to generate DH params which can take a while */
3084 if (n >= 512 && s && *s == '\0')
3085 gnutls_dh_params_generate2(soap->dh_params, (unsigned int)n);
3086 else
3087 { unsigned int dparams_len;
3088 unsigned char dparams_buf[1024];
3089 FILE *fd = fopen(dhfile, "r");
3090 if (!fd)
3091 return soap_set_receiver_error(soap, "SSL/TLS error", "Invalid DH file", SOAP_SSL_ERROR);
3092 dparams_len = (unsigned int)fread(dparams_buf, 1, sizeof(dparams_buf), fd);
3093 fclose(fd);
3094 gnutls_datum_t dparams = { dparams_buf, dparams_len };
3095 if (gnutls_dh_params_import_pkcs3(soap->dh_params, &dparams, GNUTLS_X509_FMT_PEM))
3096 return soap_set_receiver_error(soap, "SSL/TLS error", "Invalid DH file", SOAP_SSL_ERROR);
3097 }
3098 }
3099 else
3100 { if (!soap->rsa_params)
3101 gnutls_rsa_params_init(&soap->rsa_params);
3102 gnutls_rsa_params_generate2(soap->rsa_params, SOAP_SSL_RSA_BITS);
3103 }
3104 if (soap->session)
3105 { gnutls_deinit(soap->session);
3106 soap->session = NULL;
3107 }
3108 if (soap->xcred)
3109 { gnutls_certificate_free_credentials(soap->xcred);
3110 soap->xcred = NULL;
3111 }
3112 #endif
3113 err = soap->fsslauth(soap);
3114 #ifdef WITH_OPENSSL
3115 if (!err)
3116 { if (sid)
3117 SSL_CTX_set_session_id_context(soap->ctx, (unsigned char*)sid, (unsigned int)strlen(sid));
3118 else
3119 SSL_CTX_set_session_cache_mode(soap->ctx, SSL_SESS_CACHE_OFF);
3120 }
3121 #endif
3122 return err;
3123 }
3124 #endif
3125 #endif
3126
3127 /******************************************************************************/
3128 #if defined(WITH_OPENSSL) || defined(WITH_GNUTLS)
3129 #ifndef PALM_2
3130 SOAP_FMAC1
3131 int
3132 SOAP_FMAC2
3133 #if defined(VXWORKS) && defined(WM_SECURE_KEY_STORAGE)
3134 soap_ssl_client_context(struct soap *soap, unsigned short flags, const char *keyfile, const char *keyid, const char *password, const char *cafile, const char *capath, const char *randfile)
3135 #else
3136 soap_ssl_client_context(struct soap *soap, unsigned short flags, const char *keyfile, const char *password, const char *cafile, const char *capath, const char *randfile)
3137 #endif
3138 { soap->keyfile = keyfile;
3139 #if defined(VXWORKS) && defined(WM_SECURE_KEY_STORAGE)
3140 soap->keyid = keyid;
3141 #endif
3142 soap->password = password;
3143 soap->cafile = cafile;
3144 soap->capath = capath;
3145 soap->ssl_flags = SOAP_SSL_CLIENT | flags;
3146 #ifdef WITH_OPENSSL
3147 soap->dhfile = NULL;
3148 soap->randfile = randfile;
3149 soap->fsslverify = (flags & SOAP_SSL_ALLOW_EXPIRED_CERTIFICATE) == 0 ? ssl_verify_callback : ssl_verify_callback_allow_expired_certificate;
3150 #endif
3151 #ifdef WITH_GNUTLS
3152 if (soap->session)
3153 { gnutls_deinit(soap->session);
3154 soap->session = NULL;
3155 }
3156 if (soap->xcred)
3157 { gnutls_certificate_free_credentials(soap->xcred);
3158 soap->xcred = NULL;
3159 }
3160 #endif
3161 return soap->fsslauth(soap);
3162 }
3163 #endif
3164 #endif
3165
3166 /******************************************************************************/
3167 #if defined(WITH_OPENSSL) || defined(WITH_GNUTLS)
3168 #ifndef PALM_2
3169 SOAP_FMAC1
3170 void
3171 SOAP_FMAC2
3172 soap_ssl_init()
3173 { /* Note: for MT systems, the main program MUST call soap_ssl_init() before any threads are started */
3174 if (!soap_ssl_init_done)
3175 { soap_ssl_init_done = 1;
3176 #ifdef WITH_OPENSSL
3177 SSL_library_init();
3178 OpenSSL_add_all_algorithms(); /* 2.8.1 change (wsseapi.c) */
3179 OpenSSL_add_all_digests();
3180 #ifndef WITH_LEAN
3181 SSL_load_error_strings();
3182 #endif
3183 if (!RAND_load_file("/dev/urandom", 1024))
3184 { char buf[1024];
3185 RAND_seed(buf, sizeof(buf));
3186 while (!RAND_status())
3187 { int r = rand();
3188 RAND_seed(&r, sizeof(int));
3189 }
3190 }
3191 #endif
3192 #ifdef WITH_GNUTLS
3193 # if defined(HAVE_PTHREAD_H)
3194 gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);
3195 # elif defined(HAVE_PTH_H)
3196 gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
3197 # endif
3198 gcry_control(GCRYCTL_ENABLE_QUICK_RANDOM, 0);
3199 gcry_control(GCRYCTL_DISABLE_SECMEM, 0);
3200 gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0); /* libgcrypt init done */
3201 gnutls_global_init();
3202 #endif
3203 }
3204 }
3205 #endif
3206 #endif
3207
3208 /******************************************************************************/
3209 #if defined(WITH_OPENSSL) || defined(WITH_GNUTLS)
3210 #ifndef PALM_1
3211 SOAP_FMAC1
3212 const char *
3213 SOAP_FMAC2
3214 soap_ssl_error(struct soap *soap, int ret)
3215 {
3216 #ifdef WITH_OPENSSL
3217 int err = SSL_get_error(soap->ssl, ret);
3218 const char *msg = soap_code_str(h_ssl_error_codes, err);
3219 if (msg)
3220 strcpy(soap->msgbuf, msg);
3221 else
3222 return ERR_error_string(err, soap->msgbuf);
3223 if (ERR_peek_error())
3224 { unsigned long r;
3225 strcat(soap->msgbuf, "\n");
3226 while ((r = ERR_get_error()))
3227 ERR_error_string_n(r, soap->msgbuf + strlen(soap->msgbuf), sizeof(soap->msgbuf) - strlen(soap->msgbuf));
3228 }
3229 else
3230 { switch (ret)
3231 { case 0:
3232 strcpy(soap->msgbuf, "EOF was observed that violates the SSL/TLS protocol. The client probably provided invalid authentication information.");
3233 break;
3234 case -1:
3235 #ifdef HAVE_SNPRINTF
3236 soap_snprintf(soap->msgbuf, sizeof(soap->msgbuf), "Error observed by underlying SSL/TLS BIO: %s", strerror(errno));
3237 #else
3238 { const char *s = strerror(errno);
3239 size_t l = strlen(s);
3240 sprintf(soap->msgbuf, "Error observed by underlying SSL/TLS BIO: %s", l + 44 < sizeof(soap->msgbuf) ? s : SOAP_STR_EOS);
3241 }
3242 #endif
3243 break;
3244 }
3245 }
3246 return soap->msgbuf;
3247 #endif
3248 #ifdef WITH_GNUTLS
3249 return gnutls_strerror(ret);
3250 #endif
3251 }
3252 #endif
3253 #endif
3254
3255 /******************************************************************************/
3256 #if defined(WITH_OPENSSL) || defined(WITH_GNUTLS)
3257 #ifndef PALM_1
3258 static int
3259 ssl_auth_init(struct soap *soap)
3260 {
3261 #ifdef WITH_OPENSSL
3262 long flags;
3263 int mode;
3264 #if defined(VXWORKS) && defined(WM_SECURE_KEY_STORAGE)
3265 EVP_PKEY* pkey;
3266 #endif
3267 if (!soap_ssl_init_done)
3268 soap_ssl_init();
3269 ERR_clear_error();
3270 if (!soap->ctx)
3271 { if (!(soap->ctx = SSL_CTX_new(SSLv23_method())))
3272 return soap_set_receiver_error(soap, "SSL/TLS error", "Can't setup context", SOAP_SSL_ERROR);
3273 /* The following alters the behavior of SSL read/write: */
3274 #if 0
3275 SSL_CTX_set_mode(soap->ctx, SSL_MODE_ENABLE_PARTIAL_WRITE | SSL_MODE_AUTO_RETRY);
3276 #endif
3277 }
3278 if (soap->randfile)
3279 { if (!RAND_load_file(soap->randfile, -1))
3280 return soap_set_receiver_error(soap, "SSL/TLS error", "Can't load randomness", SOAP_SSL_ERROR);
3281 }
3282 if (soap->cafile || soap->capath)
3283 { if (!SSL_CTX_load_verify_locations(soap->ctx, soap->cafile, soap->capath))
3284 return soap_set_receiver_error(soap, "SSL/TLS error", "Can't read CA file", SOAP_SSL_ERROR);
3285 if (soap->cafile && (soap->ssl_flags & SOAP_SSL_REQUIRE_CLIENT_AUTHENTICATION))
3286 SSL_CTX_set_client_CA_list(soap->ctx, SSL_load_client_CA_file(soap->cafile));
3287 }
3288 if (!(soap->ssl_flags & SOAP_SSL_NO_DEFAULT_CA_PATH))
3289 { if (!SSL_CTX_set_default_verify_paths(soap->ctx))
3290 return soap_set_receiver_error(soap, "SSL/TLS error", "Can't read default CA file and/or directory", SOAP_SSL_ERROR);
3291 }
3292 /* This code assumes a typical scenario, see alternative code below */
3293 if (soap->keyfile)
3294 { if (!SSL_CTX_use_certificate_chain_file(soap->ctx, soap->keyfile))
3295 return soap_set_receiver_error(soap, "SSL/TLS error", "Can't read certificate key file", SOAP_SSL_ERROR);
3296 if (soap->password)
3297 { SSL_CTX_set_default_passwd_cb_userdata(soap->ctx, (void*)soap->password);
3298 SSL_CTX_set_default_passwd_cb(soap->ctx, ssl_password);
3299 }
3300 if (!SSL_CTX_use_PrivateKey_file(soap->ctx, soap->keyfile, SSL_FILETYPE_PEM))
3301 return soap_set_receiver_error(soap, "SSL/TLS error", "Can't read key file", SOAP_SSL_ERROR);
3302 #ifndef WM_SECURE_KEY_STORAGE
3303 if (!SSL_CTX_use_PrivateKey_file(soap->ctx, soap->keyfile, SSL_FILETYPE_PEM))
3304 return soap_set_receiver_error(soap, "SSL/TLS error", "Can't read key file", SOAP_SSL_ERROR);
3305 #endif
3306 }
3307 #if defined(VXWORKS) && defined(WM_SECURE_KEY_STORAGE)
3308 if (NULL == (pkey = ipcom_key_db_pkey_get(soap->keyid)))
3309 return soap_set_receiver_error(soap, "SSL error", "Can't find key", SOAP_SSL_ERROR);
3310 if (0 == SSL_CTX_use_PrivateKey(soap->ctx, pkey))
3311 return soap_set_receiver_error(soap, "SSL error", "Can't read key", SOAP_SSL_ERROR);
3312 #endif
3313 /* Suggested alternative approach to check the key file for certs (cafile=NULL):*/
3314 #if 0
3315 if (soap->password)
3316 { SSL_CTX_set_default_passwd_cb_userdata(soap->ctx, (void*)soap->password);
3317 SSL_CTX_set_default_passwd_cb(soap->ctx, ssl_password);
3318 }
3319 if (!soap->cafile || !SSL_CTX_use_certificate_chain_file(soap->ctx, soap->cafile))
3320 { if (soap->keyfile)
3321 { if (!SSL_CTX_use_certificate_chain_file(soap->ctx, soap->keyfile))
3322 return soap_set_receiver_error(soap, "SSL/TLS error", "Can't read certificate or key file", SOAP_SSL_ERROR);
3323 if (!SSL_CTX_use_PrivateKey_file(soap->ctx, soap->keyfile, SSL_FILETYPE_PEM))
3324 return soap_set_receiver_error(soap, "SSL/TLS error", "Can't read key file", SOAP_SSL_ERROR);
3325 }
3326 }
3327 #endif
3328 if ((soap->ssl_flags & SOAP_SSL_RSA))
3329 { RSA *rsa = RSA_generate_key(SOAP_SSL_RSA_BITS, RSA_F4, NULL, NULL);
3330 if (!SSL_CTX_set_tmp_rsa(soap->ctx, rsa))
3331 { if (rsa)
3332 RSA_free(rsa);
3333 return soap_set_receiver_error(soap, "SSL/TLS error", "Can't set RSA key", SOAP_SSL_ERROR);
3334 }
3335 RSA_free(rsa);
3336 }
3337 else if (soap->dhfile)
3338 { DH *dh = 0;
3339 char *s;
3340 int n = (int)soap_strtoul(soap->dhfile, &s, 10);
3341 /* if dhfile is numeric, treat it as a key length to generate DH params which can take a while */
3342 if (n >= 512 && s && *s == '\0')
3343 #if defined(VXWORKS)
3344 DH_generate_parameters_ex(dh, n, 2/*or 5*/, NULL);
3345 #else
3346 dh = DH_generate_parameters(n, 2/*or 5*/, NULL, NULL);
3347 #endif
3348 else
3349 { BIO *bio;
3350 bio = BIO_new_file(soap->dhfile, "r");
3351 if (!bio)
3352 return soap_set_receiver_error(soap, "SSL/TLS error", "Can't read DH file", SOAP_SSL_ERROR);
3353 dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
3354 BIO_free(bio);
3355 }
3356 if (!dh || DH_check(dh, &n) != 1 || SSL_CTX_set_tmp_dh(soap->ctx, dh) < 0)
3357 { if (dh)
3358 DH_free(dh);
3359 return soap_set_receiver_error(soap, "SSL/TLS error", "Can't set DH parameters", SOAP_SSL_ERROR);
3360 }
3361 DH_free(dh);
3362 }
3363 flags = (SSL_OP_ALL | SSL_OP_NO_SSLv2); /* disable SSL v2 */
3364 if ((soap->ssl_flags & SOAP_SSLv3))
3365 flags |= SSL_OP_NO_TLSv1;
3366 if ((soap->ssl_flags & SOAP_TLSv1))
3367 flags |= SSL_OP_NO_SSLv3;
3368 #ifdef SSL_OP_NO_TICKET
3369 /* TLS extension is enabled by default in OPENSSL v0.9.8k
3370 Disable it by adding SSL_OP_NO_TICKET */
3371 flags |= SSL_OP_NO_TICKET;
3372 #endif
3373 SSL_CTX_set_options(soap->ctx, flags);
3374 if ((soap->ssl_flags & SOAP_SSL_REQUIRE_CLIENT_AUTHENTICATION))
3375 mode = (SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT);
3376 else if ((soap->ssl_flags & SOAP_SSL_REQUIRE_SERVER_AUTHENTICATION))
3377 mode = SSL_VERIFY_PEER;
3378 else
3379 mode = SSL_VERIFY_NONE;
3380 SSL_CTX_set_verify(soap->ctx, mode, soap->fsslverify);
3381 #if (OPENSSL_VERSION_NUMBER < 0x00905100L)
3382 SSL_CTX_set_verify_depth(soap->ctx, 1);
3383 #else
3384 SSL_CTX_set_verify_depth(soap->ctx, 9);
3385 #endif
3386 #endif
3387 #ifdef WITH_GNUTLS
3388 int ret;
3389 if (!soap_ssl_init_done)
3390 soap_ssl_init();
3391 if (!soap->xcred)
3392 { gnutls_certificate_allocate_credentials(&soap->xcred);
3393 if (soap->cafile)
3394 { if (gnutls_certificate_set_x509_trust_file(soap->xcred, soap->cafile, GNUTLS_X509_FMT_PEM) < 0)
3395 return soap_set_receiver_error(soap, "SSL/TLS error", "Can't read CA file", SOAP_SSL_ERROR);
3396 }
3397 if (soap->crlfile)
3398 { if (gnutls_certificate_set_x509_crl_file(soap->xcred, soap->crlfile, GNUTLS_X509_FMT_PEM) < 0)
3399 return soap_set_receiver_error(soap, "SSL/TLS error", "Can't read CRL file", SOAP_SSL_ERROR);
3400 }
3401 if (soap->keyfile)
3402 { if (gnutls_certificate_set_x509_key_file(soap->xcred, soap->keyfile, soap->keyfile, GNUTLS_X509_FMT_PEM) < 0) /* TODO: GNUTLS need to concat cert and key in single key file */
3403 return soap_set_receiver_error(soap, "SSL/TLS error", "Can't read key file", SOAP_SSL_ERROR);
3404 }
3405 }
3406 if ((soap->ssl_flags & SOAP_SSL_CLIENT))
3407 { gnutls_init(&soap->session, GNUTLS_CLIENT);
3408 if (soap->cafile || soap->crlfile || soap->keyfile)
3409 { ret = gnutls_priority_set_direct(soap->session, "PERFORMANCE", NULL);
3410 if (ret < 0)
3411 return soap_set_receiver_error(soap, soap_ssl_error(soap, ret), "SSL/TLS set priority error", SOAP_SSL_ERROR);
3412 gnutls_credentials_set(soap->session, GNUTLS_CRD_CERTIFICATE, soap->xcred);
3413 }
3414 else
3415 { if (!soap->acred)
3416 gnutls_anon_allocate_client_credentials(&soap->acred);
3417 gnutls_init(&soap->session, GNUTLS_CLIENT);
3418 gnutls_priority_set_direct(soap->session, "PERFORMANCE:+ANON-DH:!ARCFOUR-128", NULL);
3419 gnutls_credentials_set(soap->session, GNUTLS_CRD_ANON, soap->acred);
3420 }
3421 }
3422 else
3423 { if (!soap->keyfile)
3424 return soap_set_receiver_error(soap, "SSL/TLS error", "No key file: anonymous server authentication not supported in this release", SOAP_SSL_ERROR);
3425 if ((soap->ssl_flags & SOAP_SSL_RSA) && soap->rsa_params)
3426 gnutls_certificate_set_rsa_export_params(soap->xcred, soap->rsa_params);
3427 else if (soap->dh_params)
3428 gnutls_certificate_set_dh_params(soap->xcred, soap->dh_params);
3429 if (!soap->cache)
3430 gnutls_priority_init(&soap->cache, "NORMAL", NULL);
3431 gnutls_init(&soap->session, GNUTLS_SERVER);
3432 gnutls_priority_set(soap->session, soap->cache);
3433 gnutls_credentials_set(soap->session, GNUTLS_CRD_CERTIFICATE, soap->xcred);
3434 if ((soap->ssl_flags & SOAP_SSL_REQUIRE_CLIENT_AUTHENTICATION))
3435 gnutls_certificate_server_set_request(soap->session, GNUTLS_CERT_REQUEST);
3436 gnutls_session_enable_compatibility_mode(soap->session);
3437 if ((soap->ssl_flags & SOAP_TLSv1))
3438 { int protocol_priority[] = { GNUTLS_TLS1_0, 0 };
3439 if (gnutls_protocol_set_priority(soap->session, protocol_priority) != GNUTLS_E_SUCCESS)
3440 return soap_set_receiver_error(soap, "SSL/TLS error", "Can't set TLS v1.0 protocol", SOAP_SSL_ERROR);
3441 }
3442 }
3443 #endif
3444 return SOAP_OK;
3445 }
3446 #endif
3447 #endif
3448
3449 /******************************************************************************/
3450 #ifdef WITH_OPENSSL
3451 #ifndef PALM_1
3452 static int
3453 ssl_password(char *buf, int num, int rwflag, void *userdata)
3454 { if (num < (int)strlen((char*)userdata) + 1)
3455 return 0;
3456 return (int)strlen(strcpy(buf, (char*)userdata));
3457 }
3458 #endif
3459 #endif
3460
3461 /******************************************************************************/
3462 #ifdef WITH_OPENSSL
3463 #ifndef PALM_1
3464 static int
3465 ssl_verify_callback(int ok, X509_STORE_CTX *store)
3466 {
3467 #ifdef SOAP_DEBUG
3468 if (!ok)
3469 { char buf[1024];
3470 int err = X509_STORE_CTX_get_error(store);
3471 X509 *cert = X509_STORE_CTX_get_current_cert(store);
3472 fprintf(stderr, "SSL verify error or warning with certificate at depth %d: %s\n", X509_STORE_CTX_get_error_depth(store), X509_verify_cert_error_string(err));
3473 X509_NAME_oneline(X509_get_issuer_name(cert), buf, sizeof(buf));
3474 fprintf(stderr, "certificate issuer %s\n", buf);
3475 X509_NAME_oneline(X509_get_subject_name(cert), buf, sizeof(buf));
3476 fprintf(stderr, "certificate subject %s\n", buf);
3477 /* accept self signed certificates and certificates out of date */
3478 switch (err)
3479 { case X509_V_ERR_CERT_NOT_YET_VALID:
3480 case X509_V_ERR_CERT_HAS_EXPIRED:
3481 case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
3482 case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
3483 X509_STORE_CTX_set_error(store, X509_V_OK);
3484 ok = 1;
3485 }
3486 }
3487 #endif
3488 /* Note: return 1 to continue, but unsafe progress will be terminated by OpenSSL */
3489 return ok;
3490 }
3491 #endif
3492 #endif
3493
3494 /******************************************************************************/
3495 #ifdef WITH_OPENSSL
3496 #ifndef PALM_1
3497 static int
3498 ssl_verify_callback_allow_expired_certificate(int ok, X509_STORE_CTX *store)
3499 { ok = ssl_verify_callback(ok, store);
3500 if (!ok)
3501 { /* accept self signed certificates and certificates out of date */
3502 switch (X509_STORE_CTX_get_error(store))
3503 { case X509_V_ERR_CERT_NOT_YET_VALID:
3504 case X509_V_ERR_CERT_HAS_EXPIRED:
3505 case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
3506 case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
3507 X509_STORE_CTX_set_error(store, X509_V_OK);
3508 ok = 1;
3509 }
3510 }
3511 /* Note: return 1 to continue, but unsafe progress will be terminated by SSL */
3512 return ok;
3513 }
3514 #endif
3515 #endif
3516
3517 /******************************************************************************/
3518 #ifdef WITH_GNUTLS
3519 static const char *
3520 ssl_verify(struct soap *soap, const char *host)
3521 { unsigned int status;
3522 const char *err = NULL;
3523 int r = gnutls_certificate_verify_peers2(soap->session, &status);
3524 if (r < 0)
3525 err = "Certificate verify error";
3526 else if ((status & GNUTLS_CERT_INVALID))
3527 err = "The certificate is not trusted";
3528 else if ((status & GNUTLS_CERT_SIGNER_NOT_FOUND))
3529 err = "The certificate hasn't got a known issuer";
3530 else if ((status & GNUTLS_CERT_REVOKED))
3531 err = "The certificate has been revoked";
3532 else if (gnutls_certificate_type_get(soap->session) == GNUTLS_CRT_X509)
3533 { gnutls_x509_crt_t cert;
3534 const gnutls_datum_t *cert_list;
3535 unsigned int cert_list_size;
3536 if (gnutls_x509_crt_init(&cert) < 0)
3537 err = "Could not get X509 certificates";
3538 else if ((cert_list = gnutls_certificate_get_peers(soap->session, &cert_list_size)) == NULL)
3539 err = "Could not get X509 certificates";
3540 else if (gnutls_x509_crt_import(cert, &cert_list[0], GNUTLS_X509_FMT_DER) < 0)
3541 err = "Error parsing X509 certificate";
3542 else if (!(soap->ssl_flags & SOAP_SSL_ALLOW_EXPIRED_CERTIFICATE) && gnutls_x509_crt_get_expiration_time(cert) < time(NULL))
3543 err = "The certificate has expired";
3544 else if (!(soap->ssl_flags & SOAP_SSL_ALLOW_EXPIRED_CERTIFICATE) && gnutls_x509_crt_get_activation_time(cert) > time(NULL))
3545 err = "The certificate is not yet activated";
3546 else if (host && !(soap->ssl_flags & SOAP_SSL_SKIP_HOST_CHECK))
3547 { if (!gnutls_x509_crt_check_hostname(cert, host))
3548 err = "Certificate host name mismatch";
3549 }
3550 gnutls_x509_crt_deinit(cert);
3551 }
3552 return err;
3553 }
3554 #endif
3555
3556 /******************************************************************************/
3557 #if defined(WITH_OPENSSL) || defined(WITH_GNUTLS)
3558 #ifndef WITH_NOIO
3559 #ifndef PALM_1
3560 SOAP_FMAC1
3561 int
3562 SOAP_FMAC2
3563 soap_ssl_accept(struct soap *soap)
3564 { SOAP_SOCKET sk = soap->socket;
3565 #ifdef WITH_OPENSSL
3566 BIO *bio;
3567 int retries, r, s;
3568 if (!soap_valid_socket(sk))
3569 return soap_set_receiver_error(soap, "SSL/TLS error", "No socket in soap_ssl_accept()", SOAP_SSL_ERROR);
3570 soap->ssl_flags &= ~SOAP_SSL_CLIENT;
3571 if (!soap->ctx && (soap->error = soap->fsslauth(soap)))
3572 return soap->error;
3573 if (!soap->ssl)
3574 { soap->ssl = SSL_new(soap->ctx);
3575 if (!soap->ssl)
3576 return soap_set_receiver_error(soap, "SSL/TLS error", "SSL_new() failed in soap_ssl_accept()", SOAP_SSL_ERROR);
3577 }
3578 else
3579 SSL_clear(soap->ssl);
3580 bio = BIO_new_socket((int)sk, BIO_NOCLOSE);
3581 SSL_set_bio(soap->ssl, bio, bio);
3582 /* Set SSL sockets to non-blocking */
3583 retries = 0;
3584 if (soap->accept_timeout)
3585 { SOAP_SOCKNONBLOCK(sk)
3586 retries = 10*soap->accept_timeout;
3587 }
3588 if (retries <= 0)
3589 retries = 100; /* timeout: 10 sec retries, 100 times 0.1 sec */
3590 while ((r = SSL_accept(soap->ssl)) <= 0)
3591 { int err;
3592 if (retries-- <= 0)
3593 break;
3594 err = SSL_get_error(soap->ssl, r);
3595 if (err == SSL_ERROR_WANT_ACCEPT || err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE)
3596 { if (err == SSL_ERROR_WANT_READ)
3597 s = tcp_select(soap, sk, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_ERR, -100000);
3598 else
3599 s = tcp_select(soap, sk, SOAP_TCP_SELECT_SND | SOAP_TCP_SELECT_ERR, -100000);
3600 if (s < 0)
3601 break;
3602 }
3603 else
3604 { soap->errnum = soap_socket_errno(sk);
3605 break;
3606 }
3607 }
3608 if (r <= 0)
3609 { soap_set_receiver_error(soap, soap_ssl_error(soap, r), "SSL_accept() failed in soap_ssl_accept()", SOAP_SSL_ERROR);
3610 soap_closesock(soap);
3611 return SOAP_SSL_ERROR;
3612 }
3613 if ((soap->ssl_flags & SOAP_SSL_REQUIRE_CLIENT_AUTHENTICATION))
3614 { X509 *peer;
3615 int err;
3616 if ((err = SSL_get_verify_result(soap->ssl)) != X509_V_OK)
3617 { soap_closesock(soap);
3618 return soap_set_sender_error(soap, X509_verify_cert_error_string(err), "SSL certificate presented by peer cannot be verified in soap_ssl_accept()", SOAP_SSL_ERROR);
3619 }
3620 peer = SSL_get_peer_certificate(soap->ssl);
3621 if (!peer)
3622 { soap_closesock(soap);
3623 return soap_set_sender_error(soap, "SSL/TLS error", "No SSL certificate was presented by the peer in soap_ssl_accept()", SOAP_SSL_ERROR);
3624 }
3625 X509_free(peer);
3626 }
3627 #endif
3628 #ifdef WITH_GNUTLS
3629 int retries = 0, r;
3630 if (!soap_valid_socket(sk))
3631 return soap_set_receiver_error(soap, "SSL/TLS error", "No socket in soap_ssl_accept()", SOAP_SSL_ERROR);
3632 soap->ssl_flags &= ~SOAP_SSL_CLIENT;
3633 if (!soap->session && (soap->error = soap->fsslauth(soap)))
3634 { soap_closesock(soap);
3635 return soap->error;
3636 }
3637 gnutls_transport_set_ptr(soap->session, (gnutls_transport_ptr_t)(long)sk);
3638 /* Set SSL sockets to non-blocking */
3639 if (soap->accept_timeout)
3640 { SOAP_SOCKNONBLOCK(sk)
3641 retries = 10*soap->accept_timeout;
3642 }
3643 if (retries <= 0)
3644 retries = 100; /* timeout: 10 sec retries, 100 times 0.1 sec */
3645 while ((r = gnutls_handshake(soap->session)))
3646 { int s;
3647 /* GNUTLS repeat handhake when GNUTLS_E_AGAIN */
3648 if (retries-- <= 0)
3649 break;
3650 if (r == GNUTLS_E_AGAIN || r == GNUTLS_E_INTERRUPTED)
3651 { if (!gnutls_record_get_direction(soap->session))
3652 s = tcp_select(soap, sk, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_ERR, -100000);
3653 else
3654 s = tcp_select(soap, sk, SOAP_TCP_SELECT_SND | SOAP_TCP_SELECT_ERR, -100000);
3655 if (s < 0)
3656 break;
3657 }
3658 else
3659 { soap->errnum = soap_socket_errno(sk);
3660 break;
3661 }
3662 }
3663 if (r)
3664 { soap_closesock(soap);
3665 return soap_set_receiver_error(soap, soap_ssl_error(soap, r), "SSL/TLS handshake failed", SOAP_SSL_ERROR);
3666 }
3667 if ((soap->ssl_flags & SOAP_SSL_REQUIRE_CLIENT_AUTHENTICATION))
3668 { const char *err = ssl_verify(soap, NULL);
3669 if (err)
3670 { soap_closesock(soap);
3671 return soap_set_receiver_error(soap, "SSL/TLS error", err, SOAP_SSL_ERROR);
3672 }
3673 }
3674 #endif
3675 if (soap->recv_timeout || soap->send_timeout)
3676 SOAP_SOCKNONBLOCK(sk)
3677 else
3678 SOAP_SOCKBLOCK(sk)
3679 soap->imode |= SOAP_ENC_SSL;
3680 soap->omode |= SOAP_ENC_SSL;
3681 return SOAP_OK;
3682 }
3683 #endif
3684 #endif
3685 #endif
3686
3687 /******************************************************************************\
3688 *
3689 * TCP/UDP [SSL/TLS] IPv4 and IPv6
3690 *
3691 \******************************************************************************/
3692
3693 /******************************************************************************/
3694 #ifndef WITH_NOIO
3695 #ifndef PALM_1
3696 static int
3697 tcp_init(struct soap *soap)
3698 { soap->errmode = 1;
3699 #ifdef WIN32
3700 if (tcp_done)
3701 return 0;
3702 else
3703 { WSADATA w;
3704 if (WSAStartup(MAKEWORD(1, 1), &w))
3705 return -1;
3706 tcp_done = 1;
3707 }
3708 #endif
3709 return 0;
3710 }
3711 #endif
3712 #endif
3713
3714 /******************************************************************************/
3715 #ifndef WITH_NOIO
3716 #ifndef PALM_1
3717 static const char*
3718 tcp_error(struct soap *soap)
3719 { register const char *msg = NULL;
3720 switch (soap->errmode)
3721 { case 0:
3722 msg = soap_strerror(soap);
3723 break;
3724 case 1:
3725 msg = "WSAStartup failed";
3726 break;
3727 case 2:
3728 {
3729 #ifndef WITH_LEAN
3730 msg = soap_code_str(h_error_codes, soap->errnum);
3731 if (!msg)
3732 #endif
3733 {
3734 #ifdef HAVE_SNPRINTF
3735 soap_snprintf(soap->msgbuf, sizeof(soap->msgbuf), "TCP/UDP IP error %d", soap->errnum);
3736 #else
3737 sprintf(soap->msgbuf, "TCP/UDP IP error %d", soap->errnum);
3738 #endif
3739 msg = soap->msgbuf;
3740 }
3741 }
3742 }
3743 return msg;
3744 }
3745 #endif
3746 #endif
3747
3748 /******************************************************************************/
3749 #ifndef WITH_IPV6
3750 #ifndef WITH_NOIO
3751 #ifndef PALM_1
3752 static int
3753 tcp_gethost(struct soap *soap, const char *addr, struct in_addr *inaddr)
3754 { soap_int32 iadd = -1;
3755 struct hostent hostent, *host = &hostent;
3756 #ifdef VXWORKS
3757 int hostint;
3758 /* inet_addr(), and hostGetByName() expect "char *"; addr is a "const char *". */
3759 iadd = inet_addr((char*)addr);
3760 #else
3761 #if defined(_AIX43) || ((defined(TRU64) || defined(HP_UX)) && defined(HAVE_GETHOSTBYNAME_R))
3762 struct hostent_data ht_data;
3763 #endif
3764 #ifdef AS400
3765 iadd = inet_addr((void*)addr);
3766 #else
3767 iadd = inet_addr(addr);
3768 #endif
3769 #endif
3770 if (iadd != -1)
3771 { memcpy(inaddr, &iadd, sizeof(iadd));
3772 return SOAP_OK;
3773 }
3774 #if defined(__GLIBC__) || (defined(HAVE_GETHOSTBYNAME_R) && (defined(FREEBSD) || defined(__FreeBSD__))) || defined(__ANDROID__)
3775 if (gethostbyname_r(addr, &hostent, soap->buf, SOAP_BUFLEN, &host, &soap->errnum) < 0)
3776 host = NULL;
3777 #elif defined(_AIX43) || ((defined(TRU64) || defined(HP_UX)) && defined(HAVE_GETHOSTBYNAME_R))
3778 memset((void*)&ht_data, 0, sizeof(ht_data));
3779 if (gethostbyname_r(addr, &hostent, &ht_data) < 0)
3780 { host = NULL;
3781 soap->errnum = h_errno;
3782 }
3783 #elif defined(HAVE_GETHOSTBYNAME_R)
3784 host = gethostbyname_r(addr, &hostent, soap->buf, SOAP_BUFLEN, &soap->errnum);
3785 #elif defined(VXWORKS)
3786 /* If the DNS resolver library resolvLib has been configured in the vxWorks
3787 * image, a query for the host IP address is sent to the DNS server, if the
3788 * name was not found in the local host table. */
3789 hostint = hostGetByName((char*)addr);
3790 if (hostint == ERROR)
3791 { host = NULL;
3792 soap->errnum = soap_errno;
3793 }
3794 #else
3795 #ifdef AS400
3796 if (!(host = gethostbyname((void*)addr)))
3797 soap->errnum = h_errno;
3798 #else
3799 if (!(host = gethostbyname(addr)))
3800 soap->errnum = h_errno;
3801 #endif
3802 #endif
3803 if (!host)
3804 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Host name not found\n"));
3805 return SOAP_ERR;
3806 }
3807 #ifdef VXWORKS
3808 inaddr->s_addr = hostint;
3809 #else
3810 memcpy(inaddr, host->h_addr, host->h_length);
3811 #endif
3812 return SOAP_OK;
3813 }
3814 #endif
3815 #endif
3816 #endif
3817
3818 /******************************************************************************/
3819 #ifndef WITH_NOIO
3820 #ifndef PALM_1
3821 static SOAP_SOCKET
3822 tcp_connect(struct soap *soap, const char *endpoint, const char *host, int port)
3823 {
3824 #ifdef WITH_IPV6
3825 struct addrinfo hints, *res, *ressave;
3826 #endif
3827 SOAP_SOCKET sk;
3828 int err = 0;
3829 #ifndef WITH_LEAN
3830 #ifndef WIN32
3831 int len = SOAP_BUFLEN;
3832 #else
3833 int len = SOAP_BUFLEN + 1; /* speeds up windows xfer */
3834 #endif
3835 int set = 1;
3836 #endif
3837 #if !defined(WITH_LEAN) || defined(WITH_OPENSSL) || defined(WITH_GNUTLS)
3838 int retries;
3839 #endif
3840 if (soap_valid_socket(soap->socket))
3841 soap->fclosesocket(soap, soap->socket);
3842 soap->socket = SOAP_INVALID_SOCKET;
3843 if (tcp_init(soap))
3844 { soap->errnum = 0;
3845 soap_set_sender_error(soap, tcp_error(soap), "TCP init failed in tcp_connect()", SOAP_TCP_ERROR);
3846 return SOAP_INVALID_SOCKET;
3847 }
3848 soap->errmode = 0;
3849 #ifdef WITH_IPV6
3850 memset((void*)&hints, 0, sizeof(hints));
3851 hints.ai_family = PF_UNSPEC;
3852 #ifndef WITH_LEAN
3853 if ((soap->omode & SOAP_IO_UDP))
3854 hints.ai_socktype = SOCK_DGRAM;
3855 else
3856 #endif
3857 hints.ai_socktype = SOCK_STREAM;
3858 soap->errmode = 2;
3859 if (soap->proxy_host)
3860 err = getaddrinfo(soap->proxy_host, soap_int2s(soap, soap->proxy_port), &hints, &res);
3861 else
3862 err = getaddrinfo(host, soap_int2s(soap, port), &hints, &res);
3863 if (err)
3864 { soap_set_sender_error(soap, SOAP_GAI_STRERROR(err), "getaddrinfo failed in tcp_connect()", SOAP_TCP_ERROR);
3865 return SOAP_INVALID_SOCKET;
3866 }
3867 ressave = res;
3868 again:
3869 sk = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
3870 soap->errmode = 0;
3871 #else
3872 #ifndef WITH_LEAN
3873 again:
3874 #endif
3875 #ifndef WITH_LEAN
3876 if ((soap->omode & SOAP_IO_UDP))
3877 sk = socket(AF_INET, SOCK_DGRAM, 0);
3878 else
3879 #endif
3880 sk = socket(AF_INET, SOCK_STREAM, 0);
3881 #endif
3882 if (!soap_valid_socket(sk))
3883 {
3884 #ifdef WITH_IPV6
3885 if (res->ai_next)
3886 { res = res->ai_next;
3887 goto again;
3888 }
3889 #endif
3890 soap->errnum = soap_socket_errno(sk);
3891 soap_set_sender_error(soap, tcp_error(soap), "socket failed in tcp_connect()", SOAP_TCP_ERROR);
3892 #ifdef WITH_IPV6
3893 freeaddrinfo(ressave);
3894 #endif
3895 return SOAP_INVALID_SOCKET;
3896 }
3897 #ifdef SOCKET_CLOSE_ON_EXEC
3898 #ifdef WIN32
3899 #ifndef UNDER_CE
3900 SetHandleInformation((HANDLE)sk, HANDLE_FLAG_INHERIT, 0);
3901 #endif
3902 #else
3903 fcntl(sk, F_SETFD, 1);
3904 #endif
3905 #endif
3906 #ifndef WITH_LEAN
3907 if (soap->connect_flags == SO_LINGER)
3908 { struct linger linger;
3909 memset((void*)&linger, 0, sizeof(linger));
3910 linger.l_onoff = 1;
3911 linger.l_linger = soap->linger_time;
3912 if (setsockopt(sk, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(struct linger)))
3913 { soap->errnum = soap_socket_errno(sk);
3914 soap_set_sender_error(soap, tcp_error(soap), "setsockopt SO_LINGER failed in tcp_connect()", SOAP_TCP_ERROR);
3915 soap->fclosesocket(soap, sk);
3916 #ifdef WITH_IPV6
3917 freeaddrinfo(ressave);
3918 #endif
3919 return SOAP_INVALID_SOCKET;
3920 }
3921 }
3922 else if (soap->connect_flags && setsockopt(sk, SOL_SOCKET, soap->connect_flags, (char*)&set, sizeof(int)))
3923 { soap->errnum = soap_socket_errno(sk);
3924 soap_set_sender_error(soap, tcp_error(soap), "setsockopt failed in tcp_connect()", SOAP_TCP_ERROR);
3925 soap->fclosesocket(soap, sk);
3926 #ifdef WITH_IPV6
3927 freeaddrinfo(ressave);
3928 #endif
3929 return SOAP_INVALID_SOCKET;
3930 }
3931 if ((soap->keep_alive || soap->tcp_keep_alive) && setsockopt(sk, SOL_SOCKET, SO_KEEPALIVE, (char*)&set, sizeof(int)))
3932 { soap->errnum = soap_socket_errno(sk);
3933 soap_set_sender_error(soap, tcp_error(soap), "setsockopt SO_KEEPALIVE failed in tcp_connect()", SOAP_TCP_ERROR);
3934 soap->fclosesocket(soap, sk);
3935 #ifdef WITH_IPV6
3936 freeaddrinfo(ressave);
3937 #endif
3938 return SOAP_INVALID_SOCKET;
3939 }
3940 if (setsockopt(sk, SOL_SOCKET, SO_SNDBUF, (char*)&len, sizeof(int)))
3941 { soap->errnum = soap_socket_errno(sk);
3942 soap_set_sender_error(soap, tcp_error(soap), "setsockopt SO_SNDBUF failed in tcp_connect()", SOAP_TCP_ERROR);
3943 soap->fclosesocket(soap, sk);
3944 #ifdef WITH_IPV6
3945 freeaddrinfo(ressave);
3946 #endif
3947 return SOAP_INVALID_SOCKET;
3948 }
3949 if (setsockopt(sk, SOL_SOCKET, SO_RCVBUF, (char*)&len, sizeof(int)))
3950 { soap->errnum = soap_socket_errno(sk);
3951 soap_set_sender_error(soap, tcp_error(soap), "setsockopt SO_RCVBUF failed in tcp_connect()", SOAP_TCP_ERROR);
3952 soap->fclosesocket(soap, sk);
3953 #ifdef WITH_IPV6
3954 freeaddrinfo(ressave);
3955 #endif
3956 return SOAP_INVALID_SOCKET;
3957 }
3958 #ifdef TCP_KEEPIDLE
3959 if (soap->tcp_keep_idle && setsockopt((SOAP_SOCKET)sk, IPPROTO_TCP, TCP_KEEPIDLE, (char*)&(soap->tcp_keep_idle), sizeof(int)))
3960 { soap->errnum = soap_socket_errno(sk);
3961 soap_set_sender_error(soap, tcp_error(soap), "setsockopt TCP_KEEPIDLE failed in tcp_connect()", SOAP_TCP_ERROR);
3962 soap->fclosesocket(soap, (SOAP_SOCKET)sk);
3963 #ifdef WITH_IPV6
3964 freeaddrinfo(ressave);
3965 #endif
3966 return SOAP_INVALID_SOCKET;
3967 }
3968 #endif
3969 #ifdef TCP_KEEPINTVL
3970 if (soap->tcp_keep_intvl && setsockopt((SOAP_SOCKET)sk, IPPROTO_TCP, TCP_KEEPINTVL, (char*)&(soap->tcp_keep_intvl), sizeof(int)))
3971 { soap->errnum = soap_socket_errno(sk);
3972 soap_set_sender_error(soap, tcp_error(soap), "setsockopt TCP_KEEPINTVL failed in tcp_connect()", SOAP_TCP_ERROR);
3973 soap->fclosesocket(soap, (SOAP_SOCKET)sk);
3974 #ifdef WITH_IPV6
3975 freeaddrinfo(ressave);
3976 #endif
3977 return SOAP_INVALID_SOCKET;
3978 }
3979 #endif
3980 #ifdef TCP_KEEPCNT
3981 if (soap->tcp_keep_cnt && setsockopt((SOAP_SOCKET)sk, IPPROTO_TCP, TCP_KEEPCNT, (char*)&(soap->tcp_keep_cnt), sizeof(int)))
3982 { soap->errnum = soap_socket_errno(sk);
3983 soap_set_sender_error(soap, tcp_error(soap), "setsockopt TCP_KEEPCNT failed in tcp_connect()", SOAP_TCP_ERROR);
3984 soap->fclosesocket(soap, (SOAP_SOCKET)sk);
3985 #ifdef WITH_IPV6
3986 freeaddrinfo(ressave);
3987 #endif
3988 return SOAP_INVALID_SOCKET;
3989 }
3990 #endif
3991 #ifdef TCP_NODELAY
3992 if (!(soap->omode & SOAP_IO_UDP) && setsockopt(sk, IPPROTO_TCP, TCP_NODELAY, (char*)&set, sizeof(int)))
3993 { soap->errnum = soap_socket_errno(sk);
3994 soap_set_sender_error(soap, tcp_error(soap), "setsockopt TCP_NODELAY failed in tcp_connect()", SOAP_TCP_ERROR);
3995 soap->fclosesocket(soap, sk);
3996 #ifdef WITH_IPV6
3997 freeaddrinfo(ressave);
3998 #endif
3999 return SOAP_INVALID_SOCKET;
4000 }
4001 #endif
4002 #ifdef WITH_IPV6
4003 if ((soap->omode & SOAP_IO_UDP) && soap->ipv6_multicast_if)
4004 { struct sockaddr_in6 *in6addr = (struct sockaddr_in6*)res->ai_addr;
4005 in6addr->sin6_scope_id = soap->ipv6_multicast_if;
4006 }
4007 #endif
4008 #ifdef IP_MULTICAST_TTL
4009 if ((soap->omode & SOAP_IO_UDP))
4010 { if (soap->ipv4_multicast_ttl)
4011 { unsigned char ttl = soap->ipv4_multicast_ttl;
4012 if (setsockopt(sk, IPPROTO_IP, IP_MULTICAST_TTL, (char*)&ttl, sizeof(ttl)))
4013 { soap->errnum = soap_socket_errno(sk);
4014 soap_set_sender_error(soap, tcp_error(soap), "setsockopt IP_MULTICAST_TTL failed in tcp_connect()", SOAP_TCP_ERROR);
4015 soap->fclosesocket(soap, sk);
4016 return SOAP_INVALID_SOCKET;
4017 }
4018 }
4019 if ((soap->omode & SOAP_IO_UDP) && soap->ipv4_multicast_if && !soap->ipv6_multicast_if)
4020 { if (setsockopt(sk, IPPROTO_IP, IP_MULTICAST_IF, (char*)soap->ipv4_multicast_if, sizeof(struct in_addr)))
4021 #ifndef WINDOWS
4022 { soap->errnum = soap_socket_errno(sk);
4023 soap_set_sender_error(soap, tcp_error(soap), "setsockopt IP_MULTICAST_IF failed in tcp_connect()", SOAP_TCP_ERROR);
4024 soap->fclosesocket(soap, sk);
4025 return SOAP_INVALID_SOCKET;
4026 }
4027 #else
4028 #ifndef IP_MULTICAST_IF
4029 #define IP_MULTICAST_IF 2
4030 #endif
4031 if (setsockopt(sk, IPPROTO_IP, IP_MULTICAST_IF, (char*)soap->ipv4_multicast_if, sizeof(struct in_addr)))
4032 { soap->errnum = soap_socket_errno(sk);
4033 soap_set_sender_error(soap, tcp_error(soap), "setsockopt IP_MULTICAST_IF failed in tcp_connect()", SOAP_TCP_ERROR);
4034 soap->fclosesocket(soap, sk);
4035 return SOAP_INVALID_SOCKET;
4036 }
4037 #endif
4038 }
4039 }
4040 #endif
4041 #endif
4042 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Opening socket=%d to host='%s' port=%d\n", sk, host, port));
4043 #ifndef WITH_IPV6
4044 soap->peerlen = sizeof(soap->peer);
4045 memset((void*)&soap->peer, 0, sizeof(soap->peer));
4046 soap->peer.sin_family = AF_INET;
4047 soap->errmode = 2;
4048 if (soap->proxy_host)
4049 { if (soap->fresolve(soap, soap->proxy_host, &soap->peer.sin_addr))
4050 { soap_set_sender_error(soap, tcp_error(soap), "get proxy host by name failed in tcp_connect()", SOAP_TCP_ERROR);
4051 soap->fclosesocket(soap, sk);
4052 return SOAP_INVALID_SOCKET;
4053 }
4054 soap->peer.sin_port = htons((short)soap->proxy_port);
4055 }
4056 else
4057 { if (soap->fresolve(soap, host, &soap->peer.sin_addr))
4058 { soap_set_sender_error(soap, tcp_error(soap), "get host by name failed in tcp_connect()", SOAP_TCP_ERROR);
4059 soap->fclosesocket(soap, sk);
4060 return SOAP_INVALID_SOCKET;
4061 }
4062 soap->peer.sin_port = htons((short)port);
4063 }
4064 soap->errmode = 0;
4065 #ifndef WITH_LEAN
4066 if ((soap->omode & SOAP_IO_UDP))
4067 return sk;
4068 #endif
4069 #else
4070 if ((soap->omode & SOAP_IO_UDP))
4071 { memcpy(&soap->peer, res->ai_addr, res->ai_addrlen);
4072 soap->peerlen = res->ai_addrlen;
4073 freeaddrinfo(ressave);
4074 return sk;
4075 }
4076 #endif
4077 #ifndef WITH_LEAN
4078 if (soap->connect_timeout)
4079 SOAP_SOCKNONBLOCK(sk)
4080 else
4081 SOAP_SOCKBLOCK(sk)
4082 retries = 10;
4083 #endif
4084 for (;;)
4085 {
4086 #ifdef WITH_IPV6
4087 if (connect(sk, res->ai_addr, (int)res->ai_addrlen))
4088 #else
4089 if (connect(sk, (struct sockaddr*)&soap->peer, sizeof(soap->peer)))
4090 #endif
4091 { err = soap_socket_errno(sk);
4092 #ifndef WITH_LEAN
4093 if (err == SOAP_EADDRINUSE)
4094 { soap->fclosesocket(soap, sk);
4095 if (retries-- > 0)
4096 goto again;
4097 }
4098 else if (soap->connect_timeout && (err == SOAP_EINPROGRESS || err == SOAP_EAGAIN || err == SOAP_EWOULDBLOCK))
4099 {
4100 SOAP_SOCKLEN_T k;
4101 for (;;)
4102 { register int r;
4103 r = tcp_select(soap, sk, SOAP_TCP_SELECT_SND, soap->connect_timeout);
4104 if (r > 0)
4105 break;
4106 if (!r)
4107 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Connect timeout\n"));
4108 soap_set_sender_error(soap, "Timeout", "connect failed in tcp_connect()", SOAP_TCP_ERROR);
4109 soap->fclosesocket(soap, sk);
4110 #ifdef WITH_IPV6
4111 freeaddrinfo(ressave);
4112 #endif
4113 return SOAP_INVALID_SOCKET;
4114 }
4115 r = soap->errnum = soap_socket_errno(sk);
4116 if (r != SOAP_EINTR)
4117 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not connect to host\n"));
4118 soap_set_sender_error(soap, tcp_error(soap), "connect failed in tcp_connect()", SOAP_TCP_ERROR);
4119 soap->fclosesocket(soap, sk);
4120 #ifdef WITH_IPV6
4121 freeaddrinfo(ressave);
4122 #endif
4123 return SOAP_INVALID_SOCKET;
4124 }
4125 }
4126 k = (SOAP_SOCKLEN_T)sizeof(soap->errnum);
4127 if (!getsockopt(sk, SOL_SOCKET, SO_ERROR, (char*)&soap->errnum, &k) && !soap->errnum) /* portability note: see SOAP_SOCKLEN_T definition in stdsoap2.h */
4128 break;
4129 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not connect to host\n"));
4130 if (!soap->errnum)
4131 soap->errnum = soap_socket_errno(sk);
4132 soap_set_sender_error(soap, tcp_error(soap), "connect failed in tcp_connect()", SOAP_TCP_ERROR);
4133 soap->fclosesocket(soap, sk);
4134 #ifdef WITH_IPV6
4135 freeaddrinfo(ressave);
4136 #endif
4137 return SOAP_INVALID_SOCKET;
4138 }
4139 #endif
4140 #ifdef WITH_IPV6
4141 if (res->ai_next)
4142 { res = res->ai_next;
4143 soap->fclosesocket(soap, sk);
4144 goto again;
4145 }
4146 #endif
4147 if (err && err != SOAP_EINTR)
4148 { soap->errnum = err;
4149 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not connect to host\n"));
4150 soap_set_sender_error(soap, tcp_error(soap), "connect failed in tcp_connect()", SOAP_TCP_ERROR);
4151 soap->fclosesocket(soap, sk);
4152 #ifdef WITH_IPV6
4153 freeaddrinfo(ressave);
4154 #endif
4155 return SOAP_INVALID_SOCKET;
4156 }
4157 }
4158 else
4159 break;
4160 }
4161 #ifdef WITH_IPV6
4162 soap->peerlen = 0; /* IPv6: already connected so use send() */
4163 freeaddrinfo(ressave);
4164 #endif
4165 soap->socket = sk;
4166 soap->imode &= ~SOAP_ENC_SSL;
4167 soap->omode &= ~SOAP_ENC_SSL;
4168 if (!soap_tag_cmp(endpoint, "https:*"))
4169 {
4170 #if defined(WITH_OPENSSL) || defined(WITH_GNUTLS)
4171 #ifdef WITH_OPENSSL
4172 BIO *bio;
4173 #endif
4174 int r;
4175 if (soap->proxy_host)
4176 { soap_mode m = soap->mode; /* preserve settings */
4177 soap_mode om = soap->omode; /* make sure we only parse HTTP */
4178 size_t n = soap->count; /* save the content length */
4179 const char *userid, *passwd;
4180 int status = soap->status; /* save the current status/command */
4181 short keep_alive = soap->keep_alive; /* save the KA status */
4182 soap->omode &= ~SOAP_ENC; /* mask IO and ENC */
4183 soap->omode |= SOAP_IO_BUFFER;
4184 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Connecting to %s proxy server %s for destination endpoint %s\n", soap->proxy_http_version, soap->proxy_host, endpoint));
4185 #ifdef WITH_NTLM
4186 if (soap->ntlm_challenge)
4187 { if (soap_ntlm_handshake(soap, SOAP_CONNECT, endpoint, host, port))
4188 return soap->error;
4189 }
4190 #endif
4191 if (soap_begin_send(soap))
4192 { soap->fclosesocket(soap, sk);
4193 return SOAP_INVALID_SOCKET;
4194 }
4195 soap->status = SOAP_CONNECT;
4196 soap->keep_alive = 1;
4197 if ((soap->error = soap->fpost(soap, endpoint, host, port, NULL, NULL, 0))
4198 || soap_end_send_flush(soap))
4199 { soap->fclosesocket(soap, sk);
4200 return SOAP_INVALID_SOCKET;
4201 }
4202 soap->keep_alive = keep_alive;
4203 soap->omode = om;
4204 om = soap->imode;
4205 soap->imode &= ~SOAP_ENC; /* mask IO and ENC */
4206 userid = soap->userid; /* preserve */
4207 passwd = soap->passwd; /* preserve */
4208 if ((soap->error = soap->fparse(soap)))
4209 { soap->fclosesocket(soap, sk);
4210 return SOAP_INVALID_SOCKET;
4211 }
4212 soap->status = status; /* restore */
4213 soap->userid = userid; /* restore */
4214 soap->passwd = passwd; /* restore */
4215 soap->imode = om; /* restore */
4216 soap->count = n; /* restore */
4217 if (soap_begin_send(soap))
4218 { soap->fclosesocket(soap, sk);
4219 return SOAP_INVALID_SOCKET;
4220 }
4221 if (endpoint)
4222 { strncpy(soap->endpoint, endpoint, sizeof(soap->endpoint)); /* restore */
4223 soap->endpoint[sizeof(soap->endpoint) - 1] = '\0';
4224 }
4225 soap->mode = m;
4226 }
4227 #ifdef WITH_OPENSSL
4228 soap->ssl_flags |= SOAP_SSL_CLIENT;
4229 if (!soap->ctx && (soap->error = soap->fsslauth(soap)))
4230 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "SSL required, but no ctx set\n"));
4231 soap->fclosesocket(soap, sk);
4232 soap->error = SOAP_SSL_ERROR;
4233 return SOAP_INVALID_SOCKET;
4234 }
4235 if (!soap->ssl)
4236 { soap->ssl = SSL_new(soap->ctx);
4237 if (!soap->ssl)
4238 { soap->fclosesocket(soap, sk);
4239 soap->error = SOAP_SSL_ERROR;
4240 return SOAP_INVALID_SOCKET;
4241 }
4242 }
4243 else
4244 SSL_clear(soap->ssl);
4245 if (soap->session)
4246 { if (!strcmp(soap->session_host, host) && soap->session_port == port)
4247 SSL_set_session(soap->ssl, soap->session);
4248 SSL_SESSION_free(soap->session);
4249 soap->session = NULL;
4250 }
4251 soap->imode |= SOAP_ENC_SSL;
4252 soap->omode |= SOAP_ENC_SSL;
4253 bio = BIO_new_socket((int)sk, BIO_NOCLOSE);
4254 SSL_set_bio(soap->ssl, bio, bio);
4255 /* Connect timeout: set SSL sockets to non-blocking */
4256 retries = 0;
4257 if (soap->connect_timeout)
4258 { SOAP_SOCKNONBLOCK(sk)
4259 retries = 10*soap->connect_timeout;
4260 }
4261 else
4262 SOAP_SOCKBLOCK(sk)
4263 if (retries <= 0)
4264 retries = 100; /* timeout: 10 sec retries, 100 times 0.1 sec */
4265 /* Try connecting until success or timeout (when nonblocking) */
4266 do
4267 { if ((r = SSL_connect(soap->ssl)) <= 0)
4268 { int err = SSL_get_error(soap->ssl, r);
4269 if (err == SSL_ERROR_WANT_CONNECT || err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE)
4270 { register int s;
4271 if (err == SSL_ERROR_WANT_READ)
4272 s = tcp_select(soap, sk, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_ERR, -100000);
4273 else
4274 s = tcp_select(soap, sk, SOAP_TCP_SELECT_SND | SOAP_TCP_SELECT_ERR, -100000);
4275 if (s < 0)
4276 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "SSL_connect/select error in tcp_connect\n"));
4277 soap_set_sender_error(soap, soap_ssl_error(soap, r), "SSL_connect failed in tcp_connect()", SOAP_TCP_ERROR);
4278 soap->fclosesocket(soap, sk);
4279 return SOAP_INVALID_SOCKET;
4280 }
4281 if (s == 0 && retries-- <= 0)
4282 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "SSL/TLS connect timeout\n"));
4283 soap_set_sender_error(soap, "Timeout", "SSL_connect failed in tcp_connect()", SOAP_TCP_ERROR);
4284 soap->fclosesocket(soap, sk);
4285 return SOAP_INVALID_SOCKET;
4286 }
4287 }
4288 else
4289 { soap_set_sender_error(soap, soap_ssl_error(soap, r), "SSL_connect error in tcp_connect()", SOAP_SSL_ERROR);
4290 soap->fclosesocket(soap, sk);
4291 return SOAP_INVALID_SOCKET;
4292 }
4293 }
4294 } while (!SSL_is_init_finished(soap->ssl));
4295 /* Set SSL sockets to nonblocking */
4296 SOAP_SOCKNONBLOCK(sk)
4297 /* Check server credentials when required */
4298 if ((soap->ssl_flags & SOAP_SSL_REQUIRE_SERVER_AUTHENTICATION))
4299 { int err;
4300 if ((err = SSL_get_verify_result(soap->ssl)) != X509_V_OK)
4301 { soap_set_sender_error(soap, X509_verify_cert_error_string(err), "SSL/TLS certificate presented by peer cannot be verified in tcp_connect()", SOAP_SSL_ERROR);
4302 soap->fclosesocket(soap, sk);
4303 return SOAP_INVALID_SOCKET;
4304 }
4305 if (!(soap->ssl_flags & SOAP_SSL_SKIP_HOST_CHECK))
4306 { X509_NAME *subj;
4307 STACK_OF(CONF_VALUE) *val = NULL;
4308 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL)
4309 GENERAL_NAMES *names = NULL;
4310 #else
4311 int ext_count;
4312 #endif
4313 int ok = 0;
4314 X509 *peer = SSL_get_peer_certificate(soap->ssl);
4315 if (!peer)
4316 { soap_set_sender_error(soap, "SSL/TLS error", "No SSL/TLS certificate was presented by the peer in tcp_connect()", SOAP_SSL_ERROR);
4317 soap->fclosesocket(soap, sk);
4318 return SOAP_INVALID_SOCKET;
4319 }
4320 #if (OPENSSL_VERSION_NUMBER < 0x0090800fL)
4321 ext_count = X509_get_ext_count(peer);
4322 if (ext_count > 0)
4323 { int i;
4324 for (i = 0; i < ext_count; i++)
4325 { X509_EXTENSION *ext = X509_get_ext(peer, i);
4326 const char *ext_str = OBJ_nid2sn(OBJ_obj2nid(X509_EXTENSION_get_object(ext)));
4327 if (ext_str && !strcmp(ext_str, "subjectAltName"))
4328 { X509V3_EXT_METHOD *meth = (X509V3_EXT_METHOD*)X509V3_EXT_get(ext);
4329 unsigned char *data;
4330 if (!meth)
4331 break;
4332 data = ext->value->data;
4333 if (data)
4334 {
4335 #if (OPENSSL_VERSION_NUMBER > 0x00907000L)
4336 void *ext_data;
4337 if (meth->it)
4338 ext_data = ASN1_item_d2i(NULL, &data, ext->value->length, ASN1_ITEM_ptr(meth->it));
4339 else
4340 { /* OpenSSL is not portable at this point (?):
4341 Some compilers appear to prefer
4342 meth->d2i(NULL, (const unsigned char**)&data, ...
4343 and others prefer
4344 meth->d2i(NULL, &data, ext->value->length);
4345 */
4346 ext_data = meth->d2i(NULL, &data, ext->value->length);
4347 }
4348 if (ext_data)
4349 val = meth->i2v(meth, ext_data, NULL);
4350 else
4351 val = NULL;
4352 if (meth->it)
4353 ASN1_item_free((ASN1_VALUE*)ext_data, ASN1_ITEM_ptr(meth->it));
4354 else
4355 meth->ext_free(ext_data);
4356 #else
4357 void *ext_data = meth->d2i(NULL, &data, ext->value->length);
4358 if (ext_data)
4359 val = meth->i2v(meth, ext_data, NULL);
4360 meth->ext_free(ext_data);
4361 #endif
4362 if (val)
4363 { int j;
4364 for (j = 0; j < sk_CONF_VALUE_num(val); j++)
4365 { CONF_VALUE *nval = sk_CONF_VALUE_value(val, j);
4366 if (nval && !strcmp(nval->name, "DNS") && !strcmp(nval->value, host))
4367 { ok = 1;
4368 break;
4369 }
4370 }
4371 sk_CONF_VALUE_pop_free(val, X509V3_conf_free);
4372 }
4373 }
4374 }
4375 if (ok)
4376 break;
4377 }
4378 }
4379 #else
4380 names = (GENERAL_NAMES*)X509_get_ext_d2i(peer, NID_subject_alt_name, NULL, NULL);
4381 if (names)
4382 { val = i2v_GENERAL_NAMES(NULL, names, val);
4383 sk_GENERAL_NAME_pop_free(names, GENERAL_NAME_free);
4384 }
4385 if (val)
4386 { int j;
4387 for (j = 0; j < sk_CONF_VALUE_num(val); j++)
4388 { CONF_VALUE *nval = sk_CONF_VALUE_value(val, j);
4389 if (nval && !strcmp(nval->name, "DNS") && !strcmp(nval->value, host))
4390 { ok = 1;
4391 break;
4392 }
4393 }
4394 sk_CONF_VALUE_pop_free(val, X509V3_conf_free);
4395 }
4396 #endif
4397 if (!ok && (subj = X509_get_subject_name(peer)))
4398 { int i = -1;
4399 do
4400 { ASN1_STRING *name;
4401 i = X509_NAME_get_index_by_NID(subj, NID_commonName, i);
4402 if (i == -1)
4403 break;
4404 name = X509_NAME_ENTRY_get_data(X509_NAME_get_entry(subj, i));
4405 if (name)
4406 { if (!soap_tag_cmp(host, (const char*)M_ASN1_STRING_data(name)))
4407 ok = 1;
4408 else
4409 { unsigned char *tmp = NULL;
4410 ASN1_STRING_to_UTF8(&tmp, name);
4411 if (tmp)
4412 { if (!soap_tag_cmp(host, (const char*)tmp))
4413 ok = 1;
4414 else if (tmp[0] == '*') /* wildcard domain */
4415 { const char *t = strchr(host, '.');
4416 if (t && !soap_tag_cmp(t, (const char*)tmp+1))
4417 ok = 1;
4418 }
4419 OPENSSL_free(tmp);
4420 }
4421 }
4422 }
4423 } while (!ok);
4424 }
4425 X509_free(peer);
4426 if (!ok)
4427 { soap_set_sender_error(soap, "SSL/TLS error", "SSL/TLS certificate host name mismatch in tcp_connect()", SOAP_SSL_ERROR);
4428 soap->fclosesocket(soap, sk);
4429 return SOAP_INVALID_SOCKET;
4430 }
4431 }
4432 }
4433 #endif
4434 #ifdef WITH_GNUTLS
4435 soap->ssl_flags |= SOAP_SSL_CLIENT;
4436 if (!soap->session && (soap->error = soap->fsslauth(soap)))
4437 { soap->fclosesocket(soap, sk);
4438 return SOAP_INVALID_SOCKET;
4439 }
4440 gnutls_transport_set_ptr(soap->session, (gnutls_transport_ptr_t)(long)sk);
4441 /* Set SSL sockets to non-blocking */
4442 if (soap->connect_timeout)
4443 { SOAP_SOCKNONBLOCK(sk)
4444 retries = 10*soap->connect_timeout;
4445 }
4446 else
4447 SOAP_SOCKBLOCK(sk)
4448 if (retries <= 0)
4449 retries = 100; /* timeout: 10 sec retries, 100 times 0.1 sec */
4450 while ((r = gnutls_handshake(soap->session)))
4451 { int s;
4452 /* GNUTLS repeat handhake when GNUTLS_E_AGAIN */
4453 if (retries-- <= 0)
4454 break;
4455 if (r == GNUTLS_E_AGAIN || r == GNUTLS_E_INTERRUPTED)
4456 { if (!gnutls_record_get_direction(soap->session))
4457 s = tcp_select(soap, sk, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_ERR, -100000);
4458 else
4459 s = tcp_select(soap, sk, SOAP_TCP_SELECT_SND | SOAP_TCP_SELECT_ERR, -100000);
4460 if (s < 0)
4461 break;
4462 }
4463 else
4464 { soap->errnum = soap_socket_errno(sk);
4465 break;
4466 }
4467 }
4468 if (r)
4469 { soap_set_sender_error(soap, soap_ssl_error(soap, r), "SSL/TLS handshake failed", SOAP_SSL_ERROR);
4470 soap->fclosesocket(soap, sk);
4471 return SOAP_INVALID_SOCKET;
4472 }
4473 if ((soap->ssl_flags & SOAP_SSL_REQUIRE_SERVER_AUTHENTICATION))
4474 { const char *err = ssl_verify(soap, host);
4475 if (err)
4476 { soap->fclosesocket(soap, sk);
4477 soap->error = soap_set_sender_error(soap, "SSL/TLS error", err, SOAP_SSL_ERROR);
4478 return SOAP_INVALID_SOCKET;
4479 }
4480 }
4481 #endif
4482 #else
4483 soap->fclosesocket(soap, sk);
4484 soap->error = SOAP_SSL_ERROR;
4485 return SOAP_INVALID_SOCKET;
4486 #endif
4487 }
4488 if (soap->recv_timeout || soap->send_timeout)
4489 SOAP_SOCKNONBLOCK(sk)
4490 else
4491 SOAP_SOCKBLOCK(sk)
4492 return sk;
4493 }
4494 #endif
4495 #endif
4496
4497 /******************************************************************************/
4498 #ifndef WITH_NOIO
4499 #ifndef PALM_1
4500 static int
4501 tcp_select(struct soap *soap, SOAP_SOCKET sk, int flags, int timeout)
4502 { int r;
4503 struct timeval tv;
4504 fd_set fd[3], *rfd, *sfd, *efd;
4505 int retries = 0;
4506 int eintr = SOAP_MAXEINTR;
4507 soap->errnum = 0;
4508 #ifndef WIN32
4509 #if !defined(FD_SETSIZE) || defined(__QNX__) || defined(QNX)
4510 /* no FD_SETSIZE or select() is not MT safe on some QNX: always poll */
4511 if (1)
4512 #else
4513 /* if fd max set size exceeded, use poll() */
4514 if ((int)sk >= (int)FD_SETSIZE)
4515 #endif
4516 #ifdef HAVE_POLL
4517 { struct pollfd pollfd;
4518 pollfd.fd = (int)sk;
4519 pollfd.events = 0;
4520 if (flags & SOAP_TCP_SELECT_RCV)
4521 pollfd.events |= POLLIN;
4522 if (flags & SOAP_TCP_SELECT_SND)
4523 pollfd.events |= POLLOUT;
4524 if (flags & SOAP_TCP_SELECT_ERR)
4525 pollfd.events |= POLLERR;
4526 if (timeout <= 0)
4527 timeout /= -1000; /* -usec -> ms */
4528 else
4529 { retries = timeout - 1;
4530 timeout = 1000;
4531 }
4532 do
4533 { r = poll(&pollfd, 1, timeout);
4534 if (r < 0 && (soap->errnum = soap_socket_errno(sk)) == SOAP_EINTR && eintr--)
4535 continue;
4536 } while (r == 0 && retries--);
4537 if (r > 0)
4538 { r = 0;
4539 if ((flags & SOAP_TCP_SELECT_RCV) && (pollfd.revents & POLLIN))
4540 r |= SOAP_TCP_SELECT_RCV;
4541 if ((flags & SOAP_TCP_SELECT_SND) && (pollfd.revents & POLLOUT))
4542 r |= SOAP_TCP_SELECT_SND;
4543 if ((flags & SOAP_TCP_SELECT_ERR) && (pollfd.revents & POLLERR))
4544 r |= SOAP_TCP_SELECT_ERR;
4545 }
4546 return r;
4547 }
4548 #else
4549 { soap->error = SOAP_FD_EXCEEDED;
4550 return -1;
4551 }
4552 #endif
4553 #endif
4554 if (timeout > 0)
4555 retries = timeout - 1;
4556 do
4557 { rfd = sfd = efd = NULL;
4558 if (flags & SOAP_TCP_SELECT_RCV)
4559 { rfd = &fd[0];
4560 FD_ZERO(rfd);
4561 FD_SET(sk, rfd);
4562 }
4563 if (flags & SOAP_TCP_SELECT_SND)
4564 { sfd = &fd[1];
4565 FD_ZERO(sfd);
4566 FD_SET(sk, sfd);
4567 }
4568 if (flags & SOAP_TCP_SELECT_ERR)
4569 { efd = &fd[2];
4570 FD_ZERO(efd);
4571 FD_SET(sk, efd);
4572 }
4573 if (timeout <= 0)
4574 { tv.tv_sec = -timeout / 1000000;
4575 tv.tv_usec = -timeout % 1000000;
4576 }
4577 else
4578 { tv.tv_sec = 1;
4579 tv.tv_usec = 0;
4580 }
4581 r = select((int)sk + 1, rfd, sfd, efd, &tv);
4582 if (r < 0 && (soap->errnum = soap_socket_errno(sk)) == SOAP_EINTR && eintr--)
4583 continue;
4584 } while (r == 0 && retries--);
4585 if (r > 0)
4586 { r = 0;
4587 if ((flags & SOAP_TCP_SELECT_RCV) && FD_ISSET(sk, rfd))
4588 r |= SOAP_TCP_SELECT_RCV;
4589 if ((flags & SOAP_TCP_SELECT_SND) && FD_ISSET(sk, sfd))
4590 r |= SOAP_TCP_SELECT_SND;
4591 if ((flags & SOAP_TCP_SELECT_ERR) && FD_ISSET(sk, efd))
4592 r |= SOAP_TCP_SELECT_ERR;
4593 }
4594 return r;
4595 }
4596 #endif
4597 #endif
4598
4599 /******************************************************************************/
4600 #ifndef WITH_NOIO
4601 #ifndef PALM_1
4602 static SOAP_SOCKET
4603 tcp_accept(struct soap *soap, SOAP_SOCKET s, struct sockaddr *a, int *n)
4604 { SOAP_SOCKET sk;
4605 (void)soap;
4606 sk = accept(s, a, (SOAP_SOCKLEN_T*)n); /* portability note: see SOAP_SOCKLEN_T definition in stdsoap2.h */
4607 #ifdef SOCKET_CLOSE_ON_EXEC
4608 #ifdef WIN32
4609 #ifndef UNDER_CE
4610 SetHandleInformation((HANDLE)sk, HANDLE_FLAG_INHERIT, 0);
4611 #endif
4612 #else
4613 fcntl(sk, F_SETFD, FD_CLOEXEC);
4614 #endif
4615 #endif
4616 return sk;
4617 }
4618 #endif
4619 #endif
4620
4621 /******************************************************************************/
4622 #ifndef WITH_NOIO
4623 #ifndef PALM_1
4624 static int
4625 tcp_disconnect(struct soap *soap)
4626 {
4627 #ifdef WITH_OPENSSL
4628 if (soap->ssl)
4629 { int r, s = 0;
4630 if (soap->session)
4631 { SSL_SESSION_free(soap->session);
4632 soap->session = NULL;
4633 }
4634 if (*soap->host)
4635 { soap->session = SSL_get1_session(soap->ssl);
4636 if (soap->session)
4637 { strcpy(soap->session_host, soap->host);
4638 soap->session_port = soap->port;
4639 }
4640 }
4641 r = SSL_shutdown(soap->ssl);
4642 /* SSL shutdown does not work when reads are pending, non-blocking */
4643 if (r == 0)
4644 { while (SSL_want_read(soap->ssl))
4645 { if (SSL_read(soap->ssl, NULL, 0)
4646 || soap_socket_errno(soap->socket) != SOAP_EAGAIN)
4647 { r = SSL_shutdown(soap->ssl);
4648 break;
4649 }
4650 }
4651 }
4652 if (r == 0)
4653 { if (soap_valid_socket(soap->socket))
4654 { if (!soap->fshutdownsocket(soap, soap->socket, SOAP_SHUT_WR))
4655 {
4656 #if !defined(WITH_LEAN) && !defined(WIN32)
4657 /*
4658 wait up to 5 seconds for close_notify to be sent by peer (if peer not
4659 present, this avoids calling SSL_shutdown() which has a lengthy return
4660 timeout)
4661 */
4662 r = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_ERR, 5);
4663 if (r <= 0)
4664 { soap->errnum = 0;
4665 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Connection lost...\n"));
4666 soap->fclosesocket(soap, soap->socket);
4667 soap->socket = SOAP_INVALID_SOCKET;
4668 ERR_remove_state(0);
4669 SSL_free(soap->ssl);
4670 soap->ssl = NULL;
4671 return SOAP_OK;
4672 }
4673 #else
4674 r = SSL_shutdown(soap->ssl);
4675 #endif
4676 }
4677 }
4678 }
4679 if (r != 1)
4680 { s = ERR_get_error();
4681 if (s)
4682 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Shutdown failed: %d\n", SSL_get_error(soap->ssl, r)));
4683 if (soap_valid_socket(soap->socket) && !(soap->omode & SOAP_IO_UDP))
4684 { soap->fclosesocket(soap, soap->socket);
4685 soap->socket = SOAP_INVALID_SOCKET;
4686 }
4687 }
4688 }
4689 SSL_free(soap->ssl);
4690 soap->ssl = NULL;
4691 if (s)
4692 return SOAP_SSL_ERROR;
4693 ERR_remove_state(0);
4694 }
4695 #endif
4696 #ifdef WITH_GNUTLS
4697 if (soap->session)
4698 { gnutls_bye(soap->session, GNUTLS_SHUT_RDWR);
4699 gnutls_deinit(soap->session);
4700 soap->session = NULL;
4701 }
4702 #endif
4703 if (soap_valid_socket(soap->socket) && !(soap->omode & SOAP_IO_UDP))
4704 { soap->fshutdownsocket(soap, soap->socket, SOAP_SHUT_RDWR);
4705 soap->fclosesocket(soap, soap->socket);
4706 soap->socket = SOAP_INVALID_SOCKET;
4707 }
4708 return SOAP_OK;
4709 }
4710 #endif
4711 #endif
4712
4713 /******************************************************************************/
4714 #ifndef WITH_NOIO
4715 #ifndef PALM_1
4716 static int
4717 tcp_closesocket(struct soap *soap, SOAP_SOCKET sk)
4718 { (void)soap;
4719 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Close socket=%d\n", (int)sk));
4720 return soap_closesocket(sk);
4721 }
4722 #endif
4723 #endif
4724
4725 /******************************************************************************/
4726 #ifndef WITH_NOIO
4727 #ifndef PALM_1
4728 static int
4729 tcp_shutdownsocket(struct soap *soap, SOAP_SOCKET sk, int how)
4730 { (void)soap;
4731 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Shutdown socket=%d how=%d\n", (int)sk, how));
4732 return shutdown(sk, how);
4733 }
4734 #endif
4735 #endif
4736
4737 /******************************************************************************/
4738 #ifndef WITH_NOIO
4739 #ifndef PALM_1
4740 SOAP_FMAC1
4741 SOAP_SOCKET
4742 SOAP_FMAC2
4743 soap_bind(struct soap *soap, const char *host, int port, int backlog)
4744 {
4745 #ifdef WITH_IPV6
4746 struct addrinfo *addrinfo = NULL;
4747 struct addrinfo hints;
4748 struct addrinfo res;
4749 int err;
4750 #ifdef WITH_NO_IPV6_V6ONLY
4751 int unset = 0;
4752 #endif
4753 #endif
4754 #ifndef WITH_LEAN
4755 #ifndef WIN32
4756 int len = SOAP_BUFLEN;
4757 #else
4758 int len = SOAP_BUFLEN + 1; /* speeds up windows xfer */
4759 #endif
4760 int set = 1;
4761 #endif
4762 if (soap_valid_socket(soap->master))
4763 { soap->fclosesocket(soap, soap->master);
4764 soap->master = SOAP_INVALID_SOCKET;
4765 }
4766 soap->socket = SOAP_INVALID_SOCKET;
4767 soap->errmode = 1;
4768 if (tcp_init(soap))
4769 { soap_set_receiver_error(soap, tcp_error(soap), "TCP init failed in soap_bind()", SOAP_TCP_ERROR);
4770 return SOAP_INVALID_SOCKET;
4771 }
4772 #ifdef WITH_IPV6
4773 memset((void*)&hints, 0, sizeof(hints));
4774 hints.ai_family = PF_UNSPEC;
4775 #ifndef WITH_LEAN
4776 if ((soap->omode & SOAP_IO_UDP))
4777 hints.ai_socktype = SOCK_DGRAM;
4778 else
4779 #endif
4780 hints.ai_socktype = SOCK_STREAM;
4781 hints.ai_flags = AI_PASSIVE;
4782 soap->errmode = 2;
4783 err = getaddrinfo(host, soap_int2s(soap, port), &hints, &addrinfo);
4784 if (err || !addrinfo)
4785 { soap_set_receiver_error(soap, SOAP_GAI_STRERROR(err), "getaddrinfo failed in soap_bind()", SOAP_TCP_ERROR);
4786 return SOAP_INVALID_SOCKET;
4787 }
4788 res = *addrinfo;
4789 memcpy(&soap->peer, addrinfo->ai_addr, addrinfo->ai_addrlen);
4790 soap->peerlen = addrinfo->ai_addrlen;
4791 res.ai_addr = (struct sockaddr*)&soap->peer;
4792 res.ai_addrlen = soap->peerlen;
4793 freeaddrinfo(addrinfo);
4794 soap->master = (int)socket(res.ai_family, res.ai_socktype, res.ai_protocol);
4795 #else
4796 #ifndef WITH_LEAN
4797 if ((soap->omode & SOAP_IO_UDP))
4798 soap->master = (int)socket(AF_INET, SOCK_DGRAM, 0);
4799 else
4800 #endif
4801 soap->master = (int)socket(AF_INET, SOCK_STREAM, 0);
4802 #endif
4803 soap->errmode = 0;
4804 if (!soap_valid_socket(soap->master))
4805 { soap->errnum = soap_socket_errno(soap->master);
4806 soap_set_receiver_error(soap, tcp_error(soap), "socket failed in soap_bind()", SOAP_TCP_ERROR);
4807 return SOAP_INVALID_SOCKET;
4808 }
4809 soap->port = port;
4810 #ifndef WITH_LEAN
4811 if ((soap->omode & SOAP_IO_UDP))
4812 soap->socket = soap->master;
4813 #endif
4814 #ifdef SOCKET_CLOSE_ON_EXEC
4815 #ifdef WIN32
4816 #ifndef UNDER_CE
4817 SetHandleInformation((HANDLE)soap->master, HANDLE_FLAG_INHERIT, 0);
4818 #endif
4819 #else
4820 fcntl(soap->master, F_SETFD, 1);
4821 #endif
4822 #endif
4823 #ifndef WITH_LEAN
4824 if (soap->bind_flags && setsockopt(soap->master, SOL_SOCKET, soap->bind_flags, (char*)&set, sizeof(int)))
4825 { soap->errnum = soap_socket_errno(soap->master);
4826 soap_set_receiver_error(soap, tcp_error(soap), "setsockopt failed in soap_bind()", SOAP_TCP_ERROR);
4827 return SOAP_INVALID_SOCKET;
4828 }
4829 if (((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) && (!((soap->imode | soap->omode) & SOAP_IO_UDP)) && setsockopt(soap->master, SOL_SOCKET, SO_KEEPALIVE, (char*)&set, sizeof(int)))
4830 { soap->errnum = soap_socket_errno(soap->master);
4831 soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_KEEPALIVE failed in soap_bind()", SOAP_TCP_ERROR);
4832 return SOAP_INVALID_SOCKET;
4833 }
4834 if (setsockopt(soap->master, SOL_SOCKET, SO_SNDBUF, (char*)&len, sizeof(int)))
4835 { soap->errnum = soap_socket_errno(soap->master);
4836 soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_SNDBUF failed in soap_bind()", SOAP_TCP_ERROR);
4837 return SOAP_INVALID_SOCKET;
4838 }
4839 if (setsockopt(soap->master, SOL_SOCKET, SO_RCVBUF, (char*)&len, sizeof(int)))
4840 { soap->errnum = soap_socket_errno(soap->master);
4841 soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_RCVBUF failed in soap_bind()", SOAP_TCP_ERROR);
4842 return SOAP_INVALID_SOCKET;
4843 }
4844 #ifdef TCP_NODELAY
4845 if (!(soap->omode & SOAP_IO_UDP) && setsockopt(soap->master, IPPROTO_TCP, TCP_NODELAY, (char*)&set, sizeof(int)))
4846 { soap->errnum = soap_socket_errno(soap->master);
4847 soap_set_receiver_error(soap, tcp_error(soap), "setsockopt TCP_NODELAY failed in soap_bind()", SOAP_TCP_ERROR);
4848 return SOAP_INVALID_SOCKET;
4849 }
4850 #endif
4851 #endif
4852 #ifdef WITH_IPV6
4853 #ifdef WITH_IPV6_V6ONLY
4854 if (setsockopt(soap->master, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&set, sizeof(int)))
4855 { soap->errnum = soap_socket_errno(soap->master);
4856 soap_set_receiver_error(soap, tcp_error(soap), "setsockopt set IPV6_V6ONLY failed in soap_bind()", SOAP_TCP_ERROR);
4857 return SOAP_INVALID_SOCKET;
4858 }
4859 #endif
4860 #ifdef WITH_NO_IPV6_V6ONLY
4861 if (setsockopt(soap->master, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&unset, sizeof(int)))
4862 { soap->errnum = soap_socket_errno(soap->master);
4863 soap_set_receiver_error(soap, tcp_error(soap), "setsockopt unset IPV6_V6ONLY failed in soap_bind()", SOAP_TCP_ERROR);
4864 return SOAP_INVALID_SOCKET;
4865 }
4866 #endif
4867 soap->errmode = 0;
4868 if (bind(soap->master, res.ai_addr, (int)res.ai_addrlen))
4869 { soap->errnum = soap_socket_errno(soap->master);
4870 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not bind to host\n"));
4871 soap_closesock(soap);
4872 soap_set_receiver_error(soap, tcp_error(soap), "bind failed in soap_bind()", SOAP_TCP_ERROR);
4873 return SOAP_INVALID_SOCKET;
4874 }
4875 #else
4876 soap->peerlen = sizeof(soap->peer);
4877 memset((void*)&soap->peer, 0, sizeof(soap->peer));
4878 soap->peer.sin_family = AF_INET;
4879 soap->errmode = 2;
4880 if (host)
4881 { if (soap->fresolve(soap, host, &soap->peer.sin_addr))
4882 { soap_set_receiver_error(soap, tcp_error(soap), "get host by name failed in soap_bind()", SOAP_TCP_ERROR);
4883 return SOAP_INVALID_SOCKET;
4884 }
4885 }
4886 else
4887 soap->peer.sin_addr.s_addr = htonl(INADDR_ANY);
4888 soap->peer.sin_port = htons((short)port);
4889 soap->errmode = 0;
4890 if (bind(soap->master, (struct sockaddr*)&soap->peer, (int)soap->peerlen))
4891 { soap->errnum = soap_socket_errno(soap->master);
4892 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not bind to host\n"));
4893 soap_closesock(soap);
4894 soap_set_receiver_error(soap, tcp_error(soap), "bind failed in soap_bind()", SOAP_TCP_ERROR);
4895 return SOAP_INVALID_SOCKET;
4896 }
4897 #endif
4898 if (!(soap->omode & SOAP_IO_UDP) && listen(soap->master, backlog))
4899 { soap->errnum = soap_socket_errno(soap->master);
4900 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not bind to host\n"));
4901 soap_closesock(soap);
4902 soap_set_receiver_error(soap, tcp_error(soap), "listen failed in soap_bind()", SOAP_TCP_ERROR);
4903 return SOAP_INVALID_SOCKET;
4904 }
4905 return soap->master;
4906 }
4907 #endif
4908 #endif
4909
4910 /******************************************************************************/
4911 #ifndef WITH_NOIO
4912 #ifndef PALM_1
4913 SOAP_FMAC1
4914 int
4915 SOAP_FMAC2
4916 soap_poll(struct soap *soap)
4917 {
4918 #ifndef WITH_LEAN
4919 register int r;
4920 if (soap_valid_socket(soap->socket))
4921 { r = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_ALL, 0);
4922 if (r > 0 && (r & SOAP_TCP_SELECT_ERR))
4923 r = -1;
4924 }
4925 else if (soap_valid_socket(soap->master))
4926 r = tcp_select(soap, soap->master, SOAP_TCP_SELECT_SND, 0);
4927 else
4928 return SOAP_OK; /* OK when no socket! */
4929 if (r > 0)
4930 {
4931 #ifdef WITH_OPENSSL
4932 if (soap->imode & SOAP_ENC_SSL)
4933 {
4934 if (soap_valid_socket(soap->socket)
4935 && (r & SOAP_TCP_SELECT_SND)
4936 && (!(r & SOAP_TCP_SELECT_RCV)
4937 || SSL_peek(soap->ssl, soap->tmpbuf, 1) > 0))
4938 return SOAP_OK;
4939 }
4940 else
4941 #endif
4942 { int t;
4943 if (soap_valid_socket(soap->socket)
4944 && (r & SOAP_TCP_SELECT_SND)
4945 && (!(r & SOAP_TCP_SELECT_RCV)
4946 || recv(soap->socket, (char*)&t, 1, MSG_PEEK) > 0))
4947 return SOAP_OK;
4948 }
4949 }
4950 else if (r < 0)
4951 { if ((soap_valid_socket(soap->master) || soap_valid_socket(soap->socket)) && soap_socket_errno(soap->master) != SOAP_EINTR)
4952 { soap_set_receiver_error(soap, tcp_error(soap), "select failed in soap_poll()", SOAP_TCP_ERROR);
4953 return soap->error = SOAP_TCP_ERROR;
4954 }
4955 }
4956 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Polling: other end down on socket=%d select=%d\n", soap->socket, r));
4957 return SOAP_EOF;
4958 #else
4959 return SOAP_OK;
4960 #endif
4961 }
4962 #endif
4963 #endif
4964
4965 /******************************************************************************/
4966 #ifndef WITH_NOIO
4967 #ifndef PALM_1
4968 SOAP_FMAC1
4969 SOAP_SOCKET
4970 SOAP_FMAC2
4971 soap_accept(struct soap *soap)
4972 { int n = (int)sizeof(soap->peer);
4973 register int err;
4974 #ifndef WITH_LEAN
4975 #ifndef WIN32
4976 int len = SOAP_BUFLEN;
4977 #else
4978 int len = SOAP_BUFLEN + 1; /* speeds up windows xfer */
4979 #endif
4980 int set = 1;
4981 #endif
4982 soap->error = SOAP_OK;
4983 memset((void*)&soap->peer, 0, sizeof(soap->peer));
4984 soap->socket = SOAP_INVALID_SOCKET;
4985 soap->errmode = 0;
4986 soap->keep_alive = 0;
4987 if (!soap_valid_socket(soap->master))
4988 { soap->errnum = 0;
4989 soap_set_receiver_error(soap, tcp_error(soap), "no master socket in soap_accept()", SOAP_TCP_ERROR);
4990 return SOAP_INVALID_SOCKET;
4991 }
4992 #ifndef WITH_LEAN
4993 if ((soap->omode & SOAP_IO_UDP))
4994 return soap->socket = soap->master;
4995 #endif
4996 for (;;)
4997 { if (soap->accept_timeout || soap->send_timeout || soap->recv_timeout)
4998 { for (;;)
4999 { register int r;
5000 r = tcp_select(soap, soap->master, SOAP_TCP_SELECT_ALL, soap->accept_timeout ? soap->accept_timeout : 60);
5001 if (r > 0)
5002 break;
5003 if (!r && soap->accept_timeout)
5004 { soap_set_receiver_error(soap, "Timeout", "accept failed in soap_accept()", SOAP_TCP_ERROR);
5005 return SOAP_INVALID_SOCKET;
5006 }
5007 if (r < 0)
5008 { r = soap->errnum;
5009 if (r != SOAP_EINTR)
5010 { soap_closesock(soap);
5011 soap_set_sender_error(soap, tcp_error(soap), "accept failed in soap_accept()", SOAP_TCP_ERROR);
5012 return SOAP_INVALID_SOCKET;
5013 }
5014 }
5015 }
5016 }
5017 if (soap->accept_timeout)
5018 SOAP_SOCKNONBLOCK(soap->master)
5019 else
5020 SOAP_SOCKBLOCK(soap->master)
5021 soap->socket = soap->faccept(soap, soap->master, (struct sockaddr*)&soap->peer, &n);
5022 soap->peerlen = (size_t)n;
5023 if (soap_valid_socket(soap->socket))
5024 {
5025 #ifdef WITH_IPV6
5026 unsigned int ip1, ip2, ip3, ip4;
5027 char port[16];
5028 getnameinfo((struct sockaddr*)&soap->peer, n, soap->host, sizeof(soap->host), port, 16, NI_NUMERICHOST | NI_NUMERICSERV);
5029 sscanf(soap->host, "%u.%u.%u.%u", &ip1, &ip2, &ip3, &ip4);
5030 soap->ip = (unsigned long)ip1 << 24 | (unsigned long)ip2 << 16 | (unsigned long)ip3 << 8 | (unsigned long)ip4;
5031 soap->port = soap_strtol(port, NULL, 10);
5032 #else
5033 soap->ip = ntohl(soap->peer.sin_addr.s_addr);
5034 #ifdef HAVE_SNPRINTF
5035 soap_snprintf(soap->host, sizeof(soap->host), "%u.%u.%u.%u", (int)(soap->ip>>24)&0xFF, (int)(soap->ip>>16)&0xFF, (int)(soap->ip>>8)&0xFF, (int)soap->ip&0xFF);
5036 #else
5037 sprintf(soap->host, "%u.%u.%u.%u", (int)(soap->ip>>24)&0xFF, (int)(soap->ip>>16)&0xFF, (int)(soap->ip>>8)&0xFF, (int)soap->ip&0xFF);
5038 #endif
5039 soap->port = (int)ntohs(soap->peer.sin_port); /* does not return port number on some systems */
5040 #endif
5041 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Accept socket=%d at port=%d from IP='%s'\n", soap->socket, soap->port, soap->host));
5042 #ifndef WITH_LEAN
5043 if (soap->accept_flags == SO_LINGER)
5044 { struct linger linger;
5045 memset((void*)&linger, 0, sizeof(linger));
5046 linger.l_onoff = 1;
5047 linger.l_linger = soap->linger_time;
5048 if (setsockopt(soap->socket, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(struct linger)))
5049 { soap->errnum = soap_socket_errno(soap->socket);
5050 soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_LINGER failed in soap_accept()", SOAP_TCP_ERROR);
5051 soap_closesock(soap);
5052 return SOAP_INVALID_SOCKET;
5053 }
5054 }
5055 else if (soap->accept_flags && setsockopt(soap->socket, SOL_SOCKET, soap->accept_flags, (char*)&set, sizeof(int)))
5056 { soap->errnum = soap_socket_errno(soap->socket);
5057 soap_set_receiver_error(soap, tcp_error(soap), "setsockopt failed in soap_accept()", SOAP_TCP_ERROR);
5058 soap_closesock(soap);
5059 return SOAP_INVALID_SOCKET;
5060 }
5061 if (((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) && setsockopt(soap->socket, SOL_SOCKET, SO_KEEPALIVE, (char*)&set, sizeof(int)))
5062 { soap->errnum = soap_socket_errno(soap->socket);
5063 soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_KEEPALIVE failed in soap_accept()", SOAP_TCP_ERROR);
5064 soap_closesock(soap);
5065 return SOAP_INVALID_SOCKET;
5066 }
5067 if (setsockopt(soap->socket, SOL_SOCKET, SO_SNDBUF, (char*)&len, sizeof(int)))
5068 { soap->errnum = soap_socket_errno(soap->socket);
5069 soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_SNDBUF failed in soap_accept()", SOAP_TCP_ERROR);
5070 soap_closesock(soap);
5071 return SOAP_INVALID_SOCKET;
5072 }
5073 if (setsockopt(soap->socket, SOL_SOCKET, SO_RCVBUF, (char*)&len, sizeof(int)))
5074 { soap->errnum = soap_socket_errno(soap->socket);
5075 soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_RCVBUF failed in soap_accept()", SOAP_TCP_ERROR);
5076 soap_closesock(soap);
5077 return SOAP_INVALID_SOCKET;
5078 }
5079 #ifdef TCP_NODELAY
5080 if (setsockopt(soap->socket, IPPROTO_TCP, TCP_NODELAY, (char*)&set, sizeof(int)))
5081 { soap->errnum = soap_socket_errno(soap->socket);
5082 soap_set_receiver_error(soap, tcp_error(soap), "setsockopt TCP_NODELAY failed in soap_accept()", SOAP_TCP_ERROR);
5083 soap_closesock(soap);
5084 return SOAP_INVALID_SOCKET;
5085 }
5086 #endif
5087 #endif
5088 soap->keep_alive = (((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) != 0);
5089 if (soap->send_timeout || soap->recv_timeout)
5090 SOAP_SOCKNONBLOCK(soap->socket)
5091 else
5092 SOAP_SOCKBLOCK(soap->socket)
5093 return soap->socket;
5094 }
5095 err = soap_socket_errno(soap->socket);
5096 if (err != 0 && err != SOAP_EINTR && err != SOAP_EAGAIN && err != SOAP_EWOULDBLOCK)
5097 { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Accept failed from %s\n", soap->host));
5098 soap->errnum = err;
5099 soap_set_receiver_error(soap, tcp_error(soap), "accept failed in soap_accept()", SOAP_TCP_ERROR);
5100 soap_closesock(soap);
5101 return SOAP_INVALID_SOCKET;
5102 }
5103 }
5104 }
5105 #endif
5106 #endif
5107
5108 /******************************************************************************/
5109 #ifndef PALM_1
5110 SOAP_FMAC1
5111 int
5112 SOAP_FMAC2
5113 soap_closesock(struct soap *soap)
5114 { register int status = soap->error;
5115 #ifndef WITH_LEANER
5116 if (status) /* close on error: attachment state is not to be trusted */
5117 { soap->mime.first = NULL;
5118 soap->mime.last = NULL;
5119 soap->dime.first = NULL;
5120 soap->dime.last = NULL;
5121 }
5122 #endif
5123 if (soap->fdisconnect && (soap->error = soap->fdisconnect(soap)))
5124 return soap->error;
5125 if (status == SOAP_EOF || status == SOAP_TCP_ERROR || status == SOAP_SSL_ERROR || !soap->keep_alive)
5126 { if (soap->fclose && (soap->error = soap->fclose(soap)))
5127 return soap->error;
5128 soap->keep_alive = 0;
5129 }
5130 #ifdef WITH_ZLIB
5131 if (!(soap->mode & SOAP_MIME_POSTCHECK))
5132 { if (soap->zlib_state == SOAP_ZLIB_DEFLATE)
5133 deflateEnd(soap->d_stream);
5134 else if (soap->zlib_state == SOAP_ZLIB_INFLATE)
5135 inflateEnd(soap->d_stream);
5136 soap->zlib_state = SOAP_ZLIB_NONE;
5137 }
5138 #endif
5139 return soap->error = status;
5140 }
5141 #endif
5142
5143 /******************************************************************************/
5144 #ifndef WITH_NOIO
5145 #ifndef PALM_1
5146 SOAP_FMAC1
5147 int
5148 SOAP_FMAC2
5149 soap_force_closesock(struct soap *soap)
5150 { soap->keep_alive = 0;
5151 if (soap_valid_socket(soap->socket))
5152 return soap_closesocket(soap->socket);
5153 return SOAP_OK;
5154 }
5155 #endif
5156 #endif
5157
5158 /******************************************************************************/
5159 #ifndef WITH_NOIO
5160 #ifndef PALM_2
5161 SOAP_FMAC1
5162 void
5163 SOAP_FMAC2
5164 soap_cleanup(struct soap *soap)
5165 { soap_done(soap);
5166 #ifdef WIN32
5167 if (!tcp_done)
5168 return;
5169 tcp_done = 0;
5170 WSACleanup();
5171 #endif
5172 }
5173 #endif
5174 #endif
5175
5176 /******************************************************************************/
5177 #ifndef PALM_1
5178 SOAP_FMAC1
5179 void
5180 SOAP_FMAC2
5181 soap_done(struct soap *soap)
5182 {
5183 #ifdef SOAP_DEBUG
5184 int i;
5185 #endif
5186 if (soap_check_state(soap))
5187 return;
5188 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Done with context%s\n", soap->state == SOAP_COPY ? " copy" : ""));
5189 soap_free_temp(soap);
5190 while (soap->clist)
5191 { struct soap_clist *p = soap->clist->next;
5192 SOAP_FREE(soap, soap->clist);
5193 soap->clist = p;
5194 }
5195 if (soap->state == SOAP_INIT)
5196 soap->omode &= ~SOAP_IO_UDP; /* to force close the socket */
5197 soap->keep_alive = 0; /* to force close the socket */
5198 if (soap->master == soap->socket) /* do not close twice */
5199 soap->master = SOAP_INVALID_SOCKET;
5200 soap_closesock(soap);
5201 #ifdef WITH_COOKIES
5202 soap_free_cookies(soap);
5203 #endif
5204 while (soap->plugins)
5205 { register struct soap_plugin *p = soap->plugins->next;
5206 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Removing plugin '%s'\n", soap->plugins->id));
5207 if (soap->plugins->fcopy || soap->state == SOAP_INIT)
5208 soap->plugins->fdelete(soap, soap->plugins);
5209 SOAP_FREE(soap, soap->plugins);
5210 soap->plugins = p;
5211 }
5212 soap->fplugin = fplugin;
5213 soap->fmalloc = NULL;
5214 #ifndef WITH_NOHTTP
5215 soap->fpost = http_post;
5216 soap->fget = http_get;
5217 soap->fput = http_405;
5218 soap->fdel = http_405;
5219 soap->fopt = http_200;
5220 soap->fhead = http_200;
5221 soap->fform = NULL;
5222 soap->fposthdr = http_post_header;
5223 soap->fresponse = http_response;
5224 soap->fparse = http_parse;
5225 soap->fparsehdr = http_parse_header;
5226 #endif
5227 soap->fheader = NULL;
5228 #ifndef WITH_NOIO
5229 #ifndef WITH_IPV6
5230 soap->fresolve = tcp_gethost;
5231 #else
5232 soap->fresolve = NULL;
5233 #endif
5234 soap->faccept = tcp_accept;
5235 soap->fopen = tcp_connect;
5236 soap->fclose = tcp_disconnect;
5237 soap->fclosesocket = tcp_closesocket;
5238 soap->fshutdownsocket = tcp_shutdownsocket;
5239 soap->fsend = fsend;
5240 soap->frecv = frecv;
5241 soap->fpoll = soap_poll;
5242 #else
5243 soap->fopen = NULL;
5244 soap->fclose = NULL;
5245 soap->fpoll = NULL;
5246 #endif
5247 #ifndef WITH_LEANER
5248 soap->feltbegin = NULL;
5249 soap->feltendin = NULL;
5250 soap->feltbegout = NULL;
5251 soap->feltendout = NULL;
5252 soap->fprepareinitsend = NULL;
5253 soap->fprepareinitrecv = NULL;
5254 soap->fpreparesend = NULL;
5255 soap->fpreparerecv = NULL;
5256 soap->fpreparefinalsend = NULL;
5257 soap->fpreparefinalrecv = NULL;
5258 soap->ffiltersend = NULL;
5259 soap->ffilterrecv = NULL;
5260 #endif
5261 soap->fseterror = NULL;
5262 soap->fignore = NULL;
5263 soap->fserveloop = NULL;
5264 #ifdef WITH_OPENSSL
5265 if (soap->session)
5266 { SSL_SESSION_free(soap->session);
5267 soap->session = NULL;
5268 }
5269 #endif
5270 if (soap->state == SOAP_INIT)
5271 { if (soap_valid_socket(soap->master))
5272 { soap->fclosesocket(soap, soap->master);
5273 soap->master = SOAP_INVALID_SOCKET;
5274 }
5275 }
5276 #ifdef WITH_OPENSSL
5277 if (soap->ssl)
5278 { SSL_free(soap->ssl);
5279 soap->ssl = NULL;
5280 }
5281 if (soap->state == SOAP_INIT)
5282 { if (soap->ctx)
5283 { SSL_CTX_free(soap->ctx);
5284 soap->ctx = NULL;
5285 }
5286 }
5287 ERR_remove_state(0);
5288 #endif
5289 #ifdef WITH_GNUTLS
5290 if (soap->state == SOAP_INIT)
5291 { if (soap->xcred)
5292 { gnutls_certificate_free_credentials(soap->xcred);
5293 soap->xcred = NULL;
5294 }
5295 if (soap->acred)
5296 { gnutls_anon_free_client_credentials(soap->acred);
5297 soap->acred = NULL;
5298 }
5299 if (soap->cache)
5300 { gnutls_priority_deinit(soap->cache);
5301 soap->cache = NULL;
5302 }
5303 if (soap->dh_params)
5304 { gnutls_dh_params_deinit(soap->dh_params);
5305 soap->dh_params = NULL;
5306 }
5307 if (soap->rsa_params)
5308 { gnutls_rsa_params_deinit(soap->rsa_params);
5309 soap->rsa_params = NULL;
5310 }
5311 }
5312 if (soap->session)
5313 { gnutls_deinit(soap->session);
5314 soap->session = NULL;
5315 }
5316 #endif
5317 #ifdef WITH_C_LOCALE
5318 # ifdef WIN32
5319 _free_locale(soap->c_locale);
5320 # else
5321 freelocale(soap->c_locale);
5322 # endif
5323 #endif
5324 #ifdef WITH_ZLIB
5325 if (soap->d_stream)
5326 { SOAP_FREE(soap, (void*)soap->d_stream);
5327 soap->d_stream = NULL;
5328 }
5329 if (soap->z_buf)
5330 { SOAP_FREE(soap, (void*)soap->z_buf);
5331 soap->z_buf = NULL;
5332 }
5333 #endif
5334 #ifdef SOAP_DEBUG
5335 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free logfiles\n"));
5336 for (i = 0; i < SOAP_MAXLOGS; i++)
5337 { if (soap->logfile[i])
5338 { SOAP_FREE(soap, (void*)soap->logfile[i]);
5339 soap->logfile[i] = NULL;
5340 }
5341 soap_close_logfile(soap, i);
5342 }
5343 soap->state = SOAP_NONE;
5344 #endif
5345 #ifdef SOAP_MEM_DEBUG
5346 soap_free_mht(soap);
5347 #endif
5348 }
5349 #endif
5350
5351 /******************************************************************************\
5352 *
5353 * HTTP
5354 *
5355 \******************************************************************************/
5356
5357 /******************************************************************************/
5358 #ifndef WITH_NOHTTP
5359 #ifndef PALM_1
5360 static int
5361 http_parse(struct soap *soap)
5362 { char header[SOAP_HDRLEN], *s;
5363 unsigned short httpcmd = 0;
5364 int status = 0;
5365 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Waiting for HTTP request/response...\n"));
5366 *soap->endpoint = '\0';
5367 #ifdef WITH_NTLM
5368 if (!soap->ntlm_challenge)
5369 #endif
5370 { soap->userid = NULL;
5371 soap->passwd = NULL;
5372 soap->authrealm = NULL;
5373 }
5374 #ifdef WITH_NTLM
5375 soap->ntlm_challenge = NULL;
5376 #endif
5377 soap->proxy_from = NULL;
5378 do
5379 { soap->length = 0;
5380 soap->http_content = NULL;
5381 soap->action = NULL;
5382 soap->status = 0;
5383 soap->body = 1;
5384 if (soap_getline(soap, soap->msgbuf, sizeof(soap->msgbuf)))
5385 { if (soap->error == SOAP_EOF)
5386 return SOAP_EOF;
5387 return soap->error = 414;
5388 }
5389 if ((s = strchr(soap->msgbuf, ' ')))
5390 { soap->status = (unsigned short)soap_strtoul(s, &s, 10);
5391 if (!soap_blank((soap_wchar)*s))
5392 soap->status = 0;
5393 }
5394 else
5395 soap->status = 0;
5396 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "HTTP status: %s\n", soap->msgbuf));
5397 for (;;)
5398 { if (soap_getline(soap, header, SOAP_HDRLEN))
5399 { if (soap->error == SOAP_EOF)
5400 { soap->error = SOAP_OK;
5401 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "EOF in HTTP header, continue anyway\n"));
5402 break;
5403 }
5404 return soap->error;
5405 }
5406 if (!*header)
5407 break;
5408 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "HTTP header: %s\n", header));
5409 s = strchr(header, ':');
5410 if (s)
5411 { char *t;
5412 *s = '\0';
5413 do s++;
5414 while (*s && *s <= 32);
5415 if (*s == '"')
5416 s++;
5417 t = s + strlen(s) - 1;
5418 while (t > s && *t <= 32)
5419 t--;
5420 if (t >= s && *t == '"')
5421 t--;
5422 t[1] = '\0';
5423 if ((soap->error = soap->fparsehdr(soap, header, s)))
5424 { if (soap->error < SOAP_STOP)
5425 return soap->error;
5426 status = soap->error;
5427 soap->error = SOAP_OK;
5428 }
5429 }
5430 }
5431 } while (soap->status == 100);
5432 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Finished HTTP header parsing, status = %d\n", soap->status));
5433 s = strstr(soap->msgbuf, "HTTP/");
5434 if (s && s[7] != '1')
5435 { if (soap->keep_alive == 1)
5436 soap->keep_alive = 0;
5437 if (soap->status == 0 && (soap->omode & SOAP_IO) == SOAP_IO_CHUNK) /* soap->status == 0 for HTTP request */
5438 soap->omode = (soap->omode & ~SOAP_IO) | SOAP_IO_STORE; /* HTTP 1.0 does not support chunked transfers */
5439 }
5440 if (soap->keep_alive < 0)
5441 soap->keep_alive = 1;
5442 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Keep alive connection = %d\n", soap->keep_alive));
5443 if (soap->status == 0)
5444 { size_t l = 0;
5445 if (s)
5446 { if (!strncmp(soap->msgbuf, "POST ", l = 5))
5447 httpcmd = 1;
5448 else if (!strncmp(soap->msgbuf, "PUT ", l = 4))
5449 httpcmd = 2;
5450 else if (!strncmp(soap->msgbuf, "GET ", l = 4))
5451 httpcmd = 3;
5452 else if (!strncmp(soap->msgbuf, "DELETE ", l = 7))
5453 httpcmd = 4;
5454 else if (!strncmp(soap->msgbuf, "OPTIONS ", l = 8))
5455 httpcmd = 5;
5456 else if (!strncmp(soap->msgbuf, "HEAD ", l = 5))
5457 httpcmd = 6;
5458 }
5459 if (s && httpcmd)
5460 { size_t m = strlen(soap->endpoint);
5461 size_t n = m + (s - soap->msgbuf) - l - 1;
5462 size_t k;
5463 if (n >= sizeof(soap->endpoint))
5464 n = sizeof(soap->endpoint) - 1;
5465 if (m > n)
5466 m = n;
5467 k = n - m + 1;
5468 if (k > sizeof(soap->path))
5469 k = sizeof(soap->path);
5470 strncpy(soap->path, soap->msgbuf + l, k);
5471 soap->path[k - 1] = '\0';
5472 if (*soap->path && *soap->path != '/')
5473 *soap->endpoint = '\0';
5474 strcat(soap->endpoint, soap->path);
5475 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Target endpoint='%s'\n", soap->endpoint));
5476 if (httpcmd > 1)
5477 { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "HTTP %s handler\n", soap->msgbuf));
5478 switch (httpcmd)
5479 { case 2: soap->error = soap->fput(soap); break;
5480 case 3: soap->error = soap->fget(soap); break;
5481 case 4: soap->error = soap->fdel(soap); break;
5482 case 5: soap->error = soap->fopt(soap); break;
5483 case 6: soap->error = soap->fhead(soap); break;
5484 default: soap->error = 405; break;
5485 }
5486 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "HTTP handler return = %d\n", soap->error));
5487 if (soap->error == SOAP_OK)
5488 soap->error = SOAP_STOP; /* prevents further processing */
5489 return soap->error;
5490 }
5491 if (status)
5492 return soap->error = status;
5493 }
5494 else if (status)
5495 return soap->error = status;
5496 else if (s)
5497 return soap->error = 405;
5498 return SOAP_OK;
5499 }
5500 #if 0
5501 if (soap->length > 0 || (soap->http_content && (!soap->keep_alive || soap->recv_timeout)) || (soap->imode & SOAP_IO) == SOAP_IO_CHUNK)
5502 #endif
5503 if (soap->body)
5504 { if ((soap->status >= 200 && soap->status <= 299) /* OK, Accepted, etc */
5505 || soap->status == 400 /* Bad Request */
5506 || soap->status == 500) /* Internal Server Error */
5507 return SOAP_OK;
5508 /* force close afterwards in soap_closesock() */
5509 soap->keep_alive = 0;
5510 #ifndef WITH_LEAN
5511 /* read HTTP body for error details */
5512 s = soap_get_http_body(soap, NULL);
5513 if (s)
5514 return soap_set_receiver_error(soap, soap->msgbuf, s, soap->status);
5515 #endif
5516 }
5517 else if (soap->status >= 200 && soap->status <= 299)
5518 return soap->error = soap->status;
5519 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "HTTP error %d\n", soap->status));
5520 return soap_set_receiver_error(soap, "HTTP Error", soap->msgbuf, soap->status);
5521 }
5522 #endif
5523 #endif
5524
5525 /******************************************************************************/
5526 #ifndef WITH_NOHTTP
5527 #ifndef PALM_1
5528 static int
5529 http_parse_header(struct soap *soap, const char *key, const char *val)
5530 { if (!soap_tag_cmp(key, "Host"))
5531 {
5532 #if defined(WITH_OPENSSL) || defined(WITH_GNUTLS)
5533 if (soap->imode & SOAP_ENC_SSL)
5534 strcpy(soap->endpoint, "https://");
5535 else
5536 #endif
5537 strcpy(soap->endpoint, "http://");
5538 strncat(soap->endpoint, val, sizeof(soap->endpoint) - 8);
5539 }
5540 #ifndef WITH_LEANER
5541 else if (!soap_tag_cmp(key, "Content-Type"))
5542 { const char *action;
5543 soap->http_content = soap_strdup(soap, val);
5544 if (soap_get_header_attribute(soap, val, "application/dime"))
5545 soap->imode |= SOAP_ENC_DIME;
5546 else if (soap_get_header_attribute(soap, val, "multipart/related")
5547 || soap_get_header_attribute(soap, val, "multipart/form-data"))
5548 { soap->mime.boundary = soap_strdup(soap, soap_get_header_attribute(soap, val, "boundary"));
5549 soap->mime.start = soap_strdup(soap, soap_get_header_attribute(soap, val, "start"));
5550 soap->imode |= SOAP_ENC_MIME;
5551 }
5552 action = soap_get_header_attribute(soap, val, "action");
5553 if (action)
5554 { if (*action == '"')
5555 { soap->action = soap_strdup(soap, action + 1);
5556 if (*soap->action)
5557 soap->action[strlen(soap->action) - 1] = '\0';
5558 }
5559 else
5560 soap->action = soap_strdup(soap, action);
5561 }
5562 }
5563 #endif
5564 else if (!soap_tag_cmp(key, "Content-Length"))
5565 { soap->length = soap_strtoul(val, NULL, 10);
5566 if (!soap->length)
5567 soap->body = 0;
5568 }
5569 else if (!soap_tag_cmp(key, "Content-Encoding"))
5570 { if (!soap_tag_cmp(val, "deflate"))
5571 #ifdef WITH_ZLIB
5572 soap->zlib_in = SOAP_ZLIB_DEFLATE;
5573 #else
5574 return SOAP_ZLIB_ERROR;
5575 #endif
5576 else if (!soap_tag_cmp(val, "gzip"))
5577 #ifdef WITH_GZIP
5578 soap->zlib_in = SOAP_ZLIB_GZIP;
5579 #else
5580 return SOAP_ZLIB_ERROR;
5581 #endif
5582 }
5583 #ifdef WITH_ZLIB
5584 else if (!soap_tag_cmp(key, "Accept-Encoding"))
5585 {
5586 #ifdef WITH_GZIP
5587 if (strchr(val, '*') || soap_get_header_attribute(soap, val, "gzip"))
5588 soap->zlib_out = SOAP_ZLIB_GZIP;
5589 else
5590 #endif
5591 if (strchr(val, '*') || soap_get_header_attribute(soap, val, "deflate"))
5592 soap->zlib_out = SOAP_ZLIB_DEFLATE;
5593 else
5594 soap->zlib_out = SOAP_ZLIB_NONE;
5595 }
5596 #endif
5597 else if (!soap_tag_cmp(key, "Transfer-Encoding"))
5598 { soap->imode &= ~SOAP_IO;
5599 if (!soap_tag_cmp(val, "chunked"))
5600 soap->imode |= SOAP_IO_CHUNK;
5601 }
5602 else if (!soap_tag_cmp(key, "Connection"))
5603 { if (!soap_tag_cmp(val, "keep-alive"))
5604 soap->keep_alive = -soap->keep_alive;
5605 else if (!soap_tag_cmp(val, "close"))
5606 soap->keep_alive = 0;
5607 }
5608 #ifndef WITH_LEAN
5609 else if (!soap_tag_cmp(key, "Authorization") || !soap_tag_cmp(key, "Proxy-Authorization"))
5610 {
5611 #ifdef WITH_NTLM
5612 if (!soap_tag_cmp(val, "NTLM*"))
5613 soap->ntlm_challenge = soap_strdup(soap, val + 4);
5614 else
5615 #endif
5616 if (!soap_tag_cmp(val, "Basic *"))
5617 { int n;
5618 char *s;
5619 soap_base642s(soap, val + 6, soap->tmpbuf, sizeof(soap->tmpbuf) - 1, &n);
5620 soap->tmpbuf[n] = '\0';
5621 if ((s = strchr(soap->tmpbuf, ':')))
5622 { *s = '\0';
5623 soap->userid = soap_strdup(soap, soap->tmpbuf);
5624 soap->passwd = soap_strdup(soap, s + 1);
5625 }
5626 }
5627 }
5628 else if (!soap_tag_cmp(key, "WWW-Authenticate") || !soap_tag_cmp(key, "Proxy-Authenticate"))
5629 {
5630 #ifdef WITH_NTLM
5631 if (!soap_tag_cmp(val, "NTLM*"))
5632 soap->ntlm_challenge = soap_strdup(soap, val + 4);
5633 else
5634 #endif
5635 soap->authrealm = soap_strdup(soap, soap_get_header_attribute(soap, val + 6, "realm"));
5636 }
5637 else if (!soap_tag_cmp(key, "Expect"))
5638 { if (!soap_tag_cmp(val, "100-continue"))
5639 { if ((soap->error = soap->fposthdr(soap, "HTTP/1.1 100 Continue", NULL))
5640 || (soap->error = soap->fposthdr(soap, NULL, NULL)))
5641 return soap->error;
5642 }
5643 }
5644 #endif
5645 else if (!soap_tag_cmp(key, "SOAPAction"))
5646 { if (*val == '"')
5647 { soap->action = soap_strdup(soap, val + 1);
5648 if (*soap->action)
5649 soap->action[strlen(soap->action) - 1] = '\0';
5650 }
5651 else
5652 soap->action = soap_strdup(soap, val);
5653 }
5654 else if (!soap_tag_cmp(key, "Location"))
5655 { strncpy(soap->endpoint, val, sizeof(soap->endpoint));
5656 soap->endpoint[sizeof(soap->endpoint) - 1] = '\0';
5657 }
5658 else if (!soap_tag_cmp(key, "X-Forwarded-For"))
5659 { soap->proxy_from = soap_strdup(soap, val);
5660 }
5661 #ifdef WITH_COOKIES
5662 else if (!soap_tag_cmp(key, "Cookie")
5663 || !soap_tag_cmp(key, "Cookie2")
5664 || !soap_tag_cmp(key, "Set-Cookie")
5665 || !soap_tag_cmp(key, "Set-Cookie2"))
5666 { soap_getcookies(soap, val);
5667 }
5668 #endif
5669 return SOAP_OK;
5670 }
5671 #endif
5672 #endif
5673
5674 /******************************************************************************/
5675 #if !defined(WITH_NOHTTP) || !defined(WITH_LEANER)
5676 #ifndef PALM_1
5677 SOAP_FMAC1
5678 const char*
5679 SOAP_FMAC2
5680 soap_get_header_attribute(struct soap *soap, const char *line, const char *key)
5681 { register const char *s = line;
5682 if (s)
5683 { while (*s)
5684 { register short flag;
5685 s = soap_decode_key(soap->tmpbuf, sizeof(soap->tmpbuf), s);
5686 flag = soap_tag_cmp(soap->tmpbuf, key);
5687 s = soap_decode_val(soap->tmpbuf, sizeof(soap->tmpbuf), s);
5688 if (!flag)
5689 return soap->tmpbuf;
5690 }
5691 }
5692 return NULL;
5693 }
5694 #endif
5695 #endif
5696
5697 /******************************************************************************/
5698 #if !defined(WITH_NOHTTP) || !defined(WITH_LEANER)
5699 #ifndef PALM_1
5700 SOAP_FMAC1
5701 const char*
5702 SOAP_FMAC2
5703 soap_decode_key(char *buf, size_t len, const char *val)
5704 { return soap_decode(buf, len, val, "=,;");
5705 }
5706 #endif
5707 #endif
5708
5709 /******************************************************************************/
5710 #if !defined(WITH_NOHTTP) || !defined(WITH_LEANER)
5711 #ifndef PALM_1
5712 SOAP_FMAC1
5713 const char*
5714 SOAP_FMAC2
5715 soap_decode_val(char *buf, size_t len, const char *val)
5716 { if (*val != '=')
5717 { *buf = '\0';
5718 return val;
5719 }
5720 return soap_decode(buf, len, val + 1, ",;");
5721 }
5722 #endif
5723 #endif
5724
5725 /******************************************************************************/
5726 #if !defined(WITH_NOHTTP) || !defined(WITH_LEANER)
5727 #ifndef PALM_1
5728 static const char*
5729 soap_decode(char *buf, size_t len, const char *val, const char *sep)
5730 { const char *s;
5731 char *t = buf;
5732 size_t i = len;
5733 for (s = val; *s; s++)
5734 if (*s != ' ' && *s != '\t' && !strchr(sep, *s))
5735 break;
5736 if (len > 0)
5737 { if (*s == '"')
5738 { s++;
5739 while (*s && *s != '"' && --i)
5740 *t++ = *s++;
5741 }
5742 else
5743 { while (*s && !soap_blank((soap_wchar)*s) && !strchr(sep, *s) && --i)
5744 { if (*s == '%' && s[1] && s[2])
5745 { *t++ = ((s[1] >= 'A' ? (s[1] & 0x7) + 9 : s[1] - '0') << 4)
5746 + (s[2] >= 'A' ? (s[2] & 0x7) + 9 : s[2] - '0');
5747 s += 3;
5748 }
5749 else
5750 *t++ = *s++;
5751 }
5752 }
5753 buf[len - 1] = '\0'; /* appease */
5754 }
5755 *t = '\0';
5756 while (*s && !strchr(sep, *s))
5757 s++;
5758 return s;
5759 }
5760 #endif
5761 #endif
5762
5763 /******************************************************************************/
5764 #ifndef WITH_NOHTTP
5765 #ifndef PALM_1
5766 static const char*
5767 http_error(struct soap *soap, int status)
5768 { register const char *msg = SOAP_STR_EOS;
5769 (void)soap;
5770 #ifndef WITH_LEAN
5771 msg = soap_code_str(h_http_error_codes, status);
5772 if (!msg)
5773 msg = SOAP_STR_EOS;
5774 #endif
5775 return msg;
5776 }
5777 #endif
5778 #endif
5779
5780 /******************************************************************************/
5781
5782 #ifndef WITH_NOHTTP
5783 #ifndef PALM_1
5784 static int
5785 http_get(struct soap *soap)
5786 { (void)soap;
5787 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "HTTP GET request\n"));
5788 return SOAP_GET_METHOD;
5789 }
5790 #endif
5791 #endif
5792
5793 /******************************************************************************/
5794 #ifndef WITH_NOHTTP
5795 #ifndef PALM_1
5796 static int
5797 http_405(struct soap *soap)
5798 { (void)soap;
5799 return 405;
5800 }
5801 #endif
5802 #endif
5803
5804 /******************************************************************************/
5805 #ifndef WITH_NOHTTP
5806 #ifndef PALM_1
5807 static int
5808 http_200(struct soap *soap)
5809 { return soap_send_empty_response(soap, 200);
5810 }
5811 #endif
5812 #endif
5813
5814 /******************************************************************************/
5815 #ifndef WITH_NOHTTP
5816 #ifndef PALM_1
5817 static int
5818 http_post(struct soap *soap, const char *endpoint, const char *host, int port, const char *path, const char *action, size_t count)
5819 { register const char *s;
5820 register int err;
5821 switch (soap->status)
5822 { case SOAP_GET:
5823 s = "GET";
5824 break;
5825 case SOAP_PUT:
5826 s = "PUT";
5827 break;
5828 case SOAP_DEL:
5829 s = "DELETE";
5830 break;
5831 case SOAP_CONNECT:
5832 s = "CONNECT";
5833 break;
5834 default:
5835 s = "POST";
5836 }
5837 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "HTTP %s to %s\n", s, endpoint ? endpoint : "(null)"));
5838 #ifdef PALM
5839 if (!endpoint || (soap_tag_cmp(endpoint, "http:*") && soap_tag_cmp(endpoint, "https:*") && strncmp(endpoint, "httpg:", 6)) && strncmp(endpoint, "_beam:", 6) && strncmp(endpoint, "_local:", 7) && strncmp(endpoint, "_btobex:", 8))
5840 #else
5841 if (!endpoint || (soap_tag_cmp(endpoint, "http:*") && soap_tag_cmp(endpoint, "https:*") && strncmp(endpoint, "httpg:", 6)))
5842 #endif
5843 return SOAP_OK;
5844 if (strlen(endpoint) + strlen(soap->http_version) > sizeof(soap->tmpbuf) - 80
5845 || strlen(host) + strlen(soap->http_version) > sizeof(soap->tmpbuf) - 80)
5846 return soap->error = SOAP_EOM; /* prevent overrun (note that 'host' and 'soap->host' are substrings of 'endpoint') */
5847 if (soap->status == SOAP_CONNECT)
5848 {
5849 #ifdef HAVE_SNPRINTF
5850 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), "%s %s:%d HTTP/%s", s, soap->host, soap->port, soap->http_version);
5851 #else
5852 sprintf(soap->tmpbuf, "%s %s:%d HTTP/%s", s, soap->host, soap->port, soap->http_version);
5853 #endif
5854 }
5855 else if (soap->proxy_host && endpoint)
5856 {
5857 #ifdef HAVE_SNPRINTF
5858 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), "%s %s HTTP/%s", s, endpoint, soap->http_version);
5859 #else
5860 sprintf(soap->tmpbuf, "%s %s HTTP/%s", s, endpoint, soap->http_version);
5861 #endif
5862 }
5863 else
5864 {
5865 #ifdef HAVE_SNPRINTF
5866 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), "%s /%s HTTP/%s", s, (*path == '/' ? path + 1 : path), soap->http_version);
5867 #else
5868 sprintf(soap->tmpbuf, "%s /%s HTTP/%s", s, (*path == '/' ? path + 1 : path), soap->http_version);
5869 #endif
5870 }
5871 if ((err = soap->fposthdr(soap, soap->tmpbuf, NULL)))
5872 return err;
5873 #ifdef WITH_OPENSSL
5874 if ((soap->ssl && port != 443) || (!soap->ssl && port != 80))
5875 #else
5876 if (port != 80)
5877 #endif
5878 {
5879 #ifdef WITH_IPV6
5880 if (*host != '[' && strchr(host, ':'))
5881 {
5882 #ifdef HAVE_SNPRINTF
5883 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), "[%s]:%d", host, port); /* RFC 2732 */
5884 #else
5885 sprintf(soap->tmpbuf, "[%s]:%d", host, port); /* RFC 2732 */
5886 #endif
5887 }
5888 else
5889 #endif
5890 {
5891 #ifdef HAVE_SNPRINTF
5892 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), "%s:%d", host, port);
5893 #else
5894 sprintf(soap->tmpbuf, "%s:%d", host, port);
5895 #endif
5896 }
5897 }
5898 else
5899 {
5900 #ifdef WITH_IPV6
5901 if (*host != '[' && strchr(host, ':'))
5902 {
5903 #ifdef HAVE_SNPRINTF
5904 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), "[%s]", host); /* RFC 2732 */
5905 #else
5906 sprintf(soap->tmpbuf, "[%s]", host); /* RFC 2732 */
5907 #endif
5908 }
5909 else
5910 #endif
5911 strcpy(soap->tmpbuf, host);
5912 }
5913 if ((err = soap->fposthdr(soap, "Host", soap->tmpbuf)))
5914 return err;
5915 if ((err = soap->fposthdr(soap, "User-Agent", "gSOAP/2.8")))
5916 return err;
5917 if ((err = soap_puthttphdr(soap, SOAP_OK, count)))
5918 return err;
5919 #ifdef WITH_ZLIB
5920 #ifdef WITH_GZIP
5921 if ((err = soap->fposthdr(soap, "Accept-Encoding", "gzip, deflate")))
5922 #else
5923 if ((err = soap->fposthdr(soap, "Accept-Encoding", "deflate")))
5924 #endif
5925 return err;
5926 #endif
5927 #ifndef WITH_LEAN
5928 #ifdef WITH_NTLM
5929 if (soap->ntlm_challenge && strlen(soap->ntlm_challenge) + 6 < sizeof(soap->tmpbuf))
5930 { if (*soap->ntlm_challenge)
5931 {
5932 #ifdef HAVE_SNPRINTF
5933 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), "NTLM %s", soap->ntlm_challenge);
5934 #else
5935 sprintf(soap->tmpbuf, "NTLM %s", soap->ntlm_challenge);
5936 #endif
5937 if (soap->proxy_host)
5938 { if ((err = soap->fposthdr(soap, "Proxy-Authorization", soap->tmpbuf)))
5939 return err;
5940 }
5941 else if ((err = soap->fposthdr(soap, "Authorization", soap->tmpbuf)))
5942 return err;
5943 }
5944 }
5945 else
5946 {
5947 #endif
5948 if (soap->userid && soap->passwd && strlen(soap->userid) + strlen(soap->passwd) < 761)
5949 { strcpy(soap->tmpbuf, "Basic ");
5950 #ifdef HAVE_SNPRINTF
5951 soap_snprintf(soap->tmpbuf + 262, sizeof(soap->tmpbuf) - 262, "%s:%s", soap->userid, soap->passwd);
5952 #else
5953 sprintf(soap->tmpbuf + 262, "%s:%s", soap->userid, soap->passwd);
5954 #endif
5955 soap_s2base64(soap, (const unsigned char*)(soap->tmpbuf + 262), soap->tmpbuf + 6, (int)strlen(soap->tmpbuf + 262));
5956 if ((err = soap->fposthdr(soap, "Authorization", soap->tmpbuf)))
5957 return err;
5958 }
5959 if (soap->proxy_userid && soap->proxy_passwd && strlen(soap->proxy_userid) + strlen(soap->proxy_passwd) < 761)
5960 { strcpy(soap->tmpbuf, "Basic ");
5961 #ifdef HAVE_SNPRINTF
5962 soap_snprintf(soap->tmpbuf + 262, sizeof(soap->tmpbuf) - 262, "%s:%s", soap->proxy_userid, soap->proxy_passwd);
5963 #else
5964 sprintf(soap->tmpbuf + 262, "%s:%s", soap->proxy_userid, soap->proxy_passwd);
5965 #endif
5966 soap_s2base64(soap, (const unsigned char*)(soap->tmpbuf + 262), soap->tmpbuf + 6, (int)strlen(soap->tmpbuf + 262));
5967 if ((err = soap->fposthdr(soap, "Proxy-Authorization", soap->tmpbuf)))
5968 return err;
5969 }
5970 #ifdef WITH_NTLM
5971 }
5972 #endif
5973 #endif
5974 #ifdef WITH_COOKIES
5975 #ifdef WITH_OPENSSL
5976 if (soap_putcookies(soap, host, path, soap->ssl != NULL))
5977 return soap->error;
5978 #else
5979 if (soap_putcookies(soap, host, path, 0))
5980 return soap->error;
5981 #endif
5982 #endif
5983 if (action && soap->status != SOAP_GET && soap->status != SOAP_DEL)
5984 {
5985 #ifdef HAVE_SNPRINTF
5986 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), "\"%s\"", action);
5987 #else
5988 sprintf(soap->tmpbuf, "\"%s\"", strlen(action) < sizeof(soap->tmpbuf) - 3 ? action : SOAP_STR_EOS);
5989 #endif
5990 if ((err = soap->fposthdr(soap, "SOAPAction", soap->tmpbuf)))
5991 return err;
5992 }
5993 return soap->fposthdr(soap, NULL, NULL);
5994 }
5995 #endif
5996 #endif
5997
5998 /******************************************************************************/
5999 #ifndef WITH_NOHTTP
6000 #ifndef PALM_1
6001 static int
6002 http_send_header(struct soap *soap, const char *s)
6003 { register const char *t;
6004 do
6005 { t = strchr(s, '\n'); /* disallow \n in HTTP headers */
6006 if (!t)
6007 t = s + strlen(s);
6008 if (soap_send_raw(soap, s, t - s))
6009 return soap->error;
6010 s = t + 1;
6011 } while (*t);
6012 return SOAP_OK;
6013 }
6014 #endif
6015 #endif
6016
6017 /******************************************************************************/
6018 #ifndef WITH_NOHTTP
6019 #ifndef PALM_1
6020 static int
6021 http_post_header(struct soap *soap, const char *key, const char *val)
6022 { if (key)
6023 { if (http_send_header(soap, key))
6024 return soap->error;
6025 if (val && (soap_send_raw(soap, ": ", 2) || http_send_header(soap, val)))
6026 return soap->error;
6027 }
6028 return soap_send_raw(soap, "\r\n", 2);
6029 }
6030 #endif
6031 #endif
6032
6033 /******************************************************************************/
6034 #ifndef WITH_NOHTTP
6035 #ifndef PALM_1
6036 static int
6037 http_response(struct soap *soap, int status, size_t count)
6038 { register int err;
6039 char http[10];
6040 int code = status;
6041 const char *line;
6042 #ifdef WMW_RPM_IO
6043 if (soap->rpmreqid)
6044 httpOutputEnable(soap->rpmreqid);
6045 #endif
6046 if (!soap->http_version || strlen(soap->http_version) > 4)
6047 return soap->error = SOAP_EOM;
6048 #ifdef WMW_RPM_IO
6049 if (soap->rpmreqid || soap_valid_socket(soap->master) || soap_valid_socket(soap->socket)) /* RPM behaves as if standalone */
6050 #else
6051 if (soap_valid_socket(soap->master) || soap_valid_socket(soap->socket)) /* standalone application (socket) or CGI (stdin/out)? */
6052 #endif
6053 {
6054 #ifdef HAVE_SNPRINTF
6055 soap_snprintf(http, sizeof(http), "HTTP/%s", soap->http_version);
6056 #else
6057 sprintf(http, "HTTP/%s", soap->http_version);
6058 #endif
6059 }
6060 else
6061 strcpy(http, "Status:");
6062 if (!status || status == SOAP_HTML || status == SOAP_FILE)
6063 { if (count || ((soap->omode & SOAP_IO) == SOAP_IO_CHUNK))
6064 code = 200;
6065 else
6066 code = 202;
6067 }
6068 else if (status < 200 || status >= 600)
6069 { const char *s = *soap_faultcode(soap);
6070 if (status >= SOAP_GET_METHOD && status <= SOAP_HTTP_METHOD)
6071 code = 405;
6072 else if (soap->version == 2 && (!s || !strcmp(s, "SOAP-ENV:Sender")))
6073 code = 400;
6074 else
6075 code = 500;
6076 }
6077 line = http_error(soap, code);
6078 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "HTTP Status = %d %s\n", code, line));
6079 #ifdef HAVE_SNPRINTF
6080 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), "%s %d %s", http, code, line);
6081 #else
6082 sprintf(soap->tmpbuf, "%s %d %s", http, code, line);
6083 #endif
6084 if ((err = soap->fposthdr(soap, soap->tmpbuf, NULL)))
6085 return err;
6086 #ifndef WITH_LEAN
6087 if (status == 401)
6088 {
6089 #ifdef HAVE_SNPRINTF
6090 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), "Basic realm=\"%s\"", (soap->authrealm && strlen(soap->authrealm) < sizeof(soap->tmpbuf) - 14) ? soap->authrealm : "gSOAP Web Service");
6091 #else
6092 sprintf(soap->tmpbuf, "Basic realm=\"%s\"", (soap->authrealm && strlen(soap->authrealm) < sizeof(soap->tmpbuf) - 14) ? soap->authrealm : "gSOAP Web Service");
6093 #endif
6094 if ((err = soap->fposthdr(soap, "WWW-Authenticate", soap->tmpbuf)))
6095 return err;
6096 }
6097 else if ((status >= 301 && status <= 303) || status == 307)
6098 { if ((err = soap->fposthdr(soap, "Location", soap->endpoint)))
6099 return err;
6100 }
6101 #endif
6102 if ((err = soap->fposthdr(soap, "Server", "gSOAP/2.8"))
6103 || (err = soap_puthttphdr(soap, status, count)))
6104 return err;
6105 #ifdef WITH_COOKIES
6106 if (soap_putsetcookies(soap))
6107 return soap->error;
6108 #endif
6109 return soap->fposthdr(soap, NULL, NULL);
6110 }
6111 #endif
6112 #endif
6113
6114 /******************************************************************************/
6115 #ifndef PALM_1
6116 SOAP_FMAC1
6117 int
6118 SOAP_FMAC2
6119 soap_response(struct soap *soap, int status)
6120 { register size_t count;
6121 if (!(soap->omode & (SOAP_ENC_XML | SOAP_IO_STORE /* this tests for chunking too */))
6122 && (status == SOAP_HTML || status == SOAP_FILE))
6123 soap->omode = (soap->omode & ~SOAP_IO) | SOAP_IO_STORE;
6124 soap->status = status;
6125 count = soap_count_attachments(soap);
6126 if (soap_begin_send(soap))
6127 return soap->error;
6128 #ifndef WITH_NOHTTP
6129 if ((soap->mode & SOAP_IO) != SOAP_IO_STORE && !(soap->mode & SOAP_ENC_XML))
6130 { register int n = soap->mode;
6131 soap->mode &= ~(SOAP_IO | SOAP_ENC_ZLIB);
6132 if ((n & SOAP_IO) != SOAP_IO_FLUSH)
6133 soap->mode |= SOAP_IO_BUFFER;
6134 if ((soap->error = soap->fresponse(soap, status, count)))
6135 return soap->error;
6136 #ifndef WITH_LEANER
6137 if ((n & SOAP_IO) == SOAP_IO_CHUNK)
6138 { if (soap_flush(soap))
6139 return soap->error;
6140 }
6141 #endif
6142 soap->mode = n;
6143 }
6144 #endif
6145 return SOAP_OK;
6146 }
6147 #endif
6148
6149 /******************************************************************************/
6150 #ifndef PALM_1
6151 SOAP_FMAC1
6152 const char*
6153 SOAP_FMAC2
6154 soap_url(struct soap *soap, const char *s, const char *t)
6155 { if (!t || (*t != '/' && *t != '?') || strlen(s) + strlen(t) >= sizeof(soap->msgbuf))
6156 return s;
6157 strcpy(soap->msgbuf, s);
6158 strcat(soap->msgbuf, t);
6159 return soap->msgbuf;
6160 }
6161 #endif
6162
6163 /******************************************************************************/
6164 #ifndef PALM_1
6165 SOAP_FMAC1
6166 size_t
6167 SOAP_FMAC2
6168 soap_encode_url(const char *s, char *t, size_t len)
6169 { register int c;
6170 register size_t n = len;
6171 while ((c = *s++) && --n > 0)
6172 { if (c > ' ' && c < 128 && !strchr("()<>@,;:\\\"/[]?={}#!$&'*+", c))
6173 *t++ = c;
6174 else if (n > 2)
6175 { *t++ = '%';
6176 *t++ = (c >> 4) + (c > 159 ? '7' : '0');
6177 c &= 0xF;
6178 *t++ = c + (c > 9 ? '7' : '0');
6179 n -= 2;
6180 }
6181 else
6182 break;
6183 }
6184 *t = '\0';
6185 return len - n;
6186 }
6187 #endif
6188
6189 /******************************************************************************/
6190 #ifndef PALM_1
6191 SOAP_FMAC1
6192 const char*
6193 SOAP_FMAC2
6194 soap_encode_url_string(struct soap *soap, const char *s)
6195 { if (s)
6196 { size_t n = 3*strlen(s)+1;
6197 char *t = (char*)soap_malloc(soap, n);
6198 if (t)
6199 { soap_encode_url(s, t, n);
6200 return t;
6201 }
6202 }
6203 return SOAP_STR_EOS;
6204 }
6205 #endif
6206
6207 /******************************************************************************\
6208 *
6209 * HTTP Cookies
6210 *
6211 \******************************************************************************/
6212
6213 #ifdef WITH_COOKIES
6214 /******************************************************************************/
6215 SOAP_FMAC1
6216 struct soap_cookie*
6217 SOAP_FMAC2
6218 soap_cookie(struct soap *soap, const char *name, const char *domain, const char *path)
6219 { struct soap_cookie *p;
6220 if (!domain)
6221 domain = soap->cookie_domain;
6222 if (!path)
6223 path = soap->cookie_path;
6224 if (!path)
6225 path = SOAP_STR_EOS;
6226 else if (*path == '/')
6227 path++;
6228 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Search cookie='%s' domain='%s' path='%s'\n", name, domain ? domain : "(null)", path ? path : "(null)"));
6229 for (p = soap->cookies; p; p = p->next)
6230 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Cookie in database: %s='%s' domain='%s' path='%s' env=%hd\n", p->name, p->value ? p->value : "(null)", p->domain ? p->domain : "(null)", p->path ? p->path : "(null)", p->env));
6231 if (!strcmp(p->name, name)
6232 && p->domain
6233 && p->path
6234 && !strcmp(p->domain, domain)
6235 && (!*p->path || !strncmp(p->path, path, strlen(p->path))))
6236 break;
6237 }
6238 return p;
6239 }
6240
6241 /******************************************************************************/
6242 SOAP_FMAC1
6243 struct soap_cookie*
6244 SOAP_FMAC2
6245 soap_set_cookie(struct soap *soap, const char *name, const char *value, const char *domain, const char *path)
6246 { struct soap_cookie **p, *q;
6247 int n;
6248 if (!domain)
6249 domain = soap->cookie_domain;
6250 if (!path)
6251 path = soap->cookie_path;
6252 if (!path)
6253 path = SOAP_STR_EOS;
6254 else if (*path == '/')
6255 path++;
6256 q = soap_cookie(soap, name, domain, path);
6257 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Set %scookie: %s='%s' domain='%s' path='%s'\n", q ? SOAP_STR_EOS : "new ", name, value ? value : "(null)", domain ? domain : "(null)", path ? path : "(null)"));
6258 if (!q)
6259 { if ((q = (struct soap_cookie*)SOAP_MALLOC(soap, sizeof(struct soap_cookie))))
6260 { if ((q->name = (char*)SOAP_MALLOC(soap, strlen(name)+1)))
6261 strcpy(q->name, name);
6262 q->value = NULL;
6263 q->domain = NULL;
6264 q->path = NULL;
6265 q->expire = 0;
6266 q->maxage = -1;
6267 q->version = 1;
6268 q->secure = 0;
6269 q->modified = 0;
6270 for (p = &soap->cookies, n = soap->cookie_max; *p && n; p = &(*p)->next, n--)
6271 if (!strcmp((*p)->name, name) && (*p)->path && path && strcmp((*p)->path, path) < 0)
6272 break;
6273 if (n)
6274 { q->next = *p;
6275 *p = q;
6276 }
6277 else
6278 { SOAP_FREE(soap, q->name);
6279 SOAP_FREE(soap, q);
6280 q = NULL;
6281 }
6282 }
6283 }
6284 else
6285 q->modified = 1;
6286 if (q)
6287 { if (q->value)
6288 { if (!value || strcmp(value, q->value))
6289 { SOAP_FREE(soap, q->value);
6290 q->value = NULL;
6291 }
6292 }
6293 if (value && *value && !q->value && (q->value = (char*)SOAP_MALLOC(soap, strlen(value)+1)))
6294 strcpy(q->value, value);
6295 if (q->domain)
6296 { if (!domain || strcmp(domain, q->domain))
6297 { SOAP_FREE(soap, q->domain);
6298 q->domain = NULL;
6299 }
6300 }
6301 if (domain && !q->domain && (q->domain = (char*)SOAP_MALLOC(soap, strlen(domain)+1)))
6302 strcpy(q->domain, domain);
6303 if (q->path)
6304 { if (!path || strncmp(path, q->path, strlen(q->path)))
6305 { SOAP_FREE(soap, q->path);
6306 q->path = NULL;
6307 }
6308 }
6309 if (path && !q->path && (q->path = (char*)SOAP_MALLOC(soap, strlen(path)+1)))
6310 strcpy(q->path, path);
6311 q->session = 1;
6312 q->env = 0;
6313 }
6314 return q;
6315 }
6316
6317 /******************************************************************************/
6318 SOAP_FMAC1
6319 void
6320 SOAP_FMAC2
6321 soap_clr_cookie(struct soap *soap, const char *name, const char *domain, const char *path)
6322 { struct soap_cookie **p, *q;
6323 if (!domain)
6324 domain = soap->cookie_domain;
6325 if (!domain)
6326 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Error in clear cookie='%s': cookie domain not set\n", name ? name : "(null)"));
6327 return;
6328 }
6329 if (!path)
6330 path = soap->cookie_path;
6331 if (!path)
6332 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Error in clear cookie='%s': cookie path not set\n", name ? name : "(null)"));
6333 return;
6334 }
6335 if (*path == '/')
6336 path++;
6337 for (p = &soap->cookies, q = *p; q; q = *p)
6338 { if (!strcmp(q->name, name) && !strcmp(q->domain, domain) && !strncmp(q->path, path, strlen(q->path)))
6339 { if (q->value)
6340 SOAP_FREE(soap, q->value);
6341 if (q->domain)
6342 SOAP_FREE(soap, q->domain);
6343 if (q->path)
6344 SOAP_FREE(soap, q->path);
6345 *p = q->next;
6346 SOAP_FREE(soap, q);
6347 }
6348 else
6349 p = &q->next;
6350 }
6351 }
6352
6353 /******************************************************************************/
6354 SOAP_FMAC1
6355 char *
6356 SOAP_FMAC2
6357 soap_cookie_value(struct soap *soap, const char *name, const char *domain, const char *path)
6358 { struct soap_cookie *p;
6359 if ((p = soap_cookie(soap, name, domain, path)))
6360 return p->value;
6361 return NULL;
6362 }
6363
6364 /******************************************************************************/
6365 SOAP_FMAC1
6366 char *
6367 SOAP_FMAC2
6368 soap_env_cookie_value(struct soap *soap, const char *name, const char *domain, const char *path)
6369 { struct soap_cookie *p;
6370 if ((p = soap_cookie(soap, name, domain, path)) && p->env)
6371 return p->value;
6372 return NULL;
6373 }
6374
6375 /******************************************************************************/
6376 SOAP_FMAC1
6377 time_t
6378 SOAP_FMAC2
6379 soap_cookie_expire(struct soap *soap, const char *name, const char *domain, const char *path)
6380 { struct soap_cookie *p;
6381 if ((p = soap_cookie(soap, name, domain, path)))
6382 return p->expire;
6383 return -1;
6384 }
6385
6386 /******************************************************************************/
6387 SOAP_FMAC1
6388 int
6389 SOAP_FMAC2
6390 soap_set_cookie_expire(struct soap *soap, const char *name, long expire, const char *domain, const char *path)
6391 { struct soap_cookie *p;
6392 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Set cookie expiration max-age=%ld: cookie='%s' domain='%s' path='%s'\n", expire, name, domain ? domain : "(null)", path ? path : "(null)"));
6393 if ((p = soap_cookie(soap, name, domain, path)))
6394 { p->maxage = expire;
6395 p->modified = 1;
6396 return SOAP_OK;
6397 }
6398 return SOAP_ERR;
6399 }
6400
6401 /******************************************************************************/
6402 SOAP_FMAC1
6403 int
6404 SOAP_FMAC2
6405 soap_set_cookie_session(struct soap *soap, const char *name, const char *domain, const char *path)
6406 { struct soap_cookie *p;
6407 if ((p = soap_cookie(soap, name, domain, path)))
6408 { p->session = 1;
6409 p->modified = 1;
6410 return SOAP_OK;
6411 }
6412 return SOAP_ERR;
6413 }
6414
6415 /******************************************************************************/
6416 SOAP_FMAC1
6417 int
6418 SOAP_FMAC2
6419 soap_clr_cookie_session(struct soap *soap, const char *name, const char *domain, const char *path)
6420 { struct soap_cookie *p;
6421 if ((p = soap_cookie(soap, name, domain, path)))
6422 { p->session = 0;
6423 p->modified = 1;
6424 return SOAP_OK;
6425 }
6426 return SOAP_ERR;
6427 }
6428
6429 /******************************************************************************/
6430 SOAP_FMAC1
6431 int
6432 SOAP_FMAC2
6433 soap_putsetcookies(struct soap *soap)
6434 { struct soap_cookie *p;
6435 char *s, tmp[4096];
6436 const char *t;
6437 for (p = soap->cookies; p; p = p->next)
6438 {
6439 if (p->modified
6440 #ifdef WITH_OPENSSL
6441 || (!p->env && !soap->ssl == !p->secure)
6442 #endif
6443 )
6444 { s = tmp;
6445 if (p->name)
6446 s += soap_encode_url(p->name, s, tmp-s+4064);
6447 if (p->value && *p->value)
6448 { *s++ = '=';
6449 s += soap_encode_url(p->value, s, tmp-s+4064);
6450 }
6451 if (p->domain && (int)strlen(p->domain) < tmp-s+4064)
6452 { strcpy(s, ";Domain=");
6453 strcat(s, p->domain);
6454 }
6455 else if (soap->cookie_domain && (int)strlen(soap->cookie_domain) < tmp-s+4064)
6456 { strcpy(s, ";Domain=");
6457 strcat(s, soap->cookie_domain);
6458 }
6459 strcat(s, ";Path=/");
6460 s += strlen(s);
6461 if (p->path)
6462 t = p->path;
6463 else
6464 t = soap->cookie_path;
6465 if (t)
6466 { if (*t == '/')
6467 t++;
6468 if ((int)strlen(t) < tmp-s+4064)
6469 { if (strchr(t, '%')) /* already URL encoded? */
6470 { strcpy(s, t);
6471 s += strlen(s);
6472 }
6473 else
6474 s += soap_encode_url(t, s, tmp-s+4064);
6475 }
6476 }
6477 if (p->version > 0 && s-tmp < 4060)
6478 {
6479 #ifdef HAVE_SNPRINTF
6480 soap_snprintf(s, 4096 - (s-tmp), ";Version=%u", p->version);
6481 #else
6482 sprintf(s, ";Version=%u", p->version);
6483 #endif
6484 s += strlen(s);
6485 }
6486 if (p->maxage >= 0 && s-tmp < 4060)
6487 {
6488 #ifdef HAVE_SNPRINTF
6489 soap_snprintf(s, 4096 - (s-tmp), ";Max-Age=%ld", p->maxage);
6490 #else
6491 sprintf(s, ";Max-Age=%ld", p->maxage);
6492 #endif
6493 s += strlen(s);
6494 }
6495 if (s-tmp < 4073
6496 && (p->secure
6497 #ifdef WITH_OPENSSL
6498 || soap->ssl
6499 #endif
6500 ))
6501 strcpy(s, ";Secure");
6502 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Set-Cookie: %s\n", tmp));
6503 if ((soap->error = soap->fposthdr(soap, "Set-Cookie", tmp)))
6504 return soap->error;
6505 }
6506 }
6507 return SOAP_OK;
6508 }
6509
6510 /******************************************************************************/
6511 SOAP_FMAC1
6512 int
6513 SOAP_FMAC2
6514 soap_putcookies(struct soap *soap, const char *domain, const char *path, int secure)
6515 { struct soap_cookie **p, *q;
6516 unsigned int version = 0;
6517 time_t now = time(NULL);
6518 char *s, tmp[4096];
6519 if (!domain || !path)
6520 return SOAP_OK;
6521 s = tmp;
6522 p = &soap->cookies;
6523 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Sending cookies for domain='%s' path='%s'\n", domain, path));
6524 if (*path == '/')
6525 path++;
6526 while ((q = *p))
6527 { if (q->expire && now > q->expire)
6528 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Cookie %s expired\n", q->name));
6529 SOAP_FREE(soap, q->name);
6530 if (q->value)
6531 SOAP_FREE(soap, q->value);
6532 if (q->domain)
6533 SOAP_FREE(soap, q->domain);
6534 if (q->path)
6535 SOAP_FREE(soap, q->path);
6536 *p = q->next;
6537 SOAP_FREE(soap, q);
6538 }
6539 else
6540 { int flag;
6541 char *t = q->domain;
6542 size_t n = 0;
6543 if (!t)
6544 flag = 1;
6545 else
6546 { const char *r = strchr(t, ':');
6547 if (r)
6548 n = r - t;
6549 else
6550 n = strlen(t);
6551 flag = !strncmp(t, domain, n);
6552 }
6553 /* domain-level cookies, cannot compile when WITH_NOIO set */
6554 #ifndef WITH_NOIO
6555 if (!flag)
6556 { struct hostent *hostent = gethostbyname((char*)domain);
6557 if (hostent)
6558 { const char *r = strchr(hostent->h_name, '.');
6559 if (!r)
6560 r = hostent->h_name;
6561 flag = !strncmp(t, r, n);
6562 }
6563 }
6564 #endif
6565 if (flag
6566 && (!q->path || !strncmp(q->path, path, strlen(q->path)))
6567 && (!q->secure || secure))
6568 { size_t n = 12;
6569 if (q->name)
6570 n += 3*strlen(q->name);
6571 if (q->value && *q->value)
6572 n += 3*strlen(q->value) + 1;
6573 if (q->path && *q->path)
6574 n += strlen(q->path) + 9;
6575 if (q->domain)
6576 n += strlen(q->domain) + 11;
6577 if (tmp - s + n > sizeof(tmp))
6578 { if (s == tmp)
6579 return SOAP_OK; /* HTTP header size overflow */
6580 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Cookie: %s\n", tmp));
6581 if ((soap->error = soap->fposthdr(soap, "Cookie", tmp)))
6582 return soap->error;
6583 s = tmp;
6584 }
6585 else if (s != tmp)
6586 { strcat(s, " ");
6587 s++;
6588 }
6589 if (q->version != version && s-tmp < 4060)
6590 {
6591 #ifdef HAVE_SNPRINTF
6592 soap_snprintf(s, 4096 - (s-tmp), "$Version=%u;", q->version);
6593 #else
6594 sprintf(s, "$Version=%u;", q->version);
6595 #endif
6596 version = q->version;
6597 s += strlen(s);
6598 }
6599 if (q->name)
6600 s += soap_encode_url(q->name, s, tmp+sizeof(tmp)-s-16);
6601 if (q->value && *q->value)
6602 { *s++ = '=';
6603 s += soap_encode_url(q->value, s, tmp+sizeof(tmp)-s-16);
6604 }
6605 if (q->path && (s-tmp) + strlen(q->path) < 4060)
6606 {
6607 #ifdef HAVE_SNPRINTF
6608 soap_snprintf(s, 4096 - (s-tmp), ";$Path=\"/%s\"", (*q->path == '/' ? q->path + 1 : q->path));
6609 #else
6610 sprintf(s, ";$Path=\"/%s\"", (*q->path == '/' ? q->path + 1 : q->path));
6611 #endif
6612 s += strlen(s);
6613 }
6614 if (q->domain && (s-tmp) + strlen(q->domain) < 4060)
6615 {
6616 #ifdef HAVE_SNPRINTF
6617 soap_snprintf(s, 4096 - (s-tmp), ";$Domain=\"%s\"", q->domain);
6618 #else
6619 sprintf(s, ";$Domain=\"%s\"", q->domain);
6620 #endif
6621 s += strlen(s);
6622 }
6623 }
6624 p = &q->next;
6625 }
6626 }
6627 if (s != tmp)
6628 if ((soap->error = soap->fposthdr(soap, "Cookie", tmp)))
6629 return soap->error;
6630 return SOAP_OK;
6631 }
6632
6633 /******************************************************************************/
6634 SOAP_FMAC1
6635 void
6636 SOAP_FMAC2
6637 soap_getcookies(struct soap *soap, const char *val)
6638 { struct soap_cookie *p = NULL, *q;
6639 const char *s;
6640 char *t, tmp[4096]; /* cookie size is up to 4096 bytes [RFC2109] */
6641 char *domain = NULL;
6642 char *path = NULL;
6643 unsigned int version = 0;
6644 time_t now = time(NULL);
6645 if (!val)
6646 return;
6647 s = val;
6648 while (*s)
6649 { s = soap_decode_key(tmp, sizeof(tmp), s);
6650 if (!soap_tag_cmp(tmp, "$Version"))
6651 { if ((s = soap_decode_val(tmp, sizeof(tmp), s)))
6652 { if (p)
6653 p->version = (int)soap_strtol(tmp, NULL, 10);
6654 else
6655 version = (int)soap_strtol(tmp, NULL, 10);
6656 }
6657 }
6658 else if (!soap_tag_cmp(tmp, "$Path"))
6659 { s = soap_decode_val(tmp, sizeof(tmp), s);
6660 if (*tmp)
6661 { if ((t = (char*)SOAP_MALLOC(soap, strlen(tmp)+1)))
6662 strcpy(t, tmp);
6663 }
6664 else
6665 t = NULL;
6666 if (p)
6667 { if (p->path)
6668 SOAP_FREE(soap, p->path);
6669 p->path = t;
6670 }
6671 else
6672 { if (path)
6673 SOAP_FREE(soap, path);
6674 path = t;
6675 }
6676 }
6677 else if (!soap_tag_cmp(tmp, "$Domain"))
6678 { s = soap_decode_val(tmp, sizeof(tmp), s);
6679 if (*tmp)
6680 { if ((t = (char*)SOAP_MALLOC(soap, strlen(tmp)+1)))
6681 strcpy(t, tmp);
6682 }
6683 else
6684 t = NULL;
6685 if (p)
6686 { if (p->domain)
6687 SOAP_FREE(soap, p->domain);
6688 p->domain = t;
6689 }
6690 else
6691 { if (domain)
6692 SOAP_FREE(soap, domain);
6693 domain = t;
6694 }
6695 }
6696 else if (p && !soap_tag_cmp(tmp, "Path"))
6697 { if (p->path)
6698 SOAP_FREE(soap, p->path);
6699 s = soap_decode_val(tmp, sizeof(tmp), s);
6700 if (*tmp)
6701 { if ((p->path = (char*)SOAP_MALLOC(soap, strlen(tmp)+1)))
6702 strcpy(p->path, tmp);
6703 }
6704 else
6705 p->path = NULL;
6706 }
6707 else if (p && !soap_tag_cmp(tmp, "Domain"))
6708 { if (p->domain)
6709 SOAP_FREE(soap, p->domain);
6710 s = soap_decode_val(tmp, sizeof(tmp), s);
6711 if (*tmp)
6712 { if ((p->domain = (char*)SOAP_MALLOC(soap, strlen(tmp)+1)))
6713 strcpy(p->domain, tmp);
6714 }
6715 else
6716 p->domain = NULL;
6717 }
6718 else if (p && !soap_tag_cmp(tmp, "Version"))
6719 { s = soap_decode_val(tmp, sizeof(tmp), s);
6720 p->version = (unsigned int)soap_strtoul(tmp, NULL, 10);
6721 }
6722 else if (p && !soap_tag_cmp(tmp, "Max-Age"))
6723 { s = soap_decode_val(tmp, sizeof(tmp), s);
6724 p->expire = now + soap_strtol(tmp, NULL, 10);
6725 }
6726 else if (p && !soap_tag_cmp(tmp, "Expires"))
6727 { struct tm T;
6728 char a[3];
6729 static const char mns[] = "anebarprayunulugepctovec";
6730 s = soap_decode_val(tmp, sizeof(tmp), s);
6731 if (strlen(tmp) > 20)
6732 { memset((void*)&T, 0, sizeof(T));
6733 a[0] = tmp[4];
6734 a[1] = tmp[5];
6735 a[2] = '\0';
6736 T.tm_mday = (int)soap_strtol(a, NULL, 10);
6737 a[0] = tmp[8];
6738 a[1] = tmp[9];
6739 T.tm_mon = (int)(strstr(mns, a) - mns) / 2;
6740 a[0] = tmp[11];
6741 a[1] = tmp[12];
6742 T.tm_year = 100 + (int)soap_strtol(a, NULL, 10);
6743 a[0] = tmp[13];
6744 a[1] = tmp[14];
6745 T.tm_hour = (int)soap_strtol(a, NULL, 10);
6746 a[0] = tmp[16];
6747 a[1] = tmp[17];
6748 T.tm_min = (int)soap_strtol(a, NULL, 10);
6749 a[0] = tmp[19];
6750 a[1] = tmp[20];
6751 T.tm_sec = (int)soap_strtol(a, NULL, 10);
6752 p->expire = soap_timegm(&T);
6753 }
6754 }
6755 else if (p && !soap_tag_cmp(tmp, "Secure"))
6756 p->secure = 1;
6757 else
6758 { if (p)
6759 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Got environment cookie='%s' value='%s' domain='%s' path='%s' expire=%ld secure=%d\n", p->name, p->value ? p->value : "(null)", p->domain ? p->domain : "(null)", p->path ? p->path : "(null)", p->expire, p->secure));
6760 if ((q = soap_set_cookie(soap, p->name, p->value, p->domain, p->path)))
6761 { q->version = p->version;
6762 q->expire = p->expire;
6763 q->secure = p->secure;
6764 q->env = 1;
6765 }
6766 if (p->name)
6767 SOAP_FREE(soap, p->name);
6768 if (p->value)
6769 SOAP_FREE(soap, p->value);
6770 if (p->domain)
6771 SOAP_FREE(soap, p->domain);
6772 if (p->path)
6773 SOAP_FREE(soap, p->path);
6774 SOAP_FREE(soap, p);
6775 }
6776 if ((p = (struct soap_cookie*)SOAP_MALLOC(soap, sizeof(struct soap_cookie))))
6777 { p->name = (char*)SOAP_MALLOC(soap, strlen(tmp)+1);
6778 strcpy(p->name, tmp);
6779 s = soap_decode_val(tmp, sizeof(tmp), s);
6780 if (*tmp)
6781 { p->value = (char*)SOAP_MALLOC(soap, strlen(tmp)+1);
6782 strcpy(p->value, tmp);
6783 }
6784 else
6785 p->value = NULL;
6786 if (domain)
6787 p->domain = domain;
6788 else if (*soap->host)
6789 { p->domain = (char*)SOAP_MALLOC(soap, strlen(soap->host)+1);
6790 strcpy(p->domain, soap->host);
6791 }
6792 else
6793 p->domain = NULL;
6794 if (path)
6795 p->path = path;
6796 else if (soap->path && *soap->path)
6797 { p->path = (char*)SOAP_MALLOC(soap, strlen(soap->path)+1);
6798 strcpy(p->path, soap->path);
6799 }
6800 else
6801 { p->path = (char*)SOAP_MALLOC(soap, 2);
6802 strcpy(p->path, "/");
6803 }
6804 p->expire = 0;
6805 p->secure = 0;
6806 p->version = version;
6807 }
6808 }
6809 }
6810 if (p)
6811 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Got environment cookie='%s' value='%s' domain='%s' path='%s' expire=%ld secure=%d\n", p->name, p->value ? p->value : "(null)", p->domain ? p->domain : "(null)", p->path ? p->path : "(null)", p->expire, p->secure));
6812 if ((q = soap_set_cookie(soap, p->name, p->value, p->domain, p->path)))
6813 { q->version = p->version;
6814 q->expire = p->expire;
6815 q->secure = p->secure;
6816 q->env = 1;
6817 }
6818 if (p->name)
6819 SOAP_FREE(soap, p->name);
6820 if (p->value)
6821 SOAP_FREE(soap, p->value);
6822 if (p->domain)
6823 SOAP_FREE(soap, p->domain);
6824 if (p->path)
6825 SOAP_FREE(soap, p->path);
6826 SOAP_FREE(soap, p);
6827 }
6828 if (domain)
6829 SOAP_FREE(soap, domain);
6830 if (path)
6831 SOAP_FREE(soap, path);
6832 }
6833
6834 /******************************************************************************/
6835 SOAP_FMAC1
6836 int
6837 SOAP_FMAC2
6838 soap_getenv_cookies(struct soap *soap)
6839 { struct soap_cookie *p;
6840 const char *s;
6841 char key[4096], val[4096]; /* cookie size is up to 4096 bytes [RFC2109] */
6842 if (!(s = getenv("HTTP_COOKIE")))
6843 return SOAP_ERR;
6844 do
6845 { s = soap_decode_key(key, sizeof(key), s);
6846 s = soap_decode_val(val, sizeof(val), s);
6847 p = soap_set_cookie(soap, key, val, NULL, NULL);
6848 if (p)
6849 p->env = 1;
6850 } while (*s);
6851 return SOAP_OK;
6852 }
6853
6854 /******************************************************************************/
6855 SOAP_FMAC1
6856 struct soap_cookie*
6857 SOAP_FMAC2
6858 soap_copy_cookies(struct soap *copy, const struct soap *soap)
6859 { struct soap_cookie *p, **q, *r;
6860 q = &r;
6861 for (p = soap->cookies; p; p = p->next)
6862 { if (!(*q = (struct soap_cookie*)SOAP_MALLOC(copy, sizeof(struct soap_cookie))))
6863 return r;
6864 **q = *p;
6865 if (p->name)
6866 { if (((*q)->name = (char*)SOAP_MALLOC(copy, strlen(p->name)+1)))
6867 strcpy((*q)->name, p->name);
6868 }
6869 if (p->value)
6870 { if (((*q)->value = (char*)SOAP_MALLOC(copy, strlen(p->value)+1)))
6871 strcpy((*q)->value, p->value);
6872 }
6873 if (p->domain)
6874 { if (((*q)->domain = (char*)SOAP_MALLOC(copy, strlen(p->domain)+1)))
6875 strcpy((*q)->domain, p->domain);
6876 }
6877 if (p->path)
6878 { if (((*q)->path = (char*)SOAP_MALLOC(copy, strlen(p->path)+1)))
6879 strcpy((*q)->path, p->path);
6880 }
6881 q = &(*q)->next;
6882 }
6883 *q = NULL;
6884 return r;
6885 }
6886
6887 /******************************************************************************/
6888 SOAP_FMAC1
6889 void
6890 SOAP_FMAC2
6891 soap_free_cookies(struct soap *soap)
6892 { struct soap_cookie *p;
6893 for (p = soap->cookies; p; p = soap->cookies)
6894 { soap->cookies = p->next;
6895 SOAP_FREE(soap, p->name);
6896 if (p->value)
6897 SOAP_FREE(soap, p->value);
6898 if (p->domain)
6899 SOAP_FREE(soap, p->domain);
6900 if (p->path)
6901 SOAP_FREE(soap, p->path);
6902 SOAP_FREE(soap, p);
6903 }
6904 }
6905
6906 /******************************************************************************/
6907 #endif /* WITH_COOKIES */
6908
6909 /******************************************************************************/
6910 #ifndef WITH_NOIDREF
6911 #ifndef PALM_2
6912 SOAP_FMAC1
6913 size_t
6914 SOAP_FMAC2
6915 soap_hash(register const char *s)
6916 { register size_t h = 0;
6917 while (*s)
6918 h = 65599*h + *s++;
6919 return h % SOAP_IDHASH;
6920 }
6921 #endif
6922 #endif
6923
6924 /******************************************************************************/
6925 #ifndef WITH_NOIDREF
6926 #ifndef PALM_1
6927 static void
6928 soap_init_pht(struct soap *soap)
6929 { register int i;
6930 soap->pblk = NULL;
6931 soap->pidx = 0;
6932 for (i = 0; i < (int)SOAP_PTRHASH; i++)
6933 soap->pht[i] = NULL;
6934 }
6935 #endif
6936 #endif
6937
6938 /******************************************************************************/
6939 #ifndef PALM_1
6940 SOAP_FMAC1
6941 struct soap*
6942 SOAP_FMAC2
6943 soap_versioning(soap_new)(soap_mode imode, soap_mode omode)
6944 { struct soap *soap = (struct soap*)malloc(sizeof(struct soap));
6945 if (soap)
6946 soap_versioning(soap_init)(soap, imode, omode);
6947 return soap;
6948 }
6949 #endif
6950
6951 /******************************************************************************/
6952 #ifndef PALM_1
6953 SOAP_FMAC1
6954 void
6955 SOAP_FMAC2
6956 soap_free(struct soap *soap)
6957 { soap_done(soap);
6958 free(soap);
6959 }
6960 #endif
6961
6962 /******************************************************************************/
6963 #ifndef PALM_1
6964 SOAP_FMAC1
6965 void
6966 SOAP_FMAC2
6967 soap_del(struct soap *soap)
6968 { free(soap);
6969 }
6970 #endif
6971
6972 /******************************************************************************/
6973 #ifndef WITH_NOIDREF
6974 #ifndef PALM_1
6975 static void
6976 soap_free_pht(struct soap *soap)
6977 { register struct soap_pblk *pb, *next;
6978 register int i;
6979 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free pointer hashtable\n"));
6980 for (pb = soap->pblk; pb; pb = next)
6981 { next = pb->next;
6982 SOAP_FREE(soap, pb);
6983 }
6984 soap->pblk = NULL;
6985 soap->pidx = 0;
6986 for (i = 0; i < (int)SOAP_PTRHASH; i++)
6987 soap->pht[i] = NULL;
6988 }
6989 #endif
6990 #endif
6991
6992 /******************************************************************************/
6993 #ifndef WITH_NOIDREF
6994 #ifndef PALM_2
6995 SOAP_FMAC1
6996 int
6997 SOAP_FMAC2
6998 soap_embed(struct soap *soap, const void *p, const struct soap_array *a, int n, const char *tag, int type)
6999 { register int i;
7000 struct soap_plist *pp;
7001 (void)soap;
7002 if (soap->version == 2)
7003 soap->encoding = 1;
7004 if (a)
7005 i = soap_array_pointer_lookup(soap, p, a, n, type, &pp);
7006 else
7007 i = soap_pointer_lookup(soap, p, type, &pp);
7008 if (i)
7009 { if (soap_is_embedded(soap, pp)
7010 || soap_is_single(soap, pp))
7011 return 0;
7012 soap_set_embedded(soap, pp);
7013 }
7014 return i;
7015 }
7016 #endif
7017 #endif
7018
7019 /******************************************************************************/
7020 #ifndef WITH_NOIDREF
7021 #ifndef PALM_2
7022 SOAP_FMAC1
7023 int
7024 SOAP_FMAC2
7025 soap_pointer_lookup(struct soap *soap, const void *p, int type, struct soap_plist **ppp)
7026 { register struct soap_plist *pp;
7027 *ppp = NULL;
7028 if (p)
7029 { for (pp = soap->pht[soap_hash_ptr(p)]; pp; pp = pp->next)
7030 { if (pp->ptr == p && pp->type == type)
7031 { *ppp = pp;
7032 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Lookup location=%p type=%d id=%d\n", p, type, pp->id));
7033 return pp->id;
7034 }
7035 }
7036 }
7037 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Lookup location=%p type=%d: not found\n", p, type));
7038 return 0;
7039 }
7040 #endif
7041 #endif
7042
7043 /******************************************************************************/
7044 #ifndef WITH_NOIDREF
7045 #ifndef PALM_2
7046 SOAP_FMAC1
7047 int
7048 SOAP_FMAC2
7049 soap_pointer_enter(struct soap *soap, const void *p, const struct soap_array *a, int n, int type, struct soap_plist **ppp)
7050 { register size_t h;
7051 register struct soap_plist *pp;
7052 (void)n;
7053 if (!soap->pblk || soap->pidx >= SOAP_PTRBLK)
7054 { register struct soap_pblk *pb = (struct soap_pblk*)SOAP_MALLOC(soap, sizeof(struct soap_pblk));
7055 if (!pb)
7056 { soap->error = SOAP_EOM;
7057 return 0;
7058 }
7059 pb->next = soap->pblk;
7060 soap->pblk = pb;
7061 soap->pidx = 0;
7062 }
7063 *ppp = pp = &soap->pblk->plist[soap->pidx++];
7064 if (a)
7065 h = soap_hash_ptr(a->__ptr);
7066 else
7067 h = soap_hash_ptr(p);
7068 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Pointer enter location=%p array=%p size=%d dim=%d type=%d id=%d\n", p, a ? a->__ptr : NULL, a ? a->__size : 0, n, type, soap->idnum+1));
7069 pp->next = soap->pht[h];
7070 pp->type = type;
7071 pp->mark1 = 0;
7072 pp->mark2 = 0;
7073 pp->ptr = p;
7074 pp->array = a;
7075 soap->pht[h] = pp;
7076 pp->id = ++soap->idnum;
7077 return pp->id;
7078 }
7079 #endif
7080 #endif
7081
7082 /******************************************************************************/
7083 #ifndef WITH_NOIDREF
7084 #ifndef PALM_2
7085 SOAP_FMAC1
7086 int
7087 SOAP_FMAC2
7088 soap_array_pointer_lookup(struct soap *soap, const void *p, const struct soap_array *a, int n, int type, struct soap_plist **ppp)
7089 { register struct soap_plist *pp;
7090 *ppp = NULL;
7091 if (!p || !a->__ptr)
7092 return 0;
7093 for (pp = soap->pht[soap_hash_ptr(a->__ptr)]; pp; pp = pp->next)
7094 { if (pp->type == type && pp->array && pp->array->__ptr == a->__ptr)
7095 { register int i;
7096 for (i = 0; i < n; i++)
7097 if (((const int*)&pp->array->__size)[i] != ((const int*)&a->__size)[i])
7098 break;
7099 if (i == n)
7100 { *ppp = pp;
7101 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Array lookup location=%p type=%d id=%d\n", a->__ptr, type, pp->id));
7102 return pp->id;
7103 }
7104 }
7105 }
7106 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Array lookup location=%p type=%d: not found\n", a->__ptr, type));
7107 return 0;
7108 }
7109 #endif
7110 #endif
7111
7112 /******************************************************************************/
7113 #ifndef PALM_1
7114 SOAP_FMAC1
7115 int
7116 SOAP_FMAC2
7117 soap_begin_count(struct soap *soap)
7118 { soap_free_ns(soap);
7119 #ifndef WITH_LEANER
7120 if ((soap->mode & SOAP_ENC_DIME) || (soap->omode & SOAP_ENC_DIME))
7121 soap->mode = soap->omode | SOAP_IO_LENGTH | SOAP_ENC_DIME;
7122 else
7123 #endif
7124 { soap->mode = soap->omode;
7125 if ((soap->mode & SOAP_IO_UDP))
7126 soap->mode |= SOAP_ENC_XML;
7127 if ((soap->mode & SOAP_IO) == SOAP_IO_STORE
7128 || (((soap->mode & SOAP_IO) == SOAP_IO_CHUNK || (soap->mode & SOAP_ENC_XML))
7129 #ifndef WITH_LEANER
7130 && !soap->fpreparesend
7131 #endif
7132 ))
7133 soap->mode &= ~SOAP_IO_LENGTH;
7134 else
7135 soap->mode |= SOAP_IO_LENGTH;
7136 }
7137 #ifdef WITH_ZLIB
7138 if ((soap->mode & SOAP_ENC_ZLIB) && (soap->mode & SOAP_IO) == SOAP_IO_FLUSH)
7139 { if (!(soap->mode & SOAP_ENC_DIME))
7140 soap->mode &= ~SOAP_IO_LENGTH;
7141 if (soap->mode & SOAP_ENC_XML)
7142 soap->mode |= SOAP_IO_BUFFER;
7143 else
7144 soap->mode |= SOAP_IO_STORE;
7145 }
7146 #endif
7147 #ifndef WITH_LEANER
7148 if ((soap->mode & SOAP_ENC_MTOM) && (soap->mode & SOAP_ENC_DIME))
7149 soap->mode |= SOAP_ENC_MIME;
7150 else if (!(soap->mode & SOAP_ENC_MIME))
7151 soap->mode &= ~SOAP_ENC_MTOM;
7152 if (soap->mode & SOAP_ENC_MIME)
7153 soap_select_mime_boundary(soap);
7154 soap->dime.list = soap->dime.last; /* keep track of last DIME attachment */
7155 #endif
7156 soap->count = 0;
7157 soap->ns = 0;
7158 soap->null = 0;
7159 soap->position = 0;
7160 soap->mustUnderstand = 0;
7161 soap->encoding = 0;
7162 soap->part = SOAP_BEGIN;
7163 soap->event = 0;
7164 soap->evlev = 0;
7165 soap->idnum = 0;
7166 soap_clr_attr(soap);
7167 soap_set_local_namespaces(soap);
7168 #ifndef WITH_LEANER
7169 soap->dime.count = 0; /* count # of attachments */
7170 soap->dime.size = 0; /* accumulate total size of attachments */
7171 if (soap->fprepareinitsend && (soap->mode & SOAP_IO) != SOAP_IO_STORE && (soap->error = soap->fprepareinitsend(soap)))
7172 return soap->error;
7173 #endif
7174 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Begin count phase (socket=%d mode=0x%x count=%lu)\n", soap->socket, (unsigned int)soap->mode, (unsigned long)soap->count));
7175 return SOAP_OK;
7176 }
7177 #endif
7178
7179 /******************************************************************************/
7180 #ifndef PALM_1
7181 SOAP_FMAC1
7182 int
7183 SOAP_FMAC2
7184 soap_end_count(struct soap *soap)
7185 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of count phase\n"));
7186 #ifndef WITH_LEANER
7187 if ((soap->mode & SOAP_IO_LENGTH))
7188 { if (soap->fpreparefinalsend && (soap->error = soap->fpreparefinalsend(soap)))
7189 return soap->error;
7190 }
7191 #endif
7192 return SOAP_OK;
7193 }
7194 #endif
7195
7196 /******************************************************************************/
7197 #ifndef PALM_1
7198 SOAP_FMAC1
7199 int
7200 SOAP_FMAC2
7201 soap_begin_send(struct soap *soap)
7202 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Initializing for output to socket=%d/fd=%d\n", soap->socket, soap->sendfd));
7203 soap_free_ns(soap);
7204 soap->error = SOAP_OK;
7205 soap->mode = soap->omode | (soap->mode & (SOAP_IO_LENGTH | SOAP_ENC_DIME));
7206 #ifdef WITH_ZLIB
7207 if ((soap->mode & SOAP_ENC_ZLIB) && (soap->mode & SOAP_IO) == SOAP_IO_FLUSH)
7208 { if (soap->mode & SOAP_ENC_XML)
7209 soap->mode |= SOAP_IO_BUFFER;
7210 else
7211 soap->mode |= SOAP_IO_STORE;
7212 }
7213 #endif
7214 #ifndef WITH_LEAN
7215 if ((soap->mode & SOAP_IO_UDP))
7216 { soap->mode |= SOAP_ENC_XML;
7217 if (soap->count > SOAP_BUFLEN)
7218 return soap->error = SOAP_UDP_ERROR;
7219 }
7220 #endif
7221 if ((soap->mode & SOAP_IO) == SOAP_IO_FLUSH && soap_valid_socket(soap->socket))
7222 { if (soap->count || (soap->mode & SOAP_IO_LENGTH) || (soap->mode & SOAP_ENC_XML))
7223 soap->mode |= SOAP_IO_BUFFER;
7224 else
7225 soap->mode |= SOAP_IO_STORE;
7226 }
7227 soap->mode &= ~SOAP_IO_LENGTH;
7228 if ((soap->mode & SOAP_IO) == SOAP_IO_STORE)
7229 if (soap_new_block(soap) == NULL)
7230 return soap->error;
7231 if (!(soap->mode & SOAP_IO_KEEPALIVE))
7232 soap->keep_alive = 0;
7233 #ifndef WITH_LEANER
7234 if ((soap->mode & SOAP_ENC_MTOM) && (soap->mode & SOAP_ENC_DIME))
7235 { soap->mode |= SOAP_ENC_MIME;
7236 soap->mode &= ~SOAP_ENC_DIME;
7237 }
7238 else if (!(soap->mode & SOAP_ENC_MIME))
7239 soap->mode &= ~SOAP_ENC_MTOM;
7240 if (soap->mode & SOAP_ENC_MIME)
7241 soap_select_mime_boundary(soap);
7242 #ifdef WIN32
7243 #ifndef UNDER_CE
7244 #ifndef WITH_FASTCGI
7245 if (!soap_valid_socket(soap->socket) && !soap->os) /* Set win32 stdout or soap->sendfd to BINARY, e.g. to support DIME */
7246 #ifdef __BORLANDC__
7247 setmode(soap->sendfd, _O_BINARY);
7248 #else
7249 _setmode(soap->sendfd, _O_BINARY);
7250 #endif
7251 #endif
7252 #endif
7253 #endif
7254 #endif
7255 if (soap->mode & SOAP_IO)
7256 { soap->bufidx = 0;
7257 soap->buflen = 0;
7258 }
7259 soap->chunksize = 0;
7260 soap->ns = 0;
7261 soap->null = 0;
7262 soap->position = 0;
7263 soap->mustUnderstand = 0;
7264 soap->encoding = 0;
7265 soap->idnum = 0;
7266 soap->level = 0;
7267 soap_clr_attr(soap);
7268 soap_set_local_namespaces(soap);
7269 #ifdef WITH_ZLIB
7270 soap->z_ratio_out = 1.0;
7271 if ((soap->mode & SOAP_ENC_ZLIB) && soap->zlib_state != SOAP_ZLIB_DEFLATE)
7272 { if (!soap->z_buf)
7273 soap->z_buf = (char*)SOAP_MALLOC(soap, SOAP_BUFLEN);
7274 soap->d_stream->next_out = (Byte*)soap->z_buf;
7275 soap->d_stream->avail_out = SOAP_BUFLEN;
7276 #ifdef WITH_GZIP
7277 if (soap->zlib_out != SOAP_ZLIB_DEFLATE)
7278 { memcpy(soap->z_buf, "\37\213\10\0\0\0\0\0\0\377", 10);
7279 soap->d_stream->next_out = (Byte*)soap->z_buf + 10;
7280 soap->d_stream->avail_out = SOAP_BUFLEN - 10;
7281 soap->z_crc = crc32(0L, NULL, 0);
7282 soap->zlib_out = SOAP_ZLIB_GZIP;
7283 if (soap->z_dict)
7284 *((Byte*)soap->z_buf + 2) = 0xff;
7285 if (deflateInit2(soap->d_stream, soap->z_level, Z_DEFLATED, -MAX_WBITS, 8, Z_DEFAULT_STRATEGY) != Z_OK)
7286 return soap->error = SOAP_ZLIB_ERROR;
7287 }
7288 else
7289 #endif
7290 if (deflateInit(soap->d_stream, soap->z_level) != Z_OK)
7291 return soap->error = SOAP_ZLIB_ERROR;
7292 if (soap->z_dict)
7293 { if (deflateSetDictionary(soap->d_stream, (const Bytef*)soap->z_dict, soap->z_dict_len) != Z_OK)
7294 return soap->error = SOAP_ZLIB_ERROR;
7295 }
7296 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflate initialized\n"));
7297 soap->zlib_state = SOAP_ZLIB_DEFLATE;
7298 }
7299 #endif
7300 #ifdef WITH_OPENSSL
7301 if (soap->ssl)
7302 ERR_clear_error();
7303 #endif
7304 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Begin send phase (socket=%d mode=0x%x count=%lu)\n", soap->socket, soap->mode, (unsigned long)soap->count));
7305 soap->part = SOAP_BEGIN;
7306 #ifndef WITH_LEANER
7307 if (soap->fprepareinitsend && (soap->mode & SOAP_IO) == SOAP_IO_STORE && (soap->error = soap->fprepareinitsend(soap)))
7308 return soap->error;
7309 #endif
7310 return SOAP_OK;
7311 }
7312 #endif
7313
7314 /******************************************************************************/
7315 #ifndef WITH_NOIDREF
7316 #ifndef PALM_2
7317 SOAP_FMAC1
7318 void
7319 SOAP_FMAC2
7320 soap_embedded(struct soap *soap, const void *p, int t)
7321 { struct soap_plist *pp;
7322 if (soap_pointer_lookup(soap, p, t, &pp))
7323 { pp->mark1 = 1;
7324 pp->mark2 = 1;
7325 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Embedded %p type=%d mark set to 1\n", p, t));
7326 }
7327 }
7328 #endif
7329 #endif
7330
7331 /******************************************************************************/
7332 #ifndef WITH_NOIDREF
7333 #ifndef PALM_2
7334 SOAP_FMAC1
7335 int
7336 SOAP_FMAC2
7337 soap_reference(struct soap *soap, const void *p, int t)
7338 { struct soap_plist *pp;
7339 if (!p || (!soap->encodingStyle && !(soap->omode & (SOAP_ENC_DIME|SOAP_ENC_MIME|SOAP_ENC_MTOM|SOAP_XML_GRAPH))) || (soap->omode & SOAP_XML_TREE))
7340 return 1;
7341 if (soap_pointer_lookup(soap, p, t, &pp))
7342 { if (pp->mark1 == 0)
7343 { pp->mark1 = 2;
7344 pp->mark2 = 2;
7345 }
7346 }
7347 else if (!soap_pointer_enter(soap, p, NULL, 0, t, &pp))
7348 return 1;
7349 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Reference %p type=%d (%d %d)\n", p, t, (int)pp->mark1, (int)pp->mark2));
7350 return pp->mark1;
7351 }
7352 #endif
7353 #endif
7354
7355 /******************************************************************************/
7356 #ifndef WITH_NOIDREF
7357 #ifndef PALM_2
7358 SOAP_FMAC1
7359 int
7360 SOAP_FMAC2
7361 soap_array_reference(struct soap *soap, const void *p, const struct soap_array *a, int n, int t)
7362 { struct soap_plist *pp;
7363 if (!p || !a->__ptr || (!soap->encodingStyle && !(soap->omode & (SOAP_ENC_DIME|SOAP_ENC_MIME|SOAP_ENC_MTOM|SOAP_XML_GRAPH))) || (soap->omode & SOAP_XML_TREE))
7364 return 1;
7365 if (soap_array_pointer_lookup(soap, p, a, n, t, &pp))
7366 { if (pp->mark1 == 0)
7367 { pp->mark1 = 2;
7368 pp->mark2 = 2;
7369 }
7370 }
7371 else if (!soap_pointer_enter(soap, p, a, n, t, &pp))
7372 return 1;
7373 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Array reference %p ptr=%p dim=%d type=%d (%d %d)\n", p, a->__ptr, n, t, (int)pp->mark1, (int)pp->mark2));
7374 return pp->mark1;
7375 }
7376 #endif
7377 #endif
7378
7379 /******************************************************************************/
7380 #ifndef WITH_NOIDREF
7381 #ifndef PALM_2
7382 SOAP_FMAC1
7383 int
7384 SOAP_FMAC2
7385 soap_embedded_id(struct soap *soap, int id, const void *p, int t)
7386 { struct soap_plist *pp = NULL;
7387 if (!id || (!soap->encodingStyle && !(soap->omode & SOAP_XML_GRAPH)) || (soap->omode & SOAP_XML_TREE))
7388 return id;
7389 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Embedded_id %p type=%d id=%d\n", p, t, id));
7390 if (soap->version == 1 && soap->part != SOAP_IN_HEADER)
7391 { if (id < 0)
7392 { id = soap_pointer_lookup(soap, p, t, &pp);
7393 if (id)
7394 { if (soap->mode & SOAP_IO_LENGTH)
7395 pp->mark1 = 2;
7396 else
7397 pp->mark2 = 2;
7398 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Embedded_id multiref id=%d %p type=%d = (%d %d)\n", id, p, t, (int)pp->mark1, (int)pp->mark2));
7399 }
7400 return -1;
7401 }
7402 return id;
7403 }
7404 if (id < 0)
7405 id = soap_pointer_lookup(soap, p, t, &pp);
7406 else if (id && !soap_pointer_lookup(soap, p, t, &pp))
7407 return 0;
7408 if (id && pp)
7409 { if (soap->mode & SOAP_IO_LENGTH)
7410 pp->mark1 = 1;
7411 else
7412 pp->mark2 = 1;
7413 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Embedded_id embedded ref id=%d %p type=%d = (%d %d)\n", id, p, t, (int)pp->mark1, (int)pp->mark2));
7414 }
7415 return id;
7416 }
7417 #endif
7418 #endif
7419
7420 /******************************************************************************/
7421 #ifndef WITH_NOIDREF
7422 #ifndef PALM_2
7423 SOAP_FMAC1
7424 int
7425 SOAP_FMAC2
7426 soap_is_embedded(struct soap *soap, struct soap_plist *pp)
7427 { if (!pp)
7428 return 0;
7429 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Is embedded? %d %d\n", (int)pp->mark1, (int)pp->mark2));
7430 if (soap->version == 1 && soap->encodingStyle && !(soap->mode & SOAP_XML_GRAPH) && soap->part != SOAP_IN_HEADER)
7431 { if (soap->mode & SOAP_IO_LENGTH)
7432 return pp->mark1 != 0;
7433 return pp->mark2 != 0;
7434 }
7435 if (soap->mode & SOAP_IO_LENGTH)
7436 return pp->mark1 == 1;
7437 return pp->mark2 == 1;
7438 }
7439 #endif
7440 #endif
7441
7442 /******************************************************************************/
7443 #ifndef WITH_NOIDREF
7444 #ifndef PALM_2
7445 SOAP_FMAC1
7446 int
7447 SOAP_FMAC2
7448 soap_is_single(struct soap *soap, struct soap_plist *pp)
7449 { if (soap->part == SOAP_IN_HEADER)
7450 return 1;
7451 if (!pp)
7452 return 0;
7453 if (soap->mode & SOAP_IO_LENGTH)
7454 return pp->mark1 == 0;
7455 return pp->mark2 == 0;
7456 }
7457 #endif
7458 #endif
7459
7460 /******************************************************************************/
7461 #ifndef WITH_NOIDREF
7462 #ifndef PALM_2
7463 SOAP_FMAC1
7464 void
7465 SOAP_FMAC2
7466 soap_set_embedded(struct soap *soap, struct soap_plist *pp)
7467 { if (!pp)
7468 return;
7469 if (soap->mode & SOAP_IO_LENGTH)
7470 pp->mark1 = 1;
7471 else
7472 pp->mark2 = 1;
7473 }
7474 #endif
7475 #endif
7476
7477 /******************************************************************************/
7478 #ifndef WITH_LEANER
7479 #ifndef PALM_1
7480 SOAP_FMAC1
7481 int
7482 SOAP_FMAC2
7483 soap_attachment(struct soap *soap, const char *tag, int id, const void *p, const struct soap_array *a, const char *aid, const char *atype, const char *aoptions, int n, const char *type, int t)
7484 {
7485 #ifndef WITH_NOIDREF
7486 struct soap_plist *pp;
7487 int i;
7488 if (!p || !a->__ptr || (!aid && !atype))
7489 return soap_element_id(soap, tag, id, p, a, n, type, t);
7490 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Attachment tag='%s' id='%s' (%d) type='%s'\n", tag, aid ? aid : SOAP_STR_EOS, id, atype ? atype : SOAP_STR_EOS));
7491 i = soap_array_pointer_lookup(soap, p, a, n, t, &pp);
7492 if (!i)
7493 { i = soap_pointer_enter(soap, p, a, n, t, &pp);
7494 if (!i)
7495 { soap->error = SOAP_EOM;
7496 return -1;
7497 }
7498 }
7499 if (id <= 0)
7500 id = i;
7501 if (!aid)
7502 {
7503 #ifdef HAVE_SNPRINTF
7504 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), soap->dime_id_format, id);
7505 #else
7506 sprintf(soap->tmpbuf, soap->dime_id_format, id);
7507 #endif
7508 aid = soap_strdup(soap, soap->tmpbuf);
7509 }
7510 /* Add MTOM xop:Include element when necessary */
7511 /* TODO: this code to be obsoleted with new import/xop.h conventions */
7512 if ((soap->mode & SOAP_ENC_MTOM) && strcmp(tag, "xop:Include"))
7513 { if (soap_element_begin_out(soap, tag, 0, type)
7514 || soap_element_href(soap, "xop:Include", 0, "xmlns:xop=\"http://www.w3.org/2004/08/xop/include\" href", aid)
7515 || soap_element_end_out(soap, tag))
7516 return soap->error;
7517 }
7518 else if (soap_element_href(soap, tag, 0, "href", aid))
7519 return soap->error;
7520 if (soap->mode & SOAP_IO_LENGTH)
7521 { if (pp->mark1 != 3)
7522 { struct soap_multipart *content;
7523 if (soap->mode & SOAP_ENC_MTOM)
7524 content = soap_new_multipart(soap, &soap->mime.first, &soap->mime.last, (char*)a->__ptr, a->__size);
7525 else
7526 content = soap_new_multipart(soap, &soap->dime.first, &soap->dime.last, (char*)a->__ptr, a->__size);
7527 if (!content)
7528 { soap->error = SOAP_EOM;
7529 return -1;
7530 }
7531 if (!strncmp(aid, "cid:", 4)) /* RFC 2111 */
7532 { if (soap->mode & SOAP_ENC_MTOM)
7533 { char *s = (char*)soap_malloc(soap, strlen(aid) - 1);
7534 if (s)
7535 { *s = '<';
7536 strcpy(s + 1, aid + 4);
7537 strcat(s, ">");
7538 content->id = s;
7539 }
7540 }
7541 else
7542 content->id = aid + 4;
7543 }
7544 else
7545 content->id = aid;
7546 content->type = atype;
7547 content->options = aoptions;
7548 content->encoding = SOAP_MIME_BINARY;
7549 pp->mark1 = 3;
7550 }
7551 }
7552 else
7553 pp->mark2 = 3;
7554 #endif
7555 return -1;
7556 }
7557 #endif
7558 #endif
7559
7560 /******************************************************************************/
7561 #ifndef WITH_NOIDREF
7562 #ifndef PALM_1
7563 static void
7564 soap_init_iht(struct soap *soap)
7565 { register int i;
7566 for (i = 0; i < SOAP_IDHASH; i++)
7567 soap->iht[i] = NULL;
7568 }
7569 #endif
7570 #endif
7571
7572 /******************************************************************************/
7573 #ifndef WITH_NOIDREF
7574 #ifndef PALM_1
7575 static void
7576 soap_free_iht(struct soap *soap)
7577 { register int i;
7578 register struct soap_ilist *ip = NULL, *p = NULL;
7579 register struct soap_flist *fp = NULL, *fq = NULL;
7580 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free ID hashtable\n"));
7581 for (i = 0; i < SOAP_IDHASH; i++)
7582 { for (ip = soap->iht[i]; ip; ip = p)
7583 { for (fp = ip->flist; fp; fp = fq)
7584 { fq = fp->next;
7585 SOAP_FREE(soap, fp);
7586 }
7587 p = ip->next;
7588 SOAP_FREE(soap, ip);
7589 }
7590 soap->iht[i] = NULL;
7591 }
7592 }
7593 #endif
7594 #endif
7595
7596 /******************************************************************************/
7597 #ifndef WITH_NOIDREF
7598 #ifndef PALM_2
7599 SOAP_FMAC1
7600 struct soap_ilist *
7601 SOAP_FMAC2
7602 soap_lookup(struct soap *soap, const char *id)
7603 { register struct soap_ilist *ip = NULL;
7604 for (ip = soap->iht[soap_hash(id)]; ip; ip = ip->next)
7605 if (!strcmp(ip->id, id))
7606 return ip;
7607 return NULL;
7608 }
7609 #endif
7610 #endif
7611
7612 /******************************************************************************/
7613 #ifndef WITH_NOIDREF
7614 #ifndef PALM_2
7615 SOAP_FMAC1
7616 struct soap_ilist *
7617 SOAP_FMAC2
7618 soap_enter(struct soap *soap, const char *id)
7619 { register size_t h;
7620 register struct soap_ilist *ip;
7621 ip = (struct soap_ilist*)SOAP_MALLOC(soap, sizeof(struct soap_ilist) + strlen(id));
7622 if (ip)
7623 { strcpy((char*)ip->id, id);
7624 h = soap_hash(id); /* h = (HASH(id) % SOAP_IDHASH) so soap->iht[h] is safe */
7625 ip->next = soap->iht[h];
7626 soap->iht[h] = ip;
7627 }
7628 return ip;
7629 }
7630 #endif
7631 #endif
7632
7633 /******************************************************************************/
7634 #ifndef PALM_2
7635 SOAP_FMAC1
7636 void*
7637 SOAP_FMAC2
7638 soap_malloc(struct soap *soap, size_t n)
7639 { register char *p;
7640 if (!n)
7641 return (void*)SOAP_NON_NULL;
7642 if (!soap)
7643 return SOAP_MALLOC(soap, n);
7644 if (soap->fmalloc)
7645 p = (char*)soap->fmalloc(soap, n);
7646 else
7647 { n += sizeof(short);
7648 n += (-(long)n) & (sizeof(void*)-1); /* align at 4-, 8- or 16-byte boundary */
7649 if (!(p = (char*)SOAP_MALLOC(soap, n + sizeof(void*) + sizeof(size_t))))
7650 { soap->error = SOAP_EOM;
7651 return NULL;
7652 }
7653 /* set the canary to detect corruption */
7654 *(unsigned short*)(p + n - sizeof(unsigned short)) = (unsigned short)SOAP_CANARY;
7655 /* keep chain of alloced cells for destruction */
7656 *(void**)(p + n) = soap->alist;
7657 *(size_t*)(p + n + sizeof(void*)) = n;
7658 soap->alist = p + n;
7659 }
7660 soap->alloced = 1;
7661 return p;
7662 }
7663 #endif
7664
7665 /******************************************************************************/
7666 #ifdef SOAP_MEM_DEBUG
7667 static void
7668 soap_init_mht(struct soap *soap)
7669 { register int i;
7670 for (i = 0; i < (int)SOAP_PTRHASH; i++)
7671 soap->mht[i] = NULL;
7672 }
7673 #endif
7674
7675 /******************************************************************************/
7676 #ifdef SOAP_MEM_DEBUG
7677 static void
7678 soap_free_mht(struct soap *soap)
7679 { register int i;
7680 register struct soap_mlist *mp, *mq;
7681 for (i = 0; i < (int)SOAP_PTRHASH; i++)
7682 { for (mp = soap->mht[i]; mp; mp = mq)
7683 { mq = mp->next;
7684 if (mp->live)
7685 fprintf(stderr, "%s(%d): malloc() = %p not freed (memory leak or forgot to call soap_end()?)\n", mp->file, mp->line, mp->ptr);
7686 free(mp);
7687 }
7688 soap->mht[i] = NULL;
7689 }
7690 }
7691 #endif
7692
7693 /******************************************************************************/
7694 #ifdef SOAP_MEM_DEBUG
7695 SOAP_FMAC1
7696 void*
7697 SOAP_FMAC2
7698 soap_track_malloc(struct soap *soap, const char *file, int line, size_t size)
7699 { register void *p = malloc(size);
7700 if (soap)
7701 { register size_t h = soap_hash_ptr(p);
7702 register struct soap_mlist *mp = (struct soap_mlist*)malloc(sizeof(struct soap_mlist));
7703 if (soap->fdebug[SOAP_INDEX_TEST])
7704 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "%s(%d): malloc(%lu) = %p\n", file, line, (unsigned long)size, p));
7705 }
7706 mp->next = soap->mht[h];
7707 mp->ptr = p;
7708 mp->file = file;
7709 mp->line = line;
7710 mp->live = 1;
7711 soap->mht[h] = mp;
7712 }
7713 return p;
7714 }
7715 #endif
7716
7717 /******************************************************************************/
7718 #ifdef SOAP_MEM_DEBUG
7719 SOAP_FMAC1
7720 void
7721 SOAP_FMAC2
7722 soap_track_free(struct soap *soap, const char *file, int line, void *p)
7723 { register size_t h = soap_hash_ptr(p);
7724 register struct soap_mlist *mp;
7725 for (mp = soap->mht[h]; mp; mp = mp->next)
7726 if (mp->ptr == p)
7727 break;
7728 if (mp)
7729 { if (mp->live)
7730 { free(p);
7731 if (soap->fdebug[SOAP_INDEX_TEST])
7732 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "%s(%d): free(%p)\n", file, line, p));
7733 }
7734 mp->live = 0;
7735 }
7736 else
7737 fprintf(stderr, "%s(%d): free(%p) double free of pointer malloced at %s(%d)\n", file, line, p, mp->file, mp->line);
7738 }
7739 else
7740 fprintf(stderr, "%s(%d): free(%p) pointer not malloced\n", file, line, p);
7741 }
7742 #endif
7743
7744 /******************************************************************************/
7745 #ifdef SOAP_MEM_DEBUG
7746 static void
7747 soap_track_unlink(struct soap *soap, const void *p)
7748 { register size_t h = soap_hash_ptr(p);
7749 register struct soap_mlist *mp;
7750 for (mp = soap->mht[h]; mp; mp = mp->next)
7751 if (mp->ptr == p)
7752 break;
7753 if (mp)
7754 mp->live = 0;
7755 }
7756 #endif
7757
7758 /******************************************************************************/
7759 #ifndef PALM_2
7760 SOAP_FMAC1
7761 void
7762 SOAP_FMAC2
7763 soap_dealloc(struct soap *soap, void *p)
7764 { if (soap_check_state(soap))
7765 return;
7766 if (p)
7767 { register char **q;
7768 for (q = (char**)&soap->alist; *q; q = *(char***)q)
7769 {
7770 if (*(unsigned short*)(char*)(*q - sizeof(unsigned short)) != (unsigned short)SOAP_CANARY)
7771 {
7772 #ifdef SOAP_MEM_DEBUG
7773 fprintf(stderr, "Data corruption in dynamic allocation (see logs)\n");
7774 #endif
7775 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Data corruption:\n"));
7776 DBGHEX(TEST, *q - 200, 200);
7777 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "\n"));
7778 soap->error = SOAP_MOE;
7779 return;
7780 }
7781 if (p == (void*)(*q - *(size_t*)(*q + sizeof(void*))))
7782 { *q = **(char***)q;
7783 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Freed data at %p\n", p));
7784 SOAP_FREE(soap, p);
7785 return;
7786 }
7787 }
7788 soap_delete(soap, p);
7789 }
7790 else
7791 { register char *q;
7792 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free all soap_malloc() data\n"));
7793 while (soap->alist)
7794 { q = (char*)soap->alist;
7795 if (*(unsigned short*)(char*)(q - sizeof(unsigned short)) != (unsigned short)SOAP_CANARY)
7796 {
7797 #ifdef SOAP_MEM_DEBUG
7798 fprintf(stderr, "Data corruption in dynamic allocation (see logs)\n");
7799 #endif
7800 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Data corruption:\n"));
7801 DBGHEX(TEST, q - 200, 200);
7802 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "\n"));
7803 soap->error = SOAP_MOE;
7804 return;
7805 }
7806 soap->alist = *(void**)q;
7807 q -= *(size_t*)(q + sizeof(void*));
7808 SOAP_FREE(soap, q);
7809 }
7810 /* we must assume these were deallocated: */
7811 soap->http_content = NULL;
7812 soap->action = NULL;
7813 soap->fault = NULL;
7814 soap->header = NULL;
7815 soap->userid = NULL;
7816 soap->passwd = NULL;
7817 soap->authrealm = NULL;
7818 #ifdef WITH_NTLM
7819 soap->ntlm_challenge = NULL;
7820 #endif
7821 #ifndef WITH_LEANER
7822 soap_clr_mime(soap);
7823 #endif
7824 }
7825 }
7826 #endif
7827
7828 /******************************************************************************/
7829 #ifndef PALM_2
7830 SOAP_FMAC1
7831 void
7832 SOAP_FMAC2
7833 soap_delete(struct soap *soap, void *p)
7834 { register struct soap_clist **cp;
7835 if (soap_check_state(soap))
7836 return;
7837 cp = &soap->clist;
7838 if (p)
7839 { while (*cp)
7840 { if (p == (*cp)->ptr)
7841 { register struct soap_clist *q = *cp;
7842 *cp = q->next;
7843 if (q->fdelete(q))
7844 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not dealloc data %p: deletion callback failed for object type %d\n", q->ptr, q->type));
7845 #ifdef SOAP_MEM_DEBUG
7846 fprintf(stderr, "new(object type = %d) = %p not freed: deletion callback failed\n", q->type, q->ptr);
7847 #endif
7848 }
7849 SOAP_FREE(soap, q);
7850 return;
7851 }
7852 cp = &(*cp)->next;
7853 }
7854 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not dealloc data %p: address not in list\n", p));
7855 }
7856 else
7857 { while (*cp)
7858 { register struct soap_clist *q = *cp;
7859 *cp = q->next;
7860 if (q->fdelete(q))
7861 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not dealloc data %p: deletion callback failed for object type %d\n", q->ptr, q->type));
7862 #ifdef SOAP_MEM_DEBUG
7863 fprintf(stderr, "new(object type = %d) = %p not freed: deletion callback failed\n", q->type, q->ptr);
7864 #endif
7865 }
7866 SOAP_FREE(soap, q);
7867 }
7868 }
7869 soap->fault = NULL; /* this was possibly deallocated */
7870 soap->header = NULL; /* this was possibly deallocated */
7871 }
7872 #endif
7873
7874 /******************************************************************************/
7875 #ifndef PALM_2
7876 SOAP_FMAC1
7877 void
7878 SOAP_FMAC2
7879 soap_delegate_deletion(struct soap *soap, struct soap *soap_to)
7880 { register struct soap_clist *cp;
7881 register char **q;
7882 #ifdef SOAP_MEM_DEBUG
7883 register void *p;
7884 register struct soap_mlist **mp, *mq;
7885 size_t h;
7886 #endif
7887 for (q = (char**)&soap->alist; *q; q = *(char***)q)
7888 {
7889 if (*(unsigned short*)(char*)(*q - sizeof(unsigned short)) != (unsigned short)SOAP_CANARY)
7890 {
7891 #ifdef SOAP_MEM_DEBUG
7892 fprintf(stderr, "Data corruption in dynamic allocation (see logs)\n");
7893 #endif
7894 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Data corruption:\n"));
7895 DBGHEX(TEST, *q - 200, 200);
7896 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "\n"));
7897 soap->error = SOAP_MOE;
7898 return;
7899 }
7900 #ifdef SOAP_MEM_DEBUG
7901 p = (void*)(*q - *(size_t*)(*q + sizeof(void*)));
7902 h = soap_hash_ptr(p);
7903 for (mp = &soap->mht[h]; *mp; mp = &(*mp)->next)
7904 { if ((*mp)->ptr == p)
7905 { mq = *mp;
7906 *mp = mq->next;
7907 mq->next = soap_to->mht[h];
7908 soap_to->mht[h] = mq;
7909 break;
7910 }
7911 }
7912 #endif
7913 }
7914 *q = (char*)soap_to->alist;
7915 soap_to->alist = soap->alist;
7916 soap->alist = NULL;
7917 #ifdef SOAP_MEM_DEBUG
7918 cp = soap->clist;
7919 while (cp)
7920 { h = soap_hash_ptr(cp);
7921 for (mp = &soap->mht[h]; *mp; mp = &(*mp)->next)
7922 { if ((*mp)->ptr == cp)
7923 { mq = *mp;
7924 *mp = mq->next;
7925 mq->next = soap_to->mht[h];
7926 soap_to->mht[h] = mq;
7927 break;
7928 }
7929 }
7930 cp = cp->next;
7931 }
7932 #endif
7933 cp = soap_to->clist;
7934 if (cp)
7935 { while (cp->next)
7936 cp = cp->next;
7937 cp->next = soap->clist;
7938 }
7939 else
7940 soap_to->clist = soap->clist;
7941 soap->clist = NULL;
7942 }
7943 #endif
7944
7945 /******************************************************************************/
7946 #ifndef PALM_2
7947 SOAP_FMAC1
7948 struct soap_clist *
7949 SOAP_FMAC2
7950 soap_link(struct soap *soap, void *p, int t, int n, int (*fdelete)(struct soap_clist*))
7951 { register struct soap_clist *cp;
7952 if ((cp = (struct soap_clist*)SOAP_MALLOC(soap, sizeof(struct soap_clist))))
7953 { cp->next = soap->clist;
7954 cp->type = t;
7955 cp->size = n;
7956 cp->ptr = p;
7957 cp->fdelete = fdelete;
7958 soap->clist = cp;
7959 }
7960 return cp;
7961 }
7962 #endif
7963
7964 /******************************************************************************/
7965 #ifndef PALM_2
7966 SOAP_FMAC1
7967 int
7968 SOAP_FMAC2
7969 soap_unlink(struct soap *soap, const void *p)
7970 { register char **q;
7971 register struct soap_clist **cp;
7972 if (soap && p)
7973 { for (q = (char**)&soap->alist; *q; q = *(char***)q)
7974 { if (p == (void*)(*q - *(size_t*)(*q + sizeof(void*))))
7975 { *q = **(char***)q;
7976 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unlinked data %p\n", p));
7977 #ifdef SOAP_MEM_DEBUG
7978 soap_track_unlink(soap, p);
7979 #endif
7980 return SOAP_OK; /* found and removed from dealloc chain */
7981 }
7982 }
7983 for (cp = &soap->clist; *cp; cp = &(*cp)->next)
7984 { if (p == (*cp)->ptr)
7985 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unlinked class instance %p\n", p));
7986 q = (char**)*cp;
7987 *cp = (*cp)->next;
7988 SOAP_FREE(soap, q);
7989 return SOAP_OK; /* found and removed from dealloc chain */
7990 }
7991 }
7992 }
7993 return SOAP_ERR;
7994 }
7995 #endif
7996
7997 /******************************************************************************/
7998 #ifndef WITH_NOIDREF
7999 #ifndef PALM_2
8000 SOAP_FMAC1
8001 int
8002 SOAP_FMAC2
8003 soap_lookup_type(struct soap *soap, const char *id)
8004 { register struct soap_ilist *ip;
8005 if (id && *id)
8006 { ip = soap_lookup(soap, id);
8007 if (ip)
8008 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Lookup id='%s' type=%d\n", id, ip->type));
8009 return ip->type;
8010 }
8011 }
8012 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "lookup type id='%s' NOT FOUND! Need to get it from xsi:type\n", id));
8013 return 0;
8014 }
8015 #endif
8016 #endif
8017
8018 /******************************************************************************/
8019 #ifndef WITH_NOIDREF
8020 #ifndef PALM_2
8021 SOAP_FMAC1
8022 void*
8023 SOAP_FMAC2
8024 soap_id_lookup(struct soap *soap, const char *id, void **p, int t, size_t n, unsigned int k)
8025 { struct soap_ilist *ip;
8026 void **q;
8027 if (!p || !id || !*id)
8028 return p;
8029 ip = soap_lookup(soap, id); /* lookup pointer to hash table entry for string id */
8030 if (!ip)
8031 { if (!(ip = soap_enter(soap, id))) /* new hash table entry for string id */
8032 return NULL;
8033 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Forwarding first href='%s' type=%d %p (%u bytes)\n", id, t, p, (unsigned int)n));
8034 ip->type = t;
8035 ip->size = n;
8036 ip->link = p;
8037 ip->copy = NULL;
8038 ip->flist = NULL;
8039 ip->ptr = NULL;
8040 ip->level = k;
8041 *p = NULL;
8042 }
8043 else if (ip->ptr)
8044 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolved href='%s' type=%d location=%p (%u bytes)\n", id, t, ip->ptr, (unsigned int)n));
8045 if (ip->type != t)
8046 { strcpy(soap->id, id);
8047 soap->error = SOAP_HREF;
8048 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Type incompatibility: href='%s' id-type=%d href-type=%d\n", id, ip->type, t));
8049 return NULL;
8050 }
8051 while (ip->level < k)
8052 { q = (void**)soap_malloc(soap, sizeof(void*));
8053 if (!q)
8054 return NULL;
8055 *p = (void*)q;
8056 p = q;
8057 k--;
8058 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Descending one level...\n"));
8059 }
8060 *p = ip->ptr;
8061 }
8062 else if (ip->level > k)
8063 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolving level %u pointers to href='%s'\n", ip->level, id));
8064 while (ip->level > k)
8065 { void *s, **r = &ip->link;
8066 q = (void**)ip->link;
8067 while (q)
8068 { *r = (void*)soap_malloc(soap, sizeof(void*));
8069 if (!*r)
8070 return NULL;
8071 s = *q;
8072 *q = *r;
8073 r = (void**)*r;
8074 q = (void**)s;
8075 }
8076 *r = NULL;
8077 ip->size = n;
8078 ip->copy = NULL;
8079 ip->level = ip->level - 1;
8080 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Descending one level...\n"));
8081 }
8082 q = (void**)ip->link;
8083 ip->link = p;
8084 *p = (void*)q;
8085 }
8086 else
8087 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Forwarded href='%s' type=%d location=%p (%u bytes)\n", id, t, p, (unsigned int)n));
8088 while (ip->level < k)
8089 { q = (void**)soap_malloc(soap, sizeof(void*));
8090 if (!q)
8091 return NULL;
8092 *p = q;
8093 p = q;
8094 k--;
8095 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Descending one level...\n"));
8096 }
8097 q = (void**)ip->link;
8098 ip->link = p;
8099 *p = (void*)q;
8100 }
8101 return p;
8102 }
8103 #endif
8104 #endif
8105
8106 /******************************************************************************/
8107 #ifndef WITH_NOIDREF
8108 #ifndef PALM_2
8109 SOAP_FMAC1
8110 void*
8111 SOAP_FMAC2
8112 soap_id_forward(struct soap *soap, const char *href, void *p, size_t len, int st, int tt, size_t n, unsigned int k, void (*fcopy)(struct soap*, int, int, void*, size_t, const void*, size_t))
8113 { struct soap_ilist *ip;
8114 if (!p || !href || !*href)
8115 return p;
8116 ip = soap_lookup(soap, href); /* lookup pointer to hash table entry for string id */
8117 if (!ip)
8118 { if (!(ip = soap_enter(soap, href))) /* new hash table entry for string id */
8119 return NULL;
8120 ip->type = st;
8121 ip->size = n;
8122 ip->link = NULL;
8123 ip->copy = NULL;
8124 ip->ptr = NULL;
8125 ip->level = 0;
8126 ip->flist = NULL;
8127 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "New entry href='%s' type=%d size=%lu level=%d location=%p\n", href, st, (unsigned long)n, k, p));
8128 }
8129 else if (ip->type != st || (ip->level == k && ip->size != n))
8130 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Type incompatibility id='%s' expect type=%d size=%lu level=%u got type=%d size=%lu\n", href, ip->type, (unsigned long)ip->size, k, st, (unsigned long)n));
8131 strcpy(soap->id, href);
8132 soap->error = SOAP_HREF;
8133 return NULL;
8134 }
8135 if (fcopy || n < sizeof(void*) || *href != '#')
8136 { register struct soap_flist *fp = (struct soap_flist*)SOAP_MALLOC(soap, sizeof(struct soap_flist));
8137 if (!fp)
8138 { soap->error = SOAP_EOM;
8139 return NULL;
8140 }
8141 fp->next = ip->flist;
8142 fp->type = tt;
8143 fp->ptr = p;
8144 fp->level = k;
8145 fp->len = len;
8146 if (fcopy)
8147 fp->fcopy = fcopy;
8148 else
8149 fp->fcopy = soap_fcopy;
8150 ip->flist = fp;
8151 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Forwarding type=%d (target type=%d) size=%lu location=%p level=%u len=%lu href='%s'\n", st, tt, (unsigned long)n, p, k, (unsigned long)len, href));
8152 }
8153 else
8154 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Forwarding copying address %p for type=%d href='%s'\n", p, st, href));
8155 *(void**)p = ip->copy;
8156 ip->copy = p;
8157 }
8158 return p;
8159 }
8160 #endif
8161 #endif
8162
8163 /******************************************************************************/
8164 #ifndef PALM_2
8165 SOAP_FMAC1
8166 void*
8167 SOAP_FMAC2
8168 soap_id_enter(struct soap *soap, const char *id, void *p, int t, size_t n, unsigned int k, const char *type, const char *arrayType, void *(*finstantiate)(struct soap*, int, const char*, const char*, size_t*))
8169 {
8170 #ifndef WITH_NOIDREF
8171 struct soap_ilist *ip;
8172 #endif
8173 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Enter id='%s' type=%d loc=%p size=%lu level=%u\n", id, t, p, (unsigned long)n, k));
8174 soap->alloced = 0;
8175 if (!p)
8176 { if (finstantiate)
8177 p = finstantiate(soap, t, type, arrayType, &n);
8178 else
8179 p = soap_malloc(soap, n);
8180 if (p)
8181 soap->alloced = 1;
8182 }
8183 #ifndef WITH_NOIDREF
8184 if (!id || !*id)
8185 #endif
8186 return p;
8187 #ifndef WITH_NOIDREF
8188 ip = soap_lookup(soap, id); /* lookup pointer to hash table entry for string id */
8189 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Lookup entry id='%s for location=%p'\n", id, p));
8190 if (!ip)
8191 { if (!(ip = soap_enter(soap, id))) /* new hash table entry for string id */
8192 return NULL;
8193 ip->type = t;
8194 ip->link = NULL;
8195 ip->copy = NULL;
8196 ip->flist = NULL;
8197 ip->size = n;
8198 ip->ptr = p;
8199 ip->level = k;
8200 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "New entry id='%s' type=%d size=%lu level=%u location=%p\n", id, t, (unsigned long)n, k, p));
8201 }
8202 else if ((ip->type != t || (ip->level == k && ip->size != n)) && (ip->copy || ip->flist))
8203 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Type incompatibility id='%s' expect type=%d size=%lu level=%u got type=%d size=%lu\n", id, ip->type, (unsigned long)ip->size, k, t, (unsigned long)n));
8204 strcpy(soap->id, id);
8205 soap->error = SOAP_HREF;
8206 return NULL;
8207 }
8208 else if (ip->ptr)
8209 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Multiply defined id='%s'\n", id));
8210 strcpy(soap->id, id);
8211 soap->error = SOAP_DUPLICATE_ID;
8212 return NULL;
8213 }
8214 else
8215 { ip->size = n;
8216 ip->ptr = p;
8217 ip->level = k;
8218 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Update entry id='%s' type=%d location=%p size=%lu level=%u\n", id, t, p, (unsigned long)n, k));
8219 }
8220 return ip->ptr;
8221 #endif
8222 }
8223 #endif
8224
8225 /******************************************************************************/
8226 #ifndef PALM_2
8227 SOAP_FMAC1
8228 void
8229 SOAP_FMAC2
8230 soap_fcopy(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
8231 { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Copying data type=%d (target type=%d) %p -> %p (%lu bytes)\n", st, tt, q, p, (unsigned long)n));
8232 memcpy(p, q, n);
8233 (void)soap; (void)st; (void)tt; (void)len;
8234 }
8235 #endif
8236
8237 /******************************************************************************/
8238 #ifndef PALM_1
8239 SOAP_FMAC1
8240 int
8241 SOAP_FMAC2
8242 soap_end_send(struct soap *soap)
8243 {
8244 #ifndef WITH_LEANER
8245 int err;
8246 if (soap->dime.list)
8247 { /* SOAP body referenced attachments must appear first */
8248 soap->dime.last->next = soap->dime.first;
8249 soap->dime.first = soap->dime.list->next;
8250 soap->dime.list->next = NULL;
8251 soap->dime.last = soap->dime.list;
8252 }
8253 if (!(err = soap_putdime(soap)))
8254 err = soap_putmime(soap);
8255 soap->mime.list = NULL;
8256 soap->mime.first = NULL;
8257 soap->mime.last = NULL;
8258 soap->dime.list = NULL;
8259 soap->dime.first = NULL;
8260 soap->dime.last = NULL;
8261 if (err)
8262 return err;
8263 #endif
8264 return soap_end_send_flush(soap);
8265 }
8266 #endif
8267
8268 /******************************************************************************/
8269 #ifndef PALM_1
8270 SOAP_FMAC1
8271 int
8272 SOAP_FMAC2
8273 soap_end_send_flush(struct soap *soap)
8274 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End send mode=0x%x\n", soap->mode));
8275 if (soap->mode & SOAP_IO) /* need to flush the remaining data in buffer */
8276 { if (soap_flush(soap))
8277 #ifdef WITH_ZLIB
8278 { if (soap->mode & SOAP_ENC_ZLIB && soap->zlib_state == SOAP_ZLIB_DEFLATE)
8279 { soap->zlib_state = SOAP_ZLIB_NONE;
8280 deflateEnd(soap->d_stream);
8281 }
8282 return soap->error;
8283 }
8284 #else
8285 return soap->error;
8286 #endif
8287 #ifdef WITH_ZLIB
8288 if (soap->mode & SOAP_ENC_ZLIB)
8289 { int r;
8290 soap->d_stream->avail_in = 0;
8291 do
8292 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflating remainder\n"));
8293 r = deflate(soap->d_stream, Z_FINISH);
8294 if (soap->d_stream->avail_out != SOAP_BUFLEN)
8295 { if (soap_flush_raw(soap, soap->z_buf, SOAP_BUFLEN - soap->d_stream->avail_out))
8296 { soap->zlib_state = SOAP_ZLIB_NONE;
8297 deflateEnd(soap->d_stream);
8298 return soap->error;
8299 }
8300 soap->d_stream->next_out = (Byte*)soap->z_buf;
8301 soap->d_stream->avail_out = SOAP_BUFLEN;
8302 }
8303 } while (r == Z_OK);
8304 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflated total %lu->%lu bytes\n", soap->d_stream->total_in, soap->d_stream->total_out));
8305 soap->z_ratio_out = (float)soap->d_stream->total_out / (float)soap->d_stream->total_in;
8306 soap->mode &= ~SOAP_ENC_ZLIB;
8307 soap->zlib_state = SOAP_ZLIB_NONE;
8308 if (deflateEnd(soap->d_stream) != Z_OK || r != Z_STREAM_END)
8309 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unable to end deflate: %s\n", soap->d_stream->msg ? soap->d_stream->msg : SOAP_STR_EOS));
8310 return soap->error = SOAP_ZLIB_ERROR;
8311 }
8312 #ifdef WITH_GZIP
8313 if (soap->zlib_out != SOAP_ZLIB_DEFLATE)
8314 { soap->z_buf[0] = soap->z_crc & 0xFF;
8315 soap->z_buf[1] = (soap->z_crc >> 8) & 0xFF;
8316 soap->z_buf[2] = (soap->z_crc >> 16) & 0xFF;
8317 soap->z_buf[3] = (soap->z_crc >> 24) & 0xFF;
8318 soap->z_buf[4] = soap->d_stream->total_in & 0xFF;
8319 soap->z_buf[5] = (soap->d_stream->total_in >> 8) & 0xFF;
8320 soap->z_buf[6] = (soap->d_stream->total_in >> 16) & 0xFF;
8321 soap->z_buf[7] = (soap->d_stream->total_in >> 24) & 0xFF;
8322 if (soap_flush_raw(soap, soap->z_buf, 8))
8323 return soap->error;
8324 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "gzip crc32=%lu\n", (unsigned long)soap->z_crc));
8325 }
8326 #endif
8327 }
8328 #endif
8329 if ((soap->mode & SOAP_IO) == SOAP_IO_STORE)
8330 { char *p;
8331 #ifndef WITH_NOHTTP
8332 if (!(soap->mode & SOAP_ENC_XML))
8333 { soap->mode--;
8334 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Sending buffered message of length %u\n", (unsigned int)soap->blist->size));
8335 if (soap->status >= SOAP_POST)
8336 soap->error = soap->fpost(soap, soap->endpoint, soap->host, soap->port, soap->path, soap->action, soap->blist->size);
8337 else if (soap->status != SOAP_STOP)
8338 soap->error = soap->fresponse(soap, soap->status, soap->blist->size);
8339 if (soap->error || soap_flush(soap))
8340 return soap->error;
8341 soap->mode++;
8342 }
8343 #endif
8344 for (p = soap_first_block(soap, NULL); p; p = soap_next_block(soap, NULL))
8345 { DBGMSG(SENT, p, soap_block_size(soap, NULL));
8346 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Send %u bytes to socket=%d/fd=%d\n", (unsigned int)soap_block_size(soap, NULL), soap->socket, soap->sendfd));
8347 if ((soap->error = soap->fsend(soap, p, soap_block_size(soap, NULL))))
8348 { soap_end_block(soap, NULL);
8349 return soap->error;
8350 }
8351 }
8352 soap_end_block(soap, NULL);
8353 if (soap->fpreparefinalsend && (soap->error = soap->fpreparefinalsend(soap)))
8354 return soap->error;
8355 }
8356 #ifndef WITH_LEANER
8357 else if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK)
8358 { DBGMSG(SENT, "\r\n0\r\n\r\n", 7);
8359 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Send 7 bytes to socket=%d/fd=%d\n", soap->socket, soap->sendfd));
8360 if ((soap->error = soap->fsend(soap, "\r\n0\r\n\r\n", 7)))
8361 return soap->error;
8362 }
8363 #endif
8364 }
8365 #ifdef WITH_TCPFIN
8366 #ifdef WITH_OPENSSL
8367 if (!soap->ssl && soap_valid_socket(soap->socket) && !soap->keep_alive && !(soap->omode & SOAP_IO_UDP))
8368 soap->fshutdownsocket(soap, soap->socket, SOAP_SHUT_WR); /* Send TCP FIN */
8369 #else
8370 if (soap_valid_socket(soap->socket) && !soap->keep_alive && !(soap->omode & SOAP_IO_UDP))
8371 soap->fshutdownsocket(soap, soap->socket, SOAP_SHUT_WR); /* Send TCP FIN */
8372 #endif
8373 #endif
8374 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of send phase\n"));
8375 soap->omode &= ~SOAP_SEC_WSUID;
8376 soap->count = 0;
8377 soap->part = SOAP_END;
8378 return SOAP_OK;
8379 }
8380 #endif
8381
8382 /******************************************************************************/
8383 #ifndef PALM_1
8384 SOAP_FMAC1
8385 int
8386 SOAP_FMAC2
8387 soap_end_recv(struct soap *soap)
8388 { soap->part = SOAP_END;
8389 #ifndef WITH_LEAN
8390 soap->wsuid = NULL; /* reset before next send */
8391 soap->c14nexclude = NULL; /* reset before next send */
8392 #endif
8393 #ifndef WITH_LEANER
8394 soap->ffilterrecv = NULL;
8395 if ((soap->mode & SOAP_ENC_DIME) && soap_getdime(soap))
8396 { soap->dime.first = NULL;
8397 soap->dime.last = NULL;
8398 return soap->error;
8399 }
8400 soap->dime.list = soap->dime.first;
8401 soap->dime.first = NULL;
8402 soap->dime.last = NULL;
8403 /* Check if MIME attachments and mime-post-check flag is set, if so call soap_resolve() and return */
8404 if (soap->mode & SOAP_ENC_MIME)
8405 { if (soap->mode & SOAP_MIME_POSTCHECK)
8406 { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Post checking MIME attachments\n"));
8407 if (!soap->keep_alive)
8408 soap->keep_alive = -1;
8409 #ifndef WITH_NOIDREF
8410 soap_resolve(soap);
8411 #endif
8412 return SOAP_OK;
8413 }
8414 if (soap_getmime(soap))
8415 return soap->error;
8416 }
8417 soap->mime.list = soap->mime.first;
8418 soap->mime.first = NULL;
8419 soap->mime.last = NULL;
8420 soap->mime.boundary = NULL;
8421 if (soap->xlist)
8422 { struct soap_multipart *content;
8423 for (content = soap->mime.list; content; content = content->next)
8424 soap_resolve_attachment(soap, content);
8425 }
8426 #endif
8427 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "End of receive message ok\n"));
8428 #ifdef WITH_ZLIB
8429 if (soap->mode & SOAP_ENC_ZLIB)
8430 { /* Make sure end of compressed content is reached */
8431 while (soap->d_stream->next_out != Z_NULL)
8432 if ((int)soap_get1(soap) == EOF)
8433 break;
8434 soap->mode &= ~SOAP_ENC_ZLIB;
8435 memcpy(soap->buf, soap->z_buf, SOAP_BUFLEN);
8436 soap->bufidx = (char*)soap->d_stream->next_in - soap->z_buf;
8437 soap->buflen = soap->z_buflen;
8438 soap->zlib_state = SOAP_ZLIB_NONE;
8439 if (inflateEnd(soap->d_stream) != Z_OK)
8440 return soap->error = SOAP_ZLIB_ERROR;
8441 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Inflate end ok\n"));
8442 #ifdef WITH_GZIP
8443 if (soap->zlib_in == SOAP_ZLIB_GZIP)
8444 { soap_wchar c;
8445 short i;
8446 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Inflate gzip crc check\n"));
8447 for (i = 0; i < 8; i++)
8448 { if ((int)(c = soap_get1(soap)) == EOF)
8449 { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Gzip error: unable to read crc value\n"));
8450 return soap->error = SOAP_ZLIB_ERROR;
8451 }
8452 soap->z_buf[i] = (char)c;
8453 }
8454 if (soap->z_crc != ((uLong)(unsigned char)soap->z_buf[0] | ((uLong)(unsigned char)soap->z_buf[1] << 8) | ((uLong)(unsigned char)soap->z_buf[2] << 16) | ((uLong)(unsigned char)soap->z_buf[3] << 24)))
8455 { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Gzip inflate error: crc check failed, message corrupted? (crc32=%lu)\n", (unsigned long)soap->z_crc));
8456 return soap->error = SOAP_ZLIB_ERROR;
8457 }
8458 if (soap->d_stream->total_out != ((uLong)(unsigned char)soap->z_buf[4] | ((uLong)(unsigned char)soap->z_buf[5] << 8) | ((uLong)(unsigned char)soap->z_buf[6] << 16) | ((uLong)(unsigned char)soap->z_buf[7] << 24)))
8459 { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Gzip inflate error: incorrect message length\n"));
8460 return soap->error = SOAP_ZLIB_ERROR;
8461 }
8462 }
8463 soap->zlib_in = SOAP_ZLIB_NONE;
8464 #endif
8465 }
8466 #endif
8467 if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK)
8468 while (soap->ahead != EOF && !soap_recv_raw(soap))
8469 ;
8470 #ifndef WITH_NOIDREF
8471 if (soap_resolve(soap))
8472 return soap->error;
8473 #endif
8474 #ifndef WITH_LEANER
8475 if (soap->xlist)
8476 { if (soap->mode & SOAP_ENC_MTOM)
8477 return soap->error = SOAP_MIME_HREF;
8478 return soap->error = SOAP_DIME_HREF;
8479 }
8480 #endif
8481 soap_free_ns(soap);
8482 #ifndef WITH_LEANER
8483 if (soap->fpreparefinalrecv)
8484 return soap->error = soap->fpreparefinalrecv(soap);
8485 #endif
8486 return SOAP_OK;
8487 }
8488 #endif
8489
8490 /******************************************************************************/
8491 #ifndef PALM_1
8492 SOAP_FMAC1
8493 void
8494 SOAP_FMAC2
8495 soap_free_temp(struct soap *soap)
8496 { register struct soap_attribute *tp, *tq;
8497 register struct Namespace *ns;
8498 soap_free_ns(soap);
8499 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free any remaining temp blocks\n"));
8500 while (soap->blist)
8501 soap_end_block(soap, NULL);
8502 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free attribute storage\n"));
8503 for (tp = soap->attributes; tp; tp = tq)
8504 { tq = tp->next;
8505 if (tp->value)
8506 SOAP_FREE(soap, tp->value);
8507 SOAP_FREE(soap, tp);
8508 }
8509 soap->attributes = NULL;
8510 #ifdef WITH_FAST
8511 if (soap->labbuf)
8512 SOAP_FREE(soap, soap->labbuf);
8513 soap->labbuf = NULL;
8514 soap->lablen = 0;
8515 soap->labidx = 0;
8516 #endif
8517 ns = soap->local_namespaces;
8518 if (ns)
8519 { for (; ns->id; ns++)
8520 { if (ns->out)
8521 { SOAP_FREE(soap, ns->out);
8522 ns->out = NULL;
8523 }
8524 }
8525 SOAP_FREE(soap, soap->local_namespaces);
8526 soap->local_namespaces = NULL;
8527 }
8528 #ifndef WITH_LEANER
8529 while (soap->xlist)
8530 { struct soap_xlist *xp = soap->xlist->next;
8531 SOAP_FREE(soap, soap->xlist);
8532 soap->xlist = xp;
8533 }
8534 #endif
8535 #ifndef WITH_NOIDREF
8536 soap_free_pht(soap);
8537 soap_free_iht(soap);
8538 #endif
8539 }
8540 #endif
8541
8542 /******************************************************************************/
8543 #ifndef PALM_1
8544 static void
8545 soap_free_ns(struct soap *soap)
8546 { register struct soap_nlist *np, *nq;
8547 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free namespace stack\n"));
8548 for (np = soap->nlist; np; np = nq)
8549 { nq = np->next;
8550 SOAP_FREE(soap, np);
8551 }
8552 soap->nlist = NULL;
8553 }
8554 #endif
8555
8556 /******************************************************************************/
8557 #ifndef PALM_1
8558 #if !defined(WITH_LEAN) || defined(SOAP_DEBUG)
8559 static void
8560 soap_init_logs(struct soap *soap)
8561 { int i;
8562 for (i = 0; i < SOAP_MAXLOGS; i++)
8563 { soap->logfile[i] = NULL;
8564 soap->fdebug[i] = NULL;
8565 }
8566 }
8567 #endif
8568 #endif
8569
8570 /******************************************************************************/
8571 #if !defined(WITH_LEAN) || defined(SOAP_DEBUG)
8572 SOAP_FMAC1
8573 void
8574 SOAP_FMAC2
8575 soap_open_logfile(struct soap *soap, int i)
8576 { if (soap->logfile[i])
8577 soap->fdebug[i] = fopen(soap->logfile[i], i < 2 ? "ab" : "a");
8578 }
8579 #endif
8580
8581 /******************************************************************************/
8582 #ifdef SOAP_DEBUG
8583 static void
8584 soap_close_logfile(struct soap *soap, int i)
8585 { if (soap->fdebug[i])
8586 { fclose(soap->fdebug[i]);
8587 soap->fdebug[i] = NULL;
8588 }
8589 }
8590 #endif
8591
8592 /******************************************************************************/
8593 #ifdef SOAP_DEBUG
8594 SOAP_FMAC1
8595 void
8596 SOAP_FMAC2
8597 soap_close_logfiles(struct soap *soap)
8598 { int i;
8599 for (i = 0; i < SOAP_MAXLOGS; i++)
8600 soap_close_logfile(soap, i);
8601 }
8602 #endif
8603
8604 /******************************************************************************/
8605 #ifdef SOAP_DEBUG
8606 static void
8607 soap_set_logfile(struct soap *soap, int i, const char *logfile)
8608 { const char *s;
8609 char *t = NULL;
8610 soap_close_logfile(soap, i);
8611 s = soap->logfile[i];
8612 soap->logfile[i] = logfile;
8613 if (s)
8614 SOAP_FREE(soap, (void*)s);
8615 if (logfile)
8616 if ((t = (char*)SOAP_MALLOC(soap, strlen(logfile) + 1)))
8617 strcpy(t, logfile);
8618 soap->logfile[i] = t;
8619 }
8620 #endif
8621
8622 /******************************************************************************/
8623 SOAP_FMAC1
8624 void
8625 SOAP_FMAC2
8626 soap_set_recv_logfile(struct soap *soap, const char *logfile)
8627 {
8628 #ifdef SOAP_DEBUG
8629 soap_set_logfile(soap, SOAP_INDEX_RECV, logfile);
8630 #endif
8631 }
8632
8633 /******************************************************************************/
8634 SOAP_FMAC1
8635 void
8636 SOAP_FMAC2
8637 soap_set_sent_logfile(struct soap *soap, const char *logfile)
8638 {
8639 #ifdef SOAP_DEBUG
8640 soap_set_logfile(soap, SOAP_INDEX_SENT, logfile);
8641 #endif
8642 }
8643
8644 /******************************************************************************/
8645 SOAP_FMAC1
8646 void
8647 SOAP_FMAC2
8648 soap_set_test_logfile(struct soap *soap, const char *logfile)
8649 {
8650 #ifdef SOAP_DEBUG
8651 soap_set_logfile(soap, SOAP_INDEX_TEST, logfile);
8652 #endif
8653 }
8654
8655 /******************************************************************************/
8656 #ifndef PALM_1
8657 SOAP_FMAC1
8658 struct soap*
8659 SOAP_FMAC2
8660 soap_copy(const struct soap *soap)
8661 { return soap_copy_context((struct soap*)malloc(sizeof(struct soap)), soap);
8662 }
8663 #endif
8664
8665 /******************************************************************************/
8666 #ifndef PALM_1
8667 SOAP_FMAC1
8668 struct soap*
8669 SOAP_FMAC2
8670 soap_copy_context(struct soap *copy, const struct soap *soap)
8671 { if (copy == soap)
8672 return copy;
8673 if (soap_check_state(soap))
8674 return NULL;
8675 if (copy)
8676 { register struct soap_plugin *p = NULL;
8677 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying context\n"));
8678 #ifdef __cplusplus
8679 *copy = *soap;
8680 #else
8681 memcpy(copy, soap, sizeof(struct soap));
8682 #endif
8683 copy->state = SOAP_COPY;
8684 copy->error = SOAP_OK;
8685 copy->userid = NULL;
8686 copy->passwd = NULL;
8687 #ifdef WITH_NTLM
8688 copy->ntlm_challenge = NULL;
8689 #endif
8690 copy->nlist = NULL;
8691 copy->blist = NULL;
8692 copy->clist = NULL;
8693 copy->alist = NULL;
8694 copy->attributes = NULL;
8695 copy->labbuf = NULL;
8696 copy->lablen = 0;
8697 copy->labidx = 0;
8698 #ifdef SOAP_MEM_DEBUG
8699 soap_init_mht(copy);
8700 #endif
8701 #if !defined(WITH_LEAN) || defined(SOAP_DEBUG)
8702 soap_init_logs(copy);
8703 #endif
8704 #ifdef SOAP_DEBUG
8705 soap_set_test_logfile(copy, soap->logfile[SOAP_INDEX_TEST]);
8706 soap_set_sent_logfile(copy, soap->logfile[SOAP_INDEX_SENT]);
8707 soap_set_recv_logfile(copy, soap->logfile[SOAP_INDEX_RECV]);
8708 #endif
8709 copy->namespaces = soap->local_namespaces;
8710 copy->local_namespaces = NULL;
8711 soap_set_local_namespaces(copy); /* copy content of soap->local_namespaces */
8712 copy->namespaces = soap->namespaces; /* point to shared read-only namespaces table */
8713 #ifdef WITH_C_LOCALE
8714 # ifdef WIN32
8715 copy->c_locale = _create_locale(LC_ALL, "C");
8716 # else
8717 copy->c_locale = duplocale(soap->c_locale);
8718 # endif
8719 #else
8720 copy->c_locale = NULL;
8721 #endif
8722 #ifdef WITH_OPENSSL
8723 copy->bio = NULL;
8724 copy->ssl = NULL;
8725 copy->session = NULL;
8726 #endif
8727 #ifdef WITH_GNUTLS
8728 copy->session = NULL;
8729 #endif
8730 #ifdef WITH_ZLIB
8731 copy->d_stream = (z_stream*)SOAP_MALLOC(copy, sizeof(z_stream));
8732 copy->d_stream->zalloc = Z_NULL;
8733 copy->d_stream->zfree = Z_NULL;
8734 copy->d_stream->opaque = Z_NULL;
8735 copy->z_buf = NULL;
8736 #endif
8737 #ifndef WITH_NOIDREF
8738 soap_init_iht(copy);
8739 soap_init_pht(copy);
8740 #endif
8741 copy->header = NULL;
8742 copy->fault = NULL;
8743 copy->action = NULL;
8744 #ifndef WITH_LEAN
8745 #ifdef WITH_COOKIES
8746 copy->cookies = soap_copy_cookies(copy, soap);
8747 #else
8748 copy->cookies = NULL;
8749 #endif
8750 #endif
8751 copy->plugins = NULL;
8752 for (p = soap->plugins; p; p = p->next)
8753 { register struct soap_plugin *q = (struct soap_plugin*)SOAP_MALLOC(copy, sizeof(struct soap_plugin));
8754 if (!q)
8755 return NULL;
8756 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying plugin '%s'\n", p->id));
8757 *q = *p;
8758 if (p->fcopy && p->fcopy(copy, q, p))
8759 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not copy plugin '%s'\n", p->id));
8760 SOAP_FREE(copy, q);
8761 return NULL;
8762 }
8763 q->next = copy->plugins;
8764 copy->plugins = q;
8765 }
8766 }
8767 return copy;
8768 }
8769 #endif
8770
8771 /******************************************************************************/
8772 #ifndef PALM_1
8773 SOAP_FMAC1
8774 void
8775 SOAP_FMAC2
8776 soap_copy_stream(struct soap *copy, struct soap *soap)
8777 { struct soap_attribute *tp = NULL, *tq;
8778 if (copy == soap)
8779 return;
8780 copy->header = soap->header;
8781 copy->mode = soap->mode;
8782 copy->imode = soap->imode;
8783 copy->omode = soap->omode;
8784 copy->master = soap->master;
8785 copy->socket = soap->socket;
8786 copy->sendsk = soap->sendsk;
8787 copy->recvsk = soap->recvsk;
8788 copy->recv_timeout = soap->recv_timeout;
8789 copy->send_timeout = soap->send_timeout;
8790 #if defined(__cplusplus) && !defined(WITH_LEAN)
8791 copy->os = soap->os;
8792 copy->is = soap->is;
8793 #endif
8794 copy->sendfd = soap->sendfd;
8795 copy->recvfd = soap->recvfd;
8796 copy->bufidx = soap->bufidx;
8797 copy->buflen = soap->buflen;
8798 copy->ahead = soap->ahead;
8799 copy->cdata = soap->cdata;
8800 copy->chunksize = soap->chunksize;
8801 copy->chunkbuflen = soap->chunkbuflen;
8802 copy->keep_alive = soap->keep_alive;
8803 copy->tcp_keep_alive = soap->tcp_keep_alive;
8804 copy->tcp_keep_idle = soap->tcp_keep_idle;
8805 copy->tcp_keep_intvl = soap->tcp_keep_intvl;
8806 copy->tcp_keep_cnt = soap->tcp_keep_cnt;
8807 copy->max_keep_alive = soap->max_keep_alive;
8808 #ifndef WITH_NOIO
8809 copy->peer = soap->peer;
8810 copy->peerlen = soap->peerlen;
8811 copy->ip = soap->ip;
8812 copy->port = soap->port;
8813 memcpy(copy->host, soap->host, sizeof(soap->host));
8814 memcpy(copy->endpoint, soap->endpoint, sizeof(soap->endpoint));
8815 #endif
8816 #ifdef WITH_OPENSSL
8817 copy->bio = soap->bio;
8818 copy->ctx = soap->ctx;
8819 copy->ssl = soap->ssl;
8820 #endif
8821 #ifdef WITH_GNUTLS
8822 copy->session = soap->session;
8823 #endif
8824 #ifdef WITH_ZLIB
8825 copy->zlib_state = soap->zlib_state;
8826 copy->zlib_in = soap->zlib_in;
8827 copy->zlib_out = soap->zlib_out;
8828 if (!copy->d_stream)
8829 copy->d_stream = (z_stream*)SOAP_MALLOC(copy, sizeof(z_stream));
8830 if (copy->d_stream)
8831 memcpy(copy->d_stream, soap->d_stream, sizeof(z_stream));
8832 copy->z_crc = soap->z_crc;
8833 copy->z_ratio_in = soap->z_ratio_in;
8834 copy->z_ratio_out = soap->z_ratio_out;
8835 copy->z_buf = NULL;
8836 copy->z_buflen = soap->z_buflen;
8837 copy->z_level = soap->z_level;
8838 if (soap->z_buf && soap->zlib_state != SOAP_ZLIB_NONE)
8839 { copy->z_buf = (char*)SOAP_MALLOC(copy, SOAP_BUFLEN);
8840 if (copy->z_buf)
8841 memcpy(copy->z_buf, soap->z_buf, SOAP_BUFLEN);
8842 }
8843 copy->z_dict = soap->z_dict;
8844 copy->z_dict_len = soap->z_dict_len;
8845 #endif
8846 memcpy(copy->buf, soap->buf, sizeof(soap->buf));
8847 /* copy XML parser state */
8848 soap_free_ns(copy);
8849 soap_set_local_namespaces(copy);
8850 copy->version = soap->version;
8851 if (soap->nlist && soap->local_namespaces)
8852 { register struct soap_nlist *np = NULL, *nq;
8853 /* copy reversed nlist */
8854 for (nq = soap->nlist; nq; nq = nq->next)
8855 { register struct soap_nlist *nr = np;
8856 size_t n = sizeof(struct soap_nlist) + strlen(nq->id);
8857 np = (struct soap_nlist*)SOAP_MALLOC(copy, n);
8858 if (!np)
8859 break;
8860 memcpy(np, nq, n);
8861 np->next = nr;
8862 }
8863 while (np)
8864 { register const char *s = np->ns;
8865 copy->level = np->level; /* preserve element nesting level */
8866 if (!s && np->index >= 0)
8867 { s = soap->local_namespaces[np->index].out;
8868 if (!s)
8869 s = soap->local_namespaces[np->index].ns;
8870 }
8871 if (s && soap_push_namespace(copy, np->id, s) == NULL)
8872 break;
8873 nq = np;
8874 np = np->next;
8875 SOAP_FREE(copy, nq);
8876 }
8877 }
8878 memcpy(copy->tag, soap->tag, sizeof(copy->tag));
8879 memcpy(copy->id, soap->id, sizeof(copy->id));
8880 memcpy(copy->href, soap->href, sizeof(copy->href));
8881 memcpy(copy->type, soap->type, sizeof(copy->type));
8882 copy->other = soap->other;
8883 copy->root = soap->root;
8884 copy->null = soap->null;
8885 copy->body = soap->body;
8886 copy->part = soap->part;
8887 copy->mustUnderstand = soap->mustUnderstand;
8888 copy->level = soap->level;
8889 copy->peeked = soap->peeked;
8890 /* copy attributes */
8891 for (tq = soap->attributes; tq; tq = tq->next)
8892 { struct soap_attribute *tr = tp;
8893 size_t n = sizeof(struct soap_attribute) + strlen(tq->name);
8894 tp = (struct soap_attribute*)SOAP_MALLOC(copy, n);
8895 memcpy(tp, tq, n);
8896 if (tp->size)
8897 { tp->value = (char*)SOAP_MALLOC(copy, tp->size);
8898 if (tp->value)
8899 strcpy(tp->value, tq->value);
8900 }
8901 tp->ns = NULL;
8902 tp->next = tr;
8903 }
8904 copy->attributes = tp;
8905 }
8906 #endif
8907
8908 /******************************************************************************/
8909 #ifndef PALM_1
8910 SOAP_FMAC1
8911 void
8912 SOAP_FMAC2
8913 soap_free_stream(struct soap *soap)
8914 { soap->socket = SOAP_INVALID_SOCKET;
8915 soap->sendsk = SOAP_INVALID_SOCKET;
8916 soap->recvsk = SOAP_INVALID_SOCKET;
8917 #ifdef WITH_OPENSSL
8918 soap->bio = NULL;
8919 soap->ctx = NULL;
8920 soap->ssl = NULL;
8921 #endif
8922 #ifdef WITH_GNUTLS
8923 soap->xcred = NULL;
8924 soap->acred = NULL;
8925 soap->cache = NULL;
8926 soap->session = NULL;
8927 soap->dh_params = NULL;
8928 soap->rsa_params = NULL;
8929 #endif
8930 #ifdef WITH_ZLIB
8931 if (soap->z_buf)
8932 SOAP_FREE(soap, soap->z_buf);
8933 soap->z_buf = NULL;
8934 #endif
8935 }
8936 #endif
8937
8938 /******************************************************************************/
8939 #ifndef PALM_1
8940 SOAP_FMAC1
8941 void
8942 SOAP_FMAC2
8943 soap_initialize(struct soap *soap)
8944 { soap_versioning(soap_init)(soap, SOAP_IO_DEFAULT, SOAP_IO_DEFAULT);
8945 }
8946 #endif
8947
8948 /******************************************************************************/
8949 #ifndef PALM_1
8950 SOAP_FMAC1
8951 void
8952 SOAP_FMAC2
8953 soap_versioning(soap_init)(struct soap *soap, soap_mode imode, soap_mode omode)
8954 { size_t i;
8955 soap->state = SOAP_INIT;
8956 #ifdef SOAP_MEM_DEBUG
8957 soap_init_mht(soap);
8958 #endif
8959 #if !defined(WITH_LEAN) || defined(SOAP_DEBUG)
8960 soap_init_logs(soap);
8961 #endif
8962 #ifdef SOAP_DEBUG
8963 #ifdef TANDEM_NONSTOP
8964 soap_set_test_logfile(soap, "TESTLOG");
8965 soap_set_sent_logfile(soap, "SENTLOG");
8966 soap_set_recv_logfile(soap, "RECVLOG");
8967 #else
8968 soap_set_test_logfile(soap, "TEST.log");
8969 soap_set_sent_logfile(soap, "SENT.log");
8970 soap_set_recv_logfile(soap, "RECV.log");
8971 #endif
8972 #endif
8973 soap->version = 0;
8974 soap_mode(soap, imode);
8975 soap_imode(soap, imode);
8976 soap_omode(soap, omode);
8977 soap->plugins = NULL;
8978 soap->user = NULL;
8979 for (i = 0; i < sizeof(soap->data)/sizeof(*soap->data); i++)
8980 soap->data[i] = NULL;
8981 soap->userid = NULL;
8982 soap->passwd = NULL;
8983 soap->authrealm = NULL;
8984 #ifdef WITH_NTLM
8985 soap->ntlm_challenge = NULL;
8986 #endif
8987 #ifndef WITH_NOHTTP
8988 soap->fpost = http_post;
8989 soap->fget = http_get;
8990 soap->fput = http_405;
8991 soap->fdel = http_405;
8992 soap->fopt = http_200;
8993 soap->fhead = http_200;
8994 soap->fform = NULL;
8995 soap->fposthdr = http_post_header;
8996 soap->fresponse = http_response;
8997 soap->fparse = http_parse;
8998 soap->fparsehdr = http_parse_header;
8999 #endif
9000 soap->fheader = NULL;
9001 soap->fconnect = NULL;
9002 soap->fdisconnect = NULL;
9003 #ifndef WITH_NOIO
9004 soap->ipv6_multicast_if = 0; /* in_addr_t value */
9005 soap->ipv4_multicast_if = NULL; /* points to struct in_addr or in_addr_t */
9006 soap->ipv4_multicast_ttl = 0; /* 0: use default */
9007 #ifndef WITH_IPV6
9008 soap->fresolve = tcp_gethost;
9009 #else
9010 soap->fresolve = NULL;
9011 #endif
9012 soap->faccept = tcp_accept;
9013 soap->fopen = tcp_connect;
9014 soap->fclose = tcp_disconnect;
9015 soap->fclosesocket = tcp_closesocket;
9016 soap->fshutdownsocket = tcp_shutdownsocket;
9017 soap->fsend = fsend;
9018 soap->frecv = frecv;
9019 soap->fpoll = soap_poll;
9020 #else
9021 soap->fopen = NULL;
9022 soap->fclose = NULL;
9023 soap->fpoll = NULL;
9024 #endif
9025 soap->fseterror = NULL;
9026 soap->fignore = NULL;
9027 soap->fserveloop = NULL;
9028 soap->fplugin = fplugin;
9029 soap->fmalloc = NULL;
9030 #ifndef WITH_LEANER
9031 soap->feltbegin = NULL;
9032 soap->feltendin = NULL;
9033 soap->feltbegout = NULL;
9034 soap->feltendout = NULL;
9035 soap->fprepareinitsend = NULL;
9036 soap->fprepareinitrecv = NULL;
9037 soap->fpreparesend = NULL;
9038 soap->fpreparerecv = NULL;
9039 soap->fpreparefinalsend = NULL;
9040 soap->fpreparefinalrecv = NULL;
9041 soap->ffiltersend = NULL;
9042 soap->ffilterrecv = NULL;
9043 soap->fdimereadopen = NULL;
9044 soap->fdimewriteopen = NULL;
9045 soap->fdimereadclose = NULL;
9046 soap->fdimewriteclose = NULL;
9047 soap->fdimeread = NULL;
9048 soap->fdimewrite = NULL;
9049 soap->fmimereadopen = NULL;
9050 soap->fmimewriteopen = NULL;
9051 soap->fmimereadclose = NULL;
9052 soap->fmimewriteclose = NULL;
9053 soap->fmimeread = NULL;
9054 soap->fmimewrite = NULL;
9055 #endif
9056 soap->float_format = "%.9G"; /* Alternative: use "%G" */
9057 soap->double_format = "%.17lG"; /* Alternative: use "%lG" */
9058 soap->dime_id_format = "cid:id%d"; /* default DIME id format */
9059 soap->http_version = "1.1";
9060 soap->proxy_http_version = "1.0";
9061 soap->http_content = NULL;
9062 soap->actor = NULL;
9063 soap->lang = "en";
9064 soap->keep_alive = 0;
9065 soap->tcp_keep_alive = 0;
9066 soap->tcp_keep_idle = 0;
9067 soap->tcp_keep_intvl = 0;
9068 soap->tcp_keep_cnt = 0;
9069 soap->max_keep_alive = SOAP_MAXKEEPALIVE;
9070 soap->recv_timeout = 0;
9071 soap->send_timeout = 0;
9072 soap->connect_timeout = 0;
9073 soap->accept_timeout = 0;
9074 soap->socket_flags = 0;
9075 soap->connect_flags = 0;
9076 soap->bind_flags = 0;
9077 soap->accept_flags = 0;
9078 soap->linger_time = 0;
9079 soap->ip = 0;
9080 soap->labbuf = NULL;
9081 soap->lablen = 0;
9082 soap->labidx = 0;
9083 soap->encodingStyle = NULL;
9084 #ifndef WITH_NONAMESPACES
9085 soap->namespaces = namespaces;
9086 #else
9087 soap->namespaces = NULL;
9088 #endif
9089 soap->local_namespaces = NULL;
9090 soap->nlist = NULL;
9091 soap->blist = NULL;
9092 soap->clist = NULL;
9093 soap->alist = NULL;
9094 soap->attributes = NULL;
9095 soap->header = NULL;
9096 soap->fault = NULL;
9097 soap->master = SOAP_INVALID_SOCKET;
9098 soap->socket = SOAP_INVALID_SOCKET;
9099 soap->sendsk = SOAP_INVALID_SOCKET;
9100 soap->recvsk = SOAP_INVALID_SOCKET;
9101 soap->os = NULL;
9102 soap->is = NULL;
9103 #ifndef WITH_LEANER
9104 soap->dom = NULL;
9105 soap->dime.list = NULL;
9106 soap->dime.first = NULL;
9107 soap->dime.last = NULL;
9108 soap->mime.list = NULL;
9109 soap->mime.first = NULL;
9110 soap->mime.last = NULL;
9111 soap->mime.boundary = NULL;
9112 soap->mime.start = NULL;
9113 soap->xlist = NULL;
9114 #endif
9115 #ifndef UNDER_CE
9116 soap->recvfd = 0;
9117 soap->sendfd = 1;
9118 #else
9119 soap->recvfd = stdin;
9120 soap->sendfd = stdout;
9121 #endif
9122 soap->host[0] = '\0';
9123 soap->port = 0;
9124 soap->action = NULL;
9125 soap->proxy_host = NULL;
9126 soap->proxy_port = 8080;
9127 soap->proxy_userid = NULL;
9128 soap->proxy_passwd = NULL;
9129 soap->prolog = NULL;
9130 #ifdef WITH_ZLIB
9131 soap->zlib_state = SOAP_ZLIB_NONE;
9132 soap->zlib_in = SOAP_ZLIB_NONE;
9133 soap->zlib_out = SOAP_ZLIB_NONE;
9134 soap->d_stream = (z_stream*)SOAP_MALLOC(soap, sizeof(z_stream));
9135 soap->d_stream->zalloc = Z_NULL;
9136 soap->d_stream->zfree = Z_NULL;
9137 soap->d_stream->opaque = Z_NULL;
9138 soap->z_buf = NULL;
9139 soap->z_level = 6;
9140 soap->z_dict = NULL;
9141 soap->z_dict_len = 0;
9142 #endif
9143 #ifndef WITH_LEAN
9144 soap->wsuid = NULL;
9145 soap->c14nexclude = NULL;
9146 soap->cookies = NULL;
9147 soap->cookie_domain = NULL;
9148 soap->cookie_path = NULL;
9149 soap->cookie_max = 32;
9150 #endif
9151 #ifdef WMW_RPM_IO
9152 soap->rpmreqid = NULL;
9153 #endif
9154 #ifdef PALM
9155 palmNetLibOpen();
9156 #endif
9157 #ifndef WITH_NOIDREF
9158 soap_init_iht(soap);
9159 soap_init_pht(soap);
9160 #endif
9161 #ifdef WITH_OPENSSL
9162 if (!soap_ssl_init_done)
9163 soap_ssl_init();
9164 soap->fsslauth = ssl_auth_init;
9165 soap->fsslverify = ssl_verify_callback;
9166 soap->bio = NULL;
9167 soap->ssl = NULL;
9168 soap->ctx = NULL;
9169 soap->session = NULL;
9170 soap->ssl_flags = SOAP_SSL_DEFAULT;
9171 soap->keyfile = NULL;
9172 soap->keyid = NULL;
9173 soap->password = NULL;
9174 soap->cafile = NULL;
9175 soap->capath = NULL;
9176 soap->crlfile = NULL;
9177 soap->dhfile = NULL;
9178 soap->randfile = NULL;
9179 #endif
9180 #ifdef WITH_GNUTLS
9181 if (!soap_ssl_init_done)
9182 soap_ssl_init();
9183 soap->fsslauth = ssl_auth_init;
9184 soap->fsslverify = NULL;
9185 soap->xcred = NULL;
9186 soap->acred = NULL;
9187 soap->cache = NULL;
9188 soap->session = NULL;
9189 soap->ssl_flags = SOAP_SSL_DEFAULT;
9190 soap->keyfile = NULL;
9191 soap->keyid = NULL;
9192 soap->password = NULL;
9193 soap->cafile = NULL;
9194 soap->capath = NULL;
9195 soap->crlfile = NULL;
9196 soap->dh_params = NULL;
9197 soap->rsa_params = NULL;
9198 #endif
9199 #ifdef WITH_C_LOCALE
9200 # ifdef WIN32
9201 soap->c_locale = _create_locale(LC_ALL, "C");
9202 # else
9203 soap->c_locale = newlocale(LC_ALL_MASK, "C", NULL);
9204 # endif
9205 #else
9206 soap->c_locale = NULL;
9207 #endif
9208 soap->buflen = 0;
9209 soap->bufidx = 0;
9210 #ifndef WITH_LEANER
9211 soap->dime.chunksize = 0;
9212 soap->dime.buflen = 0;
9213 #endif
9214 soap->null = 0;
9215 soap->position = 0;
9216 soap->encoding = 0;
9217 soap->mustUnderstand = 0;
9218 soap->ns = 0;
9219 soap->part = SOAP_END;
9220 soap->event = 0;
9221 soap->evlev = 0;
9222 soap->alloced = 0;
9223 soap->count = 0;
9224 soap->length = 0;
9225 soap->cdata = 0;
9226 soap->peeked = 0;
9227 soap->ahead = 0;
9228 soap->idnum = 0;
9229 soap->level = 0;
9230 soap->endpoint[0] = '\0';
9231 soap->error = SOAP_OK;
9232 }
9233 #endif
9234
9235 /******************************************************************************/
9236 #ifndef PALM_2
9237 SOAP_FMAC1
9238 void
9239 SOAP_FMAC2
9240 soap_begin(struct soap *soap)
9241 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Reinitializing context\n"));
9242 if (!soap->keep_alive)
9243 { soap->buflen = 0;
9244 soap->bufidx = 0;
9245 }
9246 soap->null = 0;
9247 soap->position = 0;
9248 soap->encoding = 0;
9249 soap->mustUnderstand = 0;
9250 soap->mode = 0;
9251 soap->ns = 0;
9252 soap->part = SOAP_END;
9253 soap->event = 0;
9254 soap->evlev = 0;
9255 soap->alloced = 0;
9256 soap->count = 0;
9257 soap->length = 0;
9258 soap->cdata = 0;
9259 soap->error = SOAP_OK;
9260 soap->peeked = 0;
9261 soap->ahead = 0;
9262 soap->idnum = 0;
9263 soap->level = 0;
9264 soap->endpoint[0] = '\0';
9265 soap->encodingStyle = SOAP_STR_EOS;
9266 #ifndef WITH_LEANER
9267 soap->dime.chunksize = 0;
9268 soap->dime.buflen = 0;
9269 #endif
9270 soap_free_temp(soap);
9271 }
9272 #endif
9273
9274 /******************************************************************************/
9275 #ifndef PALM_2
9276 SOAP_FMAC1
9277 void
9278 SOAP_FMAC2
9279 soap_end(struct soap *soap)
9280 { if (soap_check_state(soap))
9281 return;
9282 soap_free_temp(soap);
9283 soap_dealloc(soap, NULL);
9284 while (soap->clist)
9285 { register struct soap_clist *cp = soap->clist->next;
9286 SOAP_FREE(soap, soap->clist);
9287 soap->clist = cp;
9288 }
9289 soap_closesock(soap);
9290 #ifdef SOAP_DEBUG
9291 soap_close_logfiles(soap);
9292 #endif
9293 #ifdef PALM
9294 palmNetLibClose();
9295 #endif
9296 }
9297 #endif
9298
9299 /******************************************************************************/
9300 #ifndef PALM_1
9301 SOAP_FMAC1
9302 void
9303 SOAP_FMAC2
9304 soap_set_version(struct soap *soap, short version)
9305 { soap_set_local_namespaces(soap);
9306 if (soap->version != version)
9307 { if (version == 1)
9308 { soap->local_namespaces[0].ns = soap_env1;
9309 soap->local_namespaces[1].ns = soap_enc1;
9310 }
9311 else if (version == 2)
9312 { soap->local_namespaces[0].ns = soap_env2;
9313 soap->local_namespaces[1].ns = soap_enc2;
9314 }
9315 soap->version = version;
9316 }
9317 }
9318 #endif
9319
9320 /******************************************************************************/
9321 #ifndef PALM_1
9322 SOAP_FMAC1
9323 int
9324 SOAP_FMAC2
9325 soap_set_namespaces(struct soap *soap, const struct Namespace *p)
9326 { register struct Namespace *ns = soap->local_namespaces;
9327 register struct soap_nlist *np, *nq, *nr;
9328 register unsigned int level = soap->level;
9329 soap->namespaces = p;
9330 soap->local_namespaces = NULL;
9331 soap_set_local_namespaces(soap);
9332 /* reverse the namespace list */
9333 np = soap->nlist;
9334 soap->nlist = NULL;
9335 if (np)
9336 { nq = np->next;
9337 np->next = NULL;
9338 while (nq)
9339 { nr = nq->next;
9340 nq->next = np;
9341 np = nq;
9342 nq = nr;
9343 }
9344 }
9345 /* then push on new stack */
9346 while (np)
9347 { register const char *s;
9348 soap->level = np->level; /* preserve element nesting level */
9349 s = np->ns;
9350 if (!s && np->index >= 0 && ns)
9351 { s = ns[np->index].out;
9352 if (!s)
9353 s = ns[np->index].ns;
9354 }
9355 if (s && soap_push_namespace(soap, np->id, s) == NULL)
9356 return soap->error;
9357 nq = np;
9358 np = np->next;
9359 SOAP_FREE(soap, nq);
9360 }
9361 if (ns)
9362 { register int i;
9363 for (i = 0; ns[i].id; i++)
9364 { if (ns[i].out)
9365 { SOAP_FREE(soap, ns[i].out);
9366 ns[i].out = NULL;
9367 }
9368 }
9369 SOAP_FREE(soap, ns);
9370 }
9371 soap->level = level; /* restore level */
9372 return SOAP_OK;
9373 }
9374 #endif
9375
9376 /******************************************************************************/
9377 #ifndef PALM_1
9378 SOAP_FMAC1
9379 void
9380 SOAP_FMAC2
9381 soap_set_local_namespaces(struct soap *soap)
9382 { if (soap->namespaces && !soap->local_namespaces)
9383 { register const struct Namespace *ns1;
9384 register struct Namespace *ns2;
9385 register size_t n = 1;
9386 for (ns1 = soap->namespaces; ns1->id; ns1++)
9387 n++;
9388 n *= sizeof(struct Namespace);
9389 ns2 = (struct Namespace*)SOAP_MALLOC(soap, n);
9390 if (ns2)
9391 { memcpy(ns2, soap->namespaces, n);
9392 if (ns2[0].ns)
9393 { if (!strcmp(ns2[0].ns, soap_env1))
9394 soap->version = 1;
9395 else if (!strcmp(ns2[0].ns, soap_env2))
9396 soap->version = 2;
9397 }
9398 soap->local_namespaces = ns2;
9399 for (; ns2->id; ns2++)
9400 ns2->out = NULL;
9401 }
9402 }
9403 }
9404 #endif
9405
9406 /******************************************************************************/
9407 #ifndef WITH_LEAN
9408 #ifndef PALM_1
9409 SOAP_FMAC1
9410 const char *
9411 SOAP_FMAC2
9412 soap_tagsearch(const char *big, const char *little)
9413 { if (little)
9414 { register size_t n = strlen(little);
9415 register const char *s = big;
9416 while (s)
9417 { register const char *t = s;
9418 register size_t i;
9419 for (i = 0; i < n; i++, t++)
9420 { if (*t != little[i])
9421 break;
9422 }
9423 if (*t == '\0' || *t == ' ')
9424 { if (i == n || (i && little[i-1] == ':'))
9425 return s;
9426 }
9427 s = strchr(t, ' ');
9428 if (s)
9429 s++;
9430 }
9431 }
9432 return NULL;
9433 }
9434 #endif
9435 #endif
9436
9437 /******************************************************************************/
9438 #ifndef WITH_LEAN
9439 #ifndef PALM_1
9440 SOAP_FMAC1
9441 struct soap_nlist *
9442 SOAP_FMAC2
9443 soap_lookup_ns(struct soap *soap, const char *tag, size_t n)
9444 { register struct soap_nlist *np;
9445 for (np = soap->nlist; np; np = np->next)
9446 { if (!strncmp(np->id, tag, n) && !np->id[n])
9447 return np;
9448 }
9449 return NULL;
9450 }
9451 #endif
9452 #endif
9453
9454 /******************************************************************************/
9455 #ifndef WITH_LEAN
9456 static struct soap_nlist *
9457 soap_push_ns(struct soap *soap, const char *id, const char *ns, short utilized)
9458 { register struct soap_nlist *np;
9459 size_t n, k;
9460 if (soap_tagsearch(soap->c14nexclude, id))
9461 return NULL;
9462 if (!utilized)
9463 { for (np = soap->nlist; np; np = np->next)
9464 { if (!strcmp(np->id, id) && (!np->ns || !strcmp(np->ns, ns)))
9465 break;
9466 }
9467 if (np)
9468 { if ((np->level < soap->level || !np->ns) && np->index == 1)
9469 utilized = 1;
9470 else
9471 return NULL;
9472 }
9473 }
9474 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Adding namespace binding (level=%u) '%s' '%s' utilized=%d\n", soap->level, id, ns ? ns : "(null)", utilized));
9475 n = strlen(id);
9476 if (ns)
9477 k = strlen(ns);
9478 else
9479 k = 0;
9480 np = (struct soap_nlist*)SOAP_MALLOC(soap, sizeof(struct soap_nlist) + n + k + 1);
9481 if (!np)
9482 { soap->error = SOAP_EOM;
9483 return NULL;
9484 }
9485 np->next = soap->nlist;
9486 soap->nlist = np;
9487 strcpy((char*)np->id, id);
9488 if (ns)
9489 np->ns = strcpy((char*)np->id + n + 1, ns);
9490 else
9491 np->ns = NULL;
9492 np->level = soap->level;
9493 np->index = utilized;
9494 return np;
9495 }
9496 #endif
9497
9498 /******************************************************************************/
9499 #ifndef WITH_LEAN
9500 static void
9501 soap_utilize_ns(struct soap *soap, const char *tag)
9502 { register struct soap_nlist *np;
9503 size_t n = 0;
9504 const char *t = strchr(tag, ':');
9505 if (t)
9506 { n = t - tag;
9507 if (n >= sizeof(soap->tmpbuf))
9508 n = sizeof(soap->tmpbuf) - 1;
9509 }
9510 np = soap_lookup_ns(soap, tag, n);
9511 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Utilizing namespace of '%s'\n", tag));
9512 if (np)
9513 { if (np->index <= 0)
9514 soap_push_ns(soap, np->id, np->ns, 1);
9515 }
9516 else if (strncmp(tag, "xml", 3))
9517 { strncpy(soap->tmpbuf, tag, n);
9518 soap->tmpbuf[n] = '\0';
9519 soap_push_ns(soap, soap->tmpbuf, NULL, 1);
9520 }
9521 }
9522 #endif
9523
9524 /******************************************************************************/
9525 #ifndef PALM_2
9526 SOAP_FMAC1
9527 int
9528 SOAP_FMAC2
9529 soap_element(struct soap *soap, const char *tag, int id, const char *type)
9530 {
9531 #ifndef WITH_LEAN
9532 register const char *s;
9533 #endif
9534 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element begin tag='%s' level='%u' id='%d' type='%s'\n", tag, soap->level, id, type ? type : SOAP_STR_EOS));
9535 soap->level++;
9536 #ifdef WITH_DOM
9537 #ifndef WITH_LEAN
9538 if (soap->wsuid && soap_tagsearch(soap->wsuid, tag))
9539 { size_t i;
9540 for (s = tag, i = 0; *s && i < sizeof(soap->tag) - 1; s++, i++)
9541 soap->tag[i] = *s == ':' ? '-' : *s;
9542 soap->tag[i] = '\0';
9543 if (soap_set_attr(soap, "wsu:Id", soap->tag, 1))
9544 return soap->error;
9545 }
9546 if ((soap->mode & SOAP_XML_CANONICAL) && !(soap->mode & SOAP_DOM_ASIS))
9547 { if (soap->evlev >= soap->level)
9548 soap->evlev = 0;
9549 if (soap->event == SOAP_SEC_BEGIN && !soap->evlev)
9550 { register struct soap_nlist *np;
9551 /* non-nested wsu:Id found: clear xmlns, re-emit them for exc-c14n */
9552 for (np = soap->nlist; np; np = np->next)
9553 { if (np->index == 2)
9554 { struct soap_nlist *np1 = soap_push_ns(soap, np->id, np->ns, 1);
9555 if (np1)
9556 np1->index = 0;
9557 }
9558 }
9559 soap->evlev = soap->level;
9560 }
9561 }
9562 #endif
9563 if (soap->mode & SOAP_XML_DOM)
9564 { register struct soap_dom_element *elt = (struct soap_dom_element*)soap_malloc(soap, sizeof(struct soap_dom_element));
9565 if (!elt)
9566 return soap->error;
9567 elt->soap = soap;
9568 elt->next = NULL;
9569 elt->prnt = soap->dom;
9570 elt->name = soap_strdup(soap, tag);
9571 elt->elts = NULL;
9572 elt->atts = NULL;
9573 elt->nstr = NULL;
9574 elt->data = NULL;
9575 elt->wide = NULL;
9576 elt->node = NULL;
9577 elt->type = 0;
9578 elt->head = NULL;
9579 elt->tail = NULL;
9580 if (soap->dom)
9581 { struct soap_dom_element *p = soap->dom->elts;
9582 if (p)
9583 { while (p->next)
9584 p = p->next;
9585 p->next = elt;
9586 }
9587 else
9588 soap->dom->elts = elt;
9589 }
9590 soap->dom = elt;
9591 }
9592 else
9593 {
9594 #endif
9595 #ifndef WITH_LEAN
9596 if (!soap->ns)
9597 { if (!(soap->mode & SOAP_XML_CANONICAL)
9598 && soap_send(soap, soap->prolog ? soap->prolog : "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"))
9599 return soap->error;
9600 }
9601 else if (soap->mode & SOAP_XML_INDENT)
9602 { if (soap->ns == 1 && soap_send_raw(soap, soap_indent, soap->level < sizeof(soap_indent) ? soap->level : sizeof(soap_indent) - 1))
9603 return soap->error;
9604 soap->body = 1;
9605 }
9606 if ((soap->mode & SOAP_XML_DEFAULTNS) && (s = strchr(tag, ':')))
9607 { struct Namespace *ns = soap->local_namespaces;
9608 size_t n = s - tag;
9609 if (soap_send_raw(soap, "<", 1)
9610 || soap_send(soap, s + 1))
9611 return soap->error;
9612 if (soap->nlist && !strncmp(soap->nlist->id, tag, n) && !soap->nlist->id[n])
9613 ns = NULL;
9614 for (; ns && ns->id; ns++)
9615 { if (*ns->id && (ns->out || ns->ns) && !strncmp(ns->id, tag, n) && !ns->id[n])
9616 { soap_push_ns(soap, ns->id, ns->out ? ns->out : ns->ns, 0);
9617 if (soap_attribute(soap, "xmlns", ns->out ? ns->out : ns->ns))
9618 return soap->error;
9619 break;
9620 }
9621 }
9622 }
9623 else
9624 #endif
9625 if (soap_send_raw(soap, "<", 1)
9626 || soap_send(soap, tag))
9627 return soap->error;
9628 #ifdef WITH_DOM
9629 }
9630 #endif
9631 if (!soap->ns)
9632 { struct Namespace *ns = soap->local_namespaces;
9633 int k = -1;
9634 if (ns)
9635 {
9636 #ifndef WITH_LEAN
9637 if ((soap->mode & SOAP_XML_DEFAULTNS))
9638 { if (soap->version)
9639 k = 4; /* first four required entries */
9640 else if (!(soap->mode & SOAP_XML_NOTYPE) || (soap->mode & SOAP_XML_NIL))
9641 { ns += 2;
9642 k = 2; /* next two entries */
9643 }
9644 else
9645 k = 0; /* no entries */
9646 }
9647 #endif
9648 while (k-- && ns->id)
9649 { if (*ns->id && (ns->out || ns->ns))
9650 {
9651 #ifdef HAVE_SNPRINTF
9652 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), "xmlns:%s", ns->id);
9653 #else
9654 sprintf(soap->tmpbuf, "xmlns:%s", ns->id);
9655 #endif
9656 if (soap_attribute(soap, soap->tmpbuf, ns->out ? ns->out : ns->ns))
9657 return soap->error;
9658 }
9659 ns++;
9660 }
9661 }
9662 }
9663 soap->ns = 1; /* namespace table control: ns = 0 or 2 to start, then 1 to stop dumping the table */
9664 #ifndef WITH_LEAN
9665 if (soap->mode & SOAP_XML_CANONICAL)
9666 soap_utilize_ns(soap, tag);
9667 #endif
9668 if (id > 0)
9669 {
9670 #ifdef HAVE_SNPRINTF
9671 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), "_%d", id);
9672 #else
9673 sprintf(soap->tmpbuf, "_%d", id);
9674 #endif
9675 if (soap->version == 2)
9676 { if (soap_attribute(soap, "SOAP-ENC:id", soap->tmpbuf))
9677 return soap->error;
9678 }
9679 else if (soap_attribute(soap, "id", soap->tmpbuf))
9680 return soap->error;
9681 }
9682 if (type && *type && !(soap->mode & SOAP_XML_NOTYPE) && soap->part != SOAP_IN_HEADER)
9683 { const char *t = type;
9684 #ifndef WITH_LEAN
9685 if (soap->mode & SOAP_XML_DEFAULTNS)
9686 { t = strchr(type, ':');
9687 if (t)
9688 t++;
9689 else
9690 t = type;
9691 }
9692 #endif
9693 if (soap->attributes ? soap_set_attr(soap, "xsi:type", t, 1) : soap_attribute(soap, "xsi:type", t))
9694 return soap->error;
9695 #ifndef WITH_LEAN
9696 if (soap->mode & SOAP_XML_CANONICAL)
9697 soap_utilize_ns(soap, type);
9698 #endif
9699 }
9700 if (soap->null && soap->position > 0)
9701 { register int i;
9702 #ifdef HAVE_SNPRINTF
9703 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf) - 1, "[%d", soap->positions[0]);
9704 #else
9705 sprintf(soap->tmpbuf, "[%d", soap->positions[0]);
9706 #endif
9707 for (i = 1; i < soap->position; i++)
9708 { register size_t l = strlen(soap->tmpbuf);
9709 #ifdef HAVE_SNPRINTF
9710 soap_snprintf(soap->tmpbuf + l, sizeof(soap->tmpbuf)-l-1, ",%d", soap->positions[i]);
9711 #else
9712 if (l + 13 < sizeof(soap->tmpbuf))
9713 sprintf(soap->tmpbuf + l, ",%d", soap->positions[i]);
9714 #endif
9715 }
9716 strcat(soap->tmpbuf, "]");
9717 if (soap_attribute(soap, "SOAP-ENC:position", soap->tmpbuf))
9718 return soap->error;
9719 }
9720 if (soap->mustUnderstand)
9721 { if (soap->actor && *soap->actor)
9722 { if (soap_attribute(soap, soap->version == 2 ? "SOAP-ENV:role" : "SOAP-ENV:actor", soap->actor))
9723 return soap->error;
9724 }
9725 if (soap_attribute(soap, "SOAP-ENV:mustUnderstand", soap->version == 2 ? "true" : "1"))
9726 return soap->error;
9727 soap->mustUnderstand = 0;
9728 }
9729 if (soap->encoding)
9730 { if (soap->encodingStyle && soap->local_namespaces && soap->local_namespaces[0].id && soap->local_namespaces[1].id)
9731 { if (!*soap->encodingStyle)
9732 { if (soap->local_namespaces[1].out)
9733 soap->encodingStyle = soap->local_namespaces[1].out;
9734 else
9735 soap->encodingStyle = soap->local_namespaces[1].ns;
9736 }
9737 if (soap->encodingStyle && soap_attribute(soap, "SOAP-ENV:encodingStyle", soap->encodingStyle))
9738 return soap->error;
9739 }
9740 else
9741 soap->encodingStyle = NULL;
9742 soap->encoding = 0;
9743 }
9744 soap->null = 0;
9745 soap->position = 0;
9746 if (soap->event == SOAP_SEC_BEGIN)
9747 soap->event = 0;
9748 return SOAP_OK;
9749 }
9750 #endif
9751
9752 /******************************************************************************/
9753 #ifndef PALM_2
9754 SOAP_FMAC1
9755 int
9756 SOAP_FMAC2
9757 soap_element_begin_out(struct soap *soap, const char *tag, int id, const char *type)
9758 { if (*tag == '-')
9759 return SOAP_OK;
9760 if (soap_element(soap, tag, id, type))
9761 return soap->error;
9762 #ifdef WITH_DOM
9763 if (soap_element_start_end_out(soap, NULL))
9764 return soap->error;
9765 if (soap->feltbegout)
9766 return soap->error = soap->feltbegout(soap, tag);
9767 return SOAP_OK;
9768 #else
9769 return soap_element_start_end_out(soap, NULL);
9770 #endif
9771 }
9772 #endif
9773
9774 /******************************************************************************/
9775 #ifndef PALM_2
9776 #ifndef HAVE_STRRCHR
9777 SOAP_FMAC1
9778 char*
9779 SOAP_FMAC2
9780 soap_strrchr(const char *s, int t)
9781 { register char *r = NULL;
9782 while (*s)
9783 if (*s++ == t)
9784 r = (char*)s - 1;
9785 return r;
9786 }
9787 #endif
9788 #endif
9789
9790 /******************************************************************************/
9791 #ifndef PALM_2
9792 #ifndef HAVE_STRTOL
9793 SOAP_FMAC1
9794 long
9795 SOAP_FMAC2
9796 soap_strtol(const char *s, char **t, int b)
9797 { register long n = 0;
9798 register int c;
9799 while (*s > 0 && *s <= 32)
9800 s++;
9801 if (b == 10)
9802 { short neg = 0;
9803 if (*s == '-')
9804 { s++;
9805 neg = 1;
9806 }
9807 else if (*s == '+')
9808 s++;
9809 while ((c = *s) && c >= '0' && c <= '9')
9810 { if (n >= 214748364 && (n > 214748364 || c >= '8'))
9811 break;
9812 n *= 10;
9813 n += c - '0';
9814 s++;
9815 }
9816 if (neg)
9817 n = -n;
9818 }
9819 else /* assume b == 16 and value is always positive */
9820 { while ((c = *s))
9821 { if (c >= '0' && c <= '9')
9822 c -= '0';
9823 else if (c >= 'A' && c <= 'F')
9824 c -= 'A' - 10;
9825 else if (c >= 'a' && c <= 'f')
9826 c -= 'a' - 10;
9827 if (n > 0x07FFFFFF)
9828 break;
9829 n <<= 4;
9830 n += c;
9831 s++;
9832 }
9833 }
9834 if (t)
9835 *t = (char*)s;
9836 return n;
9837 }
9838 #endif
9839 #endif
9840
9841 /******************************************************************************/
9842 #ifndef PALM_2
9843 #ifndef HAVE_STRTOUL
9844 SOAP_FMAC1
9845 unsigned long
9846 SOAP_FMAC2
9847 soap_strtoul(const char *s, char **t, int b)
9848 { unsigned long n = 0;
9849 register int c;
9850 while (*s > 0 && *s <= 32)
9851 s++;
9852 if (b == 10)
9853 { if (*s == '+')
9854 s++;
9855 while ((c = *s) && c >= '0' && c <= '9')
9856 { if (n >= 429496729 && (n > 429496729 || c >= '6'))
9857 break;
9858 n *= 10;
9859 n += c - '0';
9860 s++;
9861 }
9862 }
9863 else /* b == 16 */
9864 { while ((c = *s))
9865 { if (c >= '0' && c <= '9')
9866 c -= '0';
9867 else if (c >= 'A' && c <= 'F')
9868 c -= 'A' - 10;
9869 else if (c >= 'a' && c <= 'f')
9870 c -= 'a' - 10;
9871 if (n > 0x0FFFFFFF)
9872 break;
9873 n <<= 4;
9874 n += c;
9875 s++;
9876 }
9877 }
9878 if (t)
9879 *t = (char*)s;
9880 return n;
9881 }
9882 #endif
9883 #endif
9884
9885 /******************************************************************************/
9886 #ifndef PALM_1
9887 SOAP_FMAC1
9888 int
9889 SOAP_FMAC2
9890 soap_array_begin_out(struct soap *soap, const char *tag, int id, const char *type, const char *offset)
9891 { if (!type || !*type)
9892 return soap_element_begin_out(soap, tag, id, NULL);
9893 if (soap_element(soap, tag, id, "SOAP-ENC:Array"))
9894 return soap->error;
9895 if (soap->version == 2)
9896 { const char *s;
9897 s = soap_strrchr(type, '[');
9898 if (s && (size_t)(s - type) < sizeof(soap->tmpbuf))
9899 { strncpy(soap->tmpbuf, type, s - type);
9900 soap->tmpbuf[s - type] = '\0';
9901 if (soap_attribute(soap, "SOAP-ENC:itemType", soap->tmpbuf))
9902 return soap->error;
9903 s++;
9904 if (*s)
9905 { strncpy(soap->tmpbuf, s, sizeof(soap->tmpbuf));
9906 soap->tmpbuf[sizeof(soap->tmpbuf) - 1] = '\0';
9907 soap->tmpbuf[strlen(soap->tmpbuf) - 1] = '\0';
9908 if (soap_attribute(soap, "SOAP-ENC:arraySize", soap->tmpbuf))
9909 return soap->error;
9910 }
9911 }
9912 }
9913 else
9914 { if (offset && soap_attribute(soap, "SOAP-ENC:offset", offset))
9915 return soap->error;
9916 if (soap_attribute(soap, "SOAP-ENC:arrayType", type))
9917 return soap->error;
9918 }
9919 #ifndef WITH_LEAN
9920 if ((soap->mode & SOAP_XML_CANONICAL))
9921 soap_utilize_ns(soap, type);
9922 #endif
9923 return soap_element_start_end_out(soap, NULL);
9924 }
9925 #endif
9926
9927 /******************************************************************************/
9928 #ifndef PALM_1
9929 SOAP_FMAC1
9930 int
9931 SOAP_FMAC2
9932 soap_element_start_end_out(struct soap *soap, const char *tag)
9933 { register struct soap_attribute *tp;
9934 #ifndef WITH_LEAN
9935 if (soap->mode & SOAP_XML_CANONICAL)
9936 { struct soap_nlist *np;
9937 for (tp = soap->attributes; tp; tp = tp->next)
9938 { if (tp->visible && tp->name)
9939 soap_utilize_ns(soap, tp->name);
9940 }
9941 for (np = soap->nlist; np; np = np->next)
9942 { if (np->index == 1 && np->ns)
9943 { if (*(np->id))
9944 {
9945 #ifdef HAVE_SNPRINTF
9946 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), "xmlns:%s", np->id);
9947 #else
9948 sprintf(soap->tmpbuf, "xmlns:%s", np->id);
9949 #endif
9950 }
9951 else
9952 strcpy(soap->tmpbuf, "xmlns");
9953 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Enabling utilized binding (level=%u) %s='%s'\n", np->level, soap->tmpbuf, np->ns));
9954 soap_set_attr(soap, soap->tmpbuf, np->ns, 1);
9955 np->index = 2;
9956 }
9957 }
9958 }
9959 #endif
9960 #ifdef WITH_DOM
9961 if ((soap->mode & SOAP_XML_DOM) && soap->dom)
9962 { register struct soap_dom_attribute **att;
9963 att = &soap->dom->atts;
9964 for (tp = soap->attributes; tp; tp = tp->next)
9965 { if (tp->visible)
9966 { *att = (struct soap_dom_attribute*)soap_malloc(soap, sizeof(struct soap_dom_attribute));
9967 if (!*att)
9968 return soap->error;
9969 (*att)->next = NULL;
9970 (*att)->nstr = NULL;
9971 (*att)->name = soap_strdup(soap, tp->name);
9972 (*att)->data = soap_strdup(soap, tp->value);
9973 (*att)->wide = NULL;
9974 (*att)->soap = soap;
9975 att = &(*att)->next;
9976 tp->visible = 0;
9977 }
9978 }
9979 return SOAP_OK;
9980 }
9981 #endif
9982 for (tp = soap->attributes; tp; tp = tp->next)
9983 { if (tp->visible)
9984 {
9985 #ifndef WITH_LEAN
9986 const char *s;
9987 if ((soap->mode & SOAP_XML_DEFAULTNS) && (s = strchr(tp->name, ':')))
9988 { size_t n = s - tp->name;
9989 if (soap->nlist && !strncmp(soap->nlist->id, tp->name, n) && !soap->nlist->id[n])
9990 s++;
9991 else
9992 s = tp->name;
9993 if (soap_send(soap, " ") || soap_send(soap, s))
9994 return soap->error;
9995 }
9996 else
9997 #endif
9998 if (soap_send(soap, " ") || soap_send(soap, tp->name))
9999 return soap->error;
10000 if (tp->visible == 2 && tp->value)
10001 if (soap_send_raw(soap, "=\"", 2)
10002 || soap_string_out(soap, tp->value, tp->flag)
10003 || soap_send_raw(soap, "\"", 1))
10004 return soap->error;
10005 tp->visible = 0;
10006 }
10007 }
10008 if (tag)
10009 {
10010 #ifndef WITH_LEAN
10011 if (soap->mode & SOAP_XML_CANONICAL)
10012 { if (soap_send_raw(soap, ">", 1)
10013 || soap_element_end_out(soap, tag))
10014 return soap->error;
10015 return SOAP_OK;
10016 }
10017 #endif
10018 soap->level--; /* decrement level just before /> */
10019 return soap_send_raw(soap, "/>", 2);
10020 }
10021 return soap_send_raw(soap, ">", 1);
10022 }
10023 #endif
10024
10025 /******************************************************************************/
10026 #ifndef PALM_1
10027 SOAP_FMAC1
10028 int
10029 SOAP_FMAC2
10030 soap_element_end_out(struct soap *soap, const char *tag)
10031 {
10032 #ifndef WITH_LEAN
10033 const char *s;
10034 #endif
10035 if (*tag == '-')
10036 return SOAP_OK;
10037 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element ending tag='%s'\n", tag));
10038 #ifdef WITH_DOM
10039 if (soap->feltendout && (soap->error = soap->feltendout(soap, tag)))
10040 return soap->error;
10041 if ((soap->mode & SOAP_XML_DOM) && soap->dom)
10042 { if (soap->dom->prnt)
10043 soap->dom = soap->dom->prnt;
10044 return SOAP_OK;
10045 }
10046 #endif
10047 #ifndef WITH_LEAN
10048 if (soap->mode & SOAP_XML_CANONICAL)
10049 soap_pop_namespace(soap);
10050 if (soap->mode & SOAP_XML_INDENT)
10051 { if (!soap->body)
10052 { if (soap_send_raw(soap, soap_indent, soap->level < sizeof(soap_indent) ? soap->level : sizeof(soap_indent) - 1))
10053 return soap->error;
10054 }
10055 soap->body = 0;
10056 }
10057 if ((soap->mode & SOAP_XML_DEFAULTNS) && (s = strchr(tag, ':')))
10058 { soap_pop_namespace(soap);
10059 tag = s + 1;
10060 }
10061 #endif
10062 if (soap_send_raw(soap, "</", 2)
10063 || soap_send(soap, tag))
10064 return soap->error;
10065 soap->level--; /* decrement level just before > */
10066 return soap_send_raw(soap, ">", 1);
10067 }
10068 #endif
10069
10070 /******************************************************************************/
10071 #ifndef PALM_1
10072 SOAP_FMAC1
10073 int
10074 SOAP_FMAC2
10075 soap_element_ref(struct soap *soap, const char *tag, int id, int href)
10076 { register const char *s = "ref";
10077 register int n = 1;
10078 if (soap->version == 1)
10079 { s = "href";
10080 n = 0;
10081 }
10082 else if (soap->version == 2)
10083 s = "SOAP-ENC:ref";
10084 #ifdef HAVE_SNPRINTF
10085 soap_snprintf(soap->href, sizeof(soap->href), "#_%d", href);
10086 #else
10087 sprintf(soap->href, "#_%d", href);
10088 #endif
10089 return soap_element_href(soap, tag, id, s, soap->href + n);
10090 }
10091 #endif
10092
10093 /******************************************************************************/
10094 #ifndef PALM_1
10095 SOAP_FMAC1
10096 int
10097 SOAP_FMAC2
10098 soap_element_href(struct soap *soap, const char *tag, int id, const char *ref, const char *val)
10099 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element '%s' reference %s='%s'\n", tag, ref, val));
10100 if (soap_element(soap, tag, id, NULL)
10101 || soap_attribute(soap, ref, val)
10102 || soap_element_start_end_out(soap, tag))
10103 return soap->error;
10104 return SOAP_OK;
10105 }
10106 #endif
10107
10108 /******************************************************************************/
10109 #ifndef PALM_1
10110 SOAP_FMAC1
10111 int
10112 SOAP_FMAC2
10113 soap_element_null(struct soap *soap, const char *tag, int id, const char *type)
10114 { struct soap_attribute *tp = NULL;
10115 for (tp = soap->attributes; tp; tp = tp->next)
10116 if (tp->visible)
10117 break;
10118 if (tp || (soap->version == 2 && soap->position > 0) || id > 0 || (soap->mode & SOAP_XML_NIL))
10119 { if (soap_element(soap, tag, id, type)
10120 || (!tp && soap_attribute(soap, "xsi:nil", "true")))
10121 return soap->error;
10122 return soap_element_start_end_out(soap, tag);
10123 }
10124 soap->null = 1;
10125 soap->position = 0;
10126 soap->mustUnderstand = 0;
10127 return SOAP_OK;
10128 }
10129 #endif
10130
10131 /******************************************************************************/
10132 #ifndef PALM_1
10133 SOAP_FMAC1
10134 int
10135 SOAP_FMAC2
10136 soap_element_nil(struct soap *soap, const char *tag)
10137 { if (soap_element(soap, tag, -1, NULL)
10138 || ((soap->mode & SOAP_XML_NIL) && soap_attribute(soap, "xsi:nil", "true")))
10139 return soap->error;
10140 return soap_element_start_end_out(soap, tag);
10141 }
10142 #endif
10143
10144 /******************************************************************************/
10145 #ifndef PALM_1
10146 SOAP_FMAC1
10147 int
10148 SOAP_FMAC2
10149 soap_element_id(struct soap *soap, const char *tag, int id, const void *p, const struct soap_array *a, int n, const char *type, int t)
10150 { if (!p)
10151 { soap->error = soap_element_null(soap, tag, id, type);
10152 return -1;
10153 }
10154 #ifndef WITH_NOIDREF
10155 if ((!soap->encodingStyle && !(soap->omode & SOAP_XML_GRAPH)) || (soap->omode & SOAP_XML_TREE))
10156 return 0;
10157 if (id < 0)
10158 { struct soap_plist *pp;
10159 if (a)
10160 id = soap_array_pointer_lookup(soap, p, a, n, t, &pp);
10161 else
10162 id = soap_pointer_lookup(soap, p, t, &pp);
10163 if (id)
10164 { if (soap_is_embedded(soap, pp))
10165 { soap_element_ref(soap, tag, 0, id);
10166 return -1;
10167 }
10168 if (soap_is_single(soap, pp))
10169 return 0;
10170 soap_set_embedded(soap, pp);
10171 }
10172 }
10173 return id;
10174 #else
10175 return 0;
10176 #endif
10177 }
10178 #endif
10179
10180 /******************************************************************************/
10181 #ifndef PALM_1
10182 SOAP_FMAC1
10183 int
10184 SOAP_FMAC2
10185 soap_element_result(struct soap *soap, const char *tag)
10186 { if (soap->version == 2 && soap->encodingStyle)
10187 { if (soap_element(soap, "SOAP-RPC:result", 0, NULL)
10188 || soap_attribute(soap, "xmlns:SOAP-RPC", soap_rpc)
10189 || soap_element_start_end_out(soap, NULL)
10190 || soap_string_out(soap, tag, 0)
10191 || soap_element_end_out(soap, "SOAP-RPC:result"))
10192 return soap->error;
10193 }
10194 return SOAP_OK;
10195 }
10196 #endif
10197
10198 /******************************************************************************/
10199 #ifndef PALM_1
10200 SOAP_FMAC1
10201 void
10202 SOAP_FMAC2
10203 soap_check_result(struct soap *soap, const char *tag)
10204 { if (soap->version == 2 && soap->encodingStyle)
10205 { soap_instring(soap, ":result", NULL, NULL, 0, 2, -1, -1);
10206 /* just ignore content for compliance reasons, but should compare tag to element's QName value? */
10207 }
10208 (void)tag;
10209 }
10210 #endif
10211
10212 /******************************************************************************/
10213 #ifndef PALM_2
10214 SOAP_FMAC1
10215 int
10216 SOAP_FMAC2
10217 soap_attribute(struct soap *soap, const char *name, const char *value)
10218 {
10219 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Attribute '%s'='%s'\n", name, value));
10220 #ifdef WITH_DOM
10221 if ((soap->mode & SOAP_XML_DOM) && !(soap->mode & SOAP_XML_CANONICAL) && soap->dom)
10222 { register struct soap_dom_attribute *a = (struct soap_dom_attribute*)soap_malloc(soap, sizeof(struct soap_dom_attribute));
10223 if (!a)
10224 return soap->error;
10225 a->next = soap->dom->atts;
10226 a->nstr = NULL;
10227 a->name = soap_strdup(soap, name);
10228 a->data = soap_strdup(soap, value);
10229 a->wide = NULL;
10230 a->soap = soap;
10231 soap->dom->atts = a;
10232 return SOAP_OK;
10233 }
10234 #endif
10235 #ifndef WITH_LEAN
10236 if (soap->mode & SOAP_XML_CANONICAL)
10237 { /* push namespace */
10238 if (!strncmp(name, "xmlns", 5) && (name[5] == ':' || name[5] == '\0'))
10239 soap_push_ns(soap, name + 5 + (name[5] == ':'), value, 0);
10240 else if (soap_set_attr(soap, name, value, 1))
10241 return soap->error;
10242 }
10243 else
10244 #endif
10245 { if (soap_send(soap, " ") || soap_send(soap, name))
10246 return soap->error;
10247 if (value)
10248 if (soap_send_raw(soap, "=\"", 2)
10249 || soap_string_out(soap, value, 1)
10250 || soap_send_raw(soap, "\"", 1))
10251 return soap->error;
10252 }
10253 return SOAP_OK;
10254 }
10255 #endif
10256
10257 /******************************************************************************/
10258 #ifndef PALM_2
10259 SOAP_FMAC1
10260 int
10261 SOAP_FMAC2
10262 soap_element_begin_in(struct soap *soap, const char *tag, int nillable, const char *type)
10263 { if (!soap_peek_element(soap))
10264 { if (soap->other)
10265 return soap->error = SOAP_TAG_MISMATCH;
10266 if (tag && *tag == '-')
10267 return SOAP_OK;
10268 if (!(soap->error = soap_match_tag(soap, soap->tag, tag)))
10269 { soap->peeked = 0;
10270 if (type && *soap->type && soap_match_tag(soap, soap->type, type))
10271 return soap->error = SOAP_TYPE;
10272 if (!nillable && soap->null && (soap->mode & SOAP_XML_STRICT))
10273 return soap->error = SOAP_NULL;
10274 if (soap->body)
10275 soap->level++;
10276 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Begin element found (level=%u) '%s'='%s'\n", soap->level, soap->tag, tag ? tag : SOAP_STR_EOS ));
10277 soap->error = SOAP_OK;
10278 }
10279 }
10280 else if (soap->error == SOAP_NO_TAG && tag && *tag == '-')
10281 soap->error = SOAP_OK;
10282 return soap->error;
10283 }
10284 #endif
10285
10286 /******************************************************************************/
10287 #ifndef PALM_2
10288 SOAP_FMAC1
10289 int
10290 SOAP_FMAC2
10291 soap_element_end_in(struct soap *soap, const char *tag)
10292 { register soap_wchar c;
10293 register char *s;
10294 register int n = 0;
10295 if (tag && *tag == '-')
10296 return SOAP_OK;
10297 if (soap->error == SOAP_NO_TAG)
10298 soap->error = SOAP_OK;
10299 #ifdef WITH_DOM
10300 /* this whitespace or mixed content is significant for DOM */
10301 if ((soap->mode & SOAP_XML_DOM) && soap->dom)
10302 { if (!soap->peeked && !soap_string_in(soap, 3, -1, -1))
10303 return soap->error;
10304 if (soap->dom->prnt)
10305 soap->dom = soap->dom->prnt;
10306 }
10307 #endif
10308 if (soap->peeked)
10309 { if (*soap->tag)
10310 n++;
10311 soap->peeked = 0;
10312 }
10313 do
10314 { while (((c = soap_get(soap)) != SOAP_TT))
10315 { if ((int)c == EOF)
10316 return soap->error = SOAP_CHK_EOF;
10317 if (c == SOAP_LT)
10318 n++;
10319 else if (c == '/')
10320 { c = soap_get(soap);
10321 if (c == SOAP_GT)
10322 n--;
10323 else
10324 soap_unget(soap, c);
10325 }
10326 }
10327 } while (n--);
10328 s = soap->tag;
10329 n = sizeof(soap->tag);
10330 while (soap_notblank(c = soap_get(soap)))
10331 { if (--n > 0)
10332 *s++ = (char)c;
10333 }
10334 *s = '\0';
10335 if ((int)c == EOF)
10336 return soap->error = SOAP_CHK_EOF;
10337 while (soap_blank(c))
10338 c = soap_get(soap);
10339 if (c != SOAP_GT)
10340 return soap->error = SOAP_SYNTAX_ERROR;
10341 #ifndef WITH_LEAN
10342 #ifdef WITH_DOM
10343 if (soap->feltendin)
10344 { soap->level--;
10345 return soap->error = soap->feltendin(soap, soap->tag, tag);
10346 }
10347 #endif
10348 if (tag && (soap->mode & SOAP_XML_STRICT))
10349 { soap_pop_namespace(soap);
10350 if (soap_match_tag(soap, soap->tag, tag))
10351 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End element tag '%s' does not match '%s'\n", soap->tag, tag ? tag : SOAP_STR_EOS));
10352 return soap->error = SOAP_SYNTAX_ERROR;
10353 }
10354 }
10355 #endif
10356 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End element found (level=%u) '%s'='%s'\n", soap->level, soap->tag, tag ? tag : SOAP_STR_EOS));
10357 soap->level--;
10358 return SOAP_OK;
10359 }
10360 #endif
10361
10362 /******************************************************************************/
10363 #ifndef PALM_2
10364 SOAP_FMAC1
10365 const char *
10366 SOAP_FMAC2
10367 soap_attr_value(struct soap *soap, const char *name, int flag)
10368 { register struct soap_attribute *tp;
10369 if (*name == '-')
10370 return SOAP_STR_EOS;
10371 for (tp = soap->attributes; tp; tp = tp->next)
10372 { if (tp->visible && !soap_match_tag(soap, tp->name, name))
10373 break;
10374 }
10375 if (tp)
10376 { if (flag == 2 && (soap->mode & SOAP_XML_STRICT))
10377 soap->error = SOAP_PROHIBITED;
10378 else
10379 return tp->value;
10380 }
10381 else if (flag == 1 && (soap->mode & SOAP_XML_STRICT))
10382 soap->error = SOAP_REQUIRED;
10383 else
10384 soap->error = SOAP_OK;
10385 return NULL;
10386 }
10387 #endif
10388
10389 /******************************************************************************/
10390 #ifndef PALM_2
10391 SOAP_FMAC1
10392 int
10393 SOAP_FMAC2
10394 soap_set_attr(struct soap *soap, const char *name, const char *value, int flag)
10395 { register struct soap_attribute *tp;
10396 if (*name == '-')
10397 return SOAP_OK;
10398 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Set attribute %s='%s'\n", name, value ? value : SOAP_STR_EOS));
10399 for (tp = soap->attributes; tp; tp = tp->next)
10400 { if (!strcmp(tp->name, name))
10401 break;
10402 }
10403 if (!tp)
10404 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Allocate attribute %s\n", name));
10405 if (!(tp = (struct soap_attribute*)SOAP_MALLOC(soap, sizeof(struct soap_attribute) + strlen(name))))
10406 return soap->error = SOAP_EOM;
10407 tp->ns = NULL;
10408 #ifndef WITH_LEAN
10409 if ((soap->mode & SOAP_XML_CANONICAL))
10410 { struct soap_attribute **tpp = &soap->attributes;
10411 const char *s = strchr(name, ':');
10412 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inserting attribute %s for c14n\n", name));
10413 if (!strncmp(name, "xmlns", 5))
10414 { for (; *tpp; tpp = &(*tpp)->next)
10415 if (strncmp((*tpp)->name, "xmlns", 5) || strcmp((*tpp)->name + 5, name + 5) > 0)
10416 break;
10417 }
10418 else if (!s)
10419 { for (; *tpp; tpp = &(*tpp)->next)
10420 if (strncmp((*tpp)->name, "xmlns", 5) && ((*tpp)->ns || strcmp((*tpp)->name, name) > 0))
10421 break;
10422 }
10423 else
10424 { struct soap_nlist *np = soap_lookup_ns(soap, name, s - name);
10425 if (np)
10426 tp->ns = np->ns;
10427 else
10428 { struct soap_attribute *tq;
10429 for (tq = soap->attributes; tq; tq = tq->next)
10430 { if (!strncmp(tq->name, "xmlns:", 6) && !strncmp(tq->name + 6, name, s - name) && !tq->name[6 + s - name])
10431 { tp->ns = tq->ns;
10432 break;
10433 }
10434 }
10435 }
10436 for (; *tpp; tpp = &(*tpp)->next)
10437 { int k;
10438 if (strncmp((*tpp)->name, "xmlns", 5) && (*tpp)->ns && tp->ns && ((k = strcmp((*tpp)->ns, tp->ns)) > 0 || (!k && strcmp((*tpp)->name, name) > 0)))
10439 break;
10440 }
10441 }
10442 tp->next = *tpp;
10443 *tpp = tp;
10444 }
10445 else
10446 #endif
10447 { tp->next = soap->attributes;
10448 soap->attributes = tp;
10449 }
10450 strcpy((char*)tp->name, name);
10451 tp->value = NULL;
10452 }
10453 else if (tp->visible)
10454 { return SOAP_OK;
10455 }
10456 else if (value && tp->value && tp->size <= strlen(value))
10457 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free attribute value of %s (free %p)\n", name, tp->value));
10458 SOAP_FREE(soap, tp->value);
10459 tp->value = NULL;
10460 tp->ns = NULL;
10461 }
10462 if (value)
10463 { if (!tp->value)
10464 { tp->size = strlen(value) + 1;
10465 if (!(tp->value = (char*)SOAP_MALLOC(soap, tp->size)))
10466 return soap->error = SOAP_EOM;
10467 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Allocate attribute value for %s (%p)\n", tp->name, tp->value));
10468 }
10469 strcpy(tp->value, value);
10470 if (!strncmp(tp->name, "xmlns:", 6))
10471 tp->ns = tp->value;
10472 tp->visible = 2;
10473 tp->flag = (short)flag;
10474 #ifndef WITH_LEAN
10475 if (!strcmp(name, "wsu:Id"))
10476 { soap->event = SOAP_SEC_BEGIN;
10477 strncpy(soap->id, value, sizeof(soap->id));
10478 soap->id[sizeof(soap->id) - 1] = '\0';
10479 }
10480 #endif
10481 }
10482 else
10483 tp->visible = 1;
10484 return SOAP_OK;
10485 }
10486 #endif
10487
10488 /******************************************************************************/
10489 #ifndef PALM_2
10490 SOAP_FMAC1
10491 void
10492 SOAP_FMAC2
10493 soap_clr_attr(struct soap *soap)
10494 { register struct soap_attribute *tp;
10495 #ifndef WITH_LEAN
10496 if ((soap->mode & SOAP_XML_CANONICAL))
10497 { while (soap->attributes)
10498 { tp = soap->attributes->next;
10499 if (soap->attributes->value)
10500 SOAP_FREE(soap, soap->attributes->value);
10501 SOAP_FREE(soap, soap->attributes);
10502 soap->attributes = tp;
10503 }
10504 }
10505 else
10506 #endif
10507 { for (tp = soap->attributes; tp; tp = tp->next)
10508 tp->visible = 0;
10509 }
10510 }
10511 #endif
10512
10513 /******************************************************************************/
10514 #ifndef PALM_2
10515 static int
10516 soap_getattrval(struct soap *soap, char *s, size_t n, soap_wchar d)
10517 { register size_t i;
10518 for (i = 0; i < n; i++)
10519 { register soap_wchar c = soap_get(soap);
10520 switch (c)
10521 {
10522 case SOAP_TT:
10523 *s++ = '<';
10524 soap_unget(soap, '/');
10525 break;
10526 case SOAP_LT:
10527 *s++ = '<';
10528 break;
10529 case SOAP_GT:
10530 if (d == ' ')
10531 { soap_unget(soap, c);
10532 *s = '\0';
10533 return SOAP_OK;
10534 }
10535 *s++ = '>';
10536 break;
10537 case SOAP_QT:
10538 if (c == d)
10539 { *s = '\0';
10540 return SOAP_OK;
10541 }
10542 *s++ = '"';
10543 break;
10544 case SOAP_AP:
10545 if (c == d)
10546 { *s = '\0';
10547 return SOAP_OK;
10548 }
10549 *s++ = '\'';
10550 break;
10551 case '\t':
10552 case '\n':
10553 case '\r':
10554 case ' ':
10555 case '/':
10556 if (d == ' ')
10557 { soap_unget(soap, c);
10558 *s = '\0';
10559 return SOAP_OK;
10560 }
10561 default:
10562 if ((int)c == EOF)
10563 { *s = '\0';
10564 return soap->error = SOAP_CHK_EOF;
10565 }
10566 *s++ = (char)c;
10567 }
10568 }
10569 return soap->error = SOAP_EOM;
10570 }
10571 #endif
10572
10573 /******************************************************************************/
10574 #ifdef WITH_FAST
10575 #ifndef PALM_2
10576 SOAP_FMAC1
10577 int
10578 SOAP_FMAC2
10579 soap_store_lab(struct soap *soap, const char *s, size_t n)
10580 { soap->labidx = 0;
10581 return soap_append_lab(soap, s, n);
10582 }
10583 #endif
10584 #endif
10585
10586 /******************************************************************************/
10587 #ifdef WITH_FAST
10588 #ifndef PALM_2
10589 SOAP_FMAC1
10590 int
10591 SOAP_FMAC2
10592 soap_append_lab(struct soap *soap, const char *s, size_t n)
10593 { if (soap->labidx + n >= soap->lablen)
10594 { register char *t = soap->labbuf;
10595 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Enlarging look-aside buffer to append data, size=%lu\n", (unsigned long)soap->lablen));
10596 if (soap->lablen == 0)
10597 soap->lablen = SOAP_LABLEN;
10598 while (soap->labidx + n >= soap->lablen)
10599 soap->lablen <<= 1;
10600 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "New look-aside buffer size=%lu\n", (unsigned long)soap->lablen));
10601 soap->labbuf = (char*)SOAP_MALLOC(soap, soap->lablen);
10602 if (!soap->labbuf)
10603 { if (t)
10604 SOAP_FREE(soap, t);
10605 return soap->error = SOAP_EOM;
10606 }
10607 if (t)
10608 { memcpy(soap->labbuf, t, soap->labidx);
10609 SOAP_FREE(soap, t);
10610 }
10611 }
10612 if (s)
10613 { memcpy(soap->labbuf + soap->labidx, s, n);
10614 soap->labidx += n;
10615 }
10616 return SOAP_OK;
10617 }
10618 #endif
10619 #endif
10620
10621 /******************************************************************************/
10622 #ifndef PALM_2
10623 SOAP_FMAC1
10624 int
10625 SOAP_FMAC2
10626 soap_peek_element(struct soap *soap)
10627 {
10628 #ifdef WITH_DOM
10629 register struct soap_dom_attribute **att = NULL;
10630 register char *lead = NULL;
10631 #endif
10632 register struct soap_attribute *tp, *tq = NULL;
10633 register const char *t;
10634 register char *s;
10635 register soap_wchar c;
10636 register int i;
10637 if (soap->peeked)
10638 { if (!*soap->tag)
10639 return soap->error = SOAP_NO_TAG;
10640 return SOAP_OK;
10641 }
10642 soap->peeked = 1;
10643 soap->id[0] = '\0';
10644 soap->href[0] = '\0';
10645 soap->type[0] = '\0';
10646 soap->arrayType[0] = '\0';
10647 soap->arraySize[0] = '\0';
10648 soap->arrayOffset[0] = '\0';
10649 soap->other = 0;
10650 soap->root = -1;
10651 soap->position = 0;
10652 soap->null = 0;
10653 soap->mustUnderstand = 0;
10654 /* UTF-8 BOM? */
10655 c = soap_getchar(soap);
10656 if (c == 0xEF && soap_get0(soap) == 0xBB)
10657 { c = soap_get1(soap);
10658 if ((c = soap_get1(soap)) == 0xBF)
10659 soap->mode &= ~SOAP_ENC_LATIN;
10660 else
10661 soap_unget(soap, (0x0F << 12) | (0xBB << 6) | (c & 0x3F)); /* UTF-8 */
10662 }
10663 else if ((c == 0xFE && soap_get0(soap) == 0xFF) /* UTF-16 BE */
10664 || (c == 0xFF && soap_get0(soap) == 0xFE)) /* UTF-16 LE */
10665 return soap->error = SOAP_UTF_ERROR;
10666 else
10667 soap_unget(soap, c);
10668 c = soap_get(soap);
10669 #ifdef WITH_DOM
10670 /* whitespace leading to tag is not insignificant for DOM */
10671 if (soap_blank(c))
10672 { soap->labidx = 0;
10673 do
10674 { if (soap_append_lab(soap, NULL, 0))
10675 return soap->error;
10676 s = soap->labbuf + soap->labidx;
10677 i = soap->lablen - soap->labidx;
10678 soap->labidx = soap->lablen;
10679 while (soap_blank(c) && i--)
10680 { *s++ = c;
10681 c = soap_get(soap);
10682 }
10683 }
10684 while (soap_blank(c));
10685 *s = '\0';
10686 lead = soap->labbuf;
10687 }
10688 #else
10689 /* skip space */
10690 while (soap_blank(c))
10691 c = soap_get(soap);
10692 #endif
10693 if (c != SOAP_LT)
10694 { *soap->tag = '\0';
10695 if ((int)c == EOF)
10696 return soap->error = SOAP_CHK_EOF;
10697 soap_unget(soap, c);
10698 #ifdef WITH_DOM
10699 /* whitespace leading to end tag is significant for DOM */
10700 if ((soap->mode & SOAP_XML_DOM) && soap->dom)
10701 { if (lead && *lead)
10702 soap->dom->tail = soap_strdup(soap, lead);
10703 else
10704 soap->dom->tail = (char*)SOAP_STR_EOS;
10705 }
10706 #endif
10707 return soap->error = SOAP_NO_TAG;
10708 }
10709 do c = soap_get1(soap);
10710 while (soap_blank(c));
10711 s = soap->tag;
10712 i = sizeof(soap->tag);
10713 while (c != '>' && c != '/' && soap_notblank(c) && (int)c != EOF)
10714 { if (--i > 0)
10715 *s++ = (char)c;
10716 c = soap_get1(soap);
10717 }
10718 *s = '\0';
10719 while (soap_blank(c))
10720 c = soap_get1(soap);
10721 #ifdef WITH_DOM
10722 if (soap->mode & SOAP_XML_DOM)
10723 { register struct soap_dom_element *elt;
10724 elt = (struct soap_dom_element*)soap_malloc(soap, sizeof(struct soap_dom_element));
10725 if (!elt)
10726 return soap->error;
10727 elt->next = NULL;
10728 elt->nstr = NULL;
10729 elt->name = soap_strdup(soap, soap->tag);
10730 elt->prnt = soap->dom;
10731 elt->elts = NULL;
10732 elt->atts = NULL;
10733 elt->data = NULL;
10734 elt->wide = NULL;
10735 elt->type = 0;
10736 elt->node = NULL;
10737 elt->head = soap_strdup(soap, lead);
10738 elt->tail = NULL;
10739 elt->soap = soap;
10740 if (soap->dom)
10741 { struct soap_dom_element *p = soap->dom->elts;
10742 if (p)
10743 { while (p->next)
10744 p = p->next;
10745 p->next = elt;
10746 }
10747 else
10748 soap->dom->elts = elt;
10749 }
10750 soap->dom = elt;
10751 att = &elt->atts;
10752 }
10753 #endif
10754 soap_pop_namespace(soap);
10755 for (tp = soap->attributes; tp; tp = tp->next)
10756 tp->visible = 0;
10757 while ((int)c != EOF && c != '>' && c != '/')
10758 { s = soap->tmpbuf;
10759 i = sizeof(soap->tmpbuf);
10760 while (c != '=' && c != '>' && c != '/' && soap_notblank(c) && (int)c != EOF)
10761 { if (--i > 0)
10762 *s++ = (char)c;
10763 c = soap_get1(soap);
10764 }
10765 *s = '\0';
10766 if (i == sizeof(soap->tmpbuf))
10767 return soap->error = SOAP_SYNTAX_ERROR;
10768 #ifdef WITH_DOM
10769 /* add attribute name to dom */
10770 if (att)
10771 { *att = (struct soap_dom_attribute*)soap_malloc(soap, sizeof(struct soap_dom_attribute));
10772 if (!*att)
10773 return soap->error;
10774 (*att)->next = NULL;
10775 (*att)->nstr = NULL;
10776 (*att)->name = soap_strdup(soap, soap->tmpbuf);
10777 (*att)->data = NULL;
10778 (*att)->wide = NULL;
10779 (*att)->soap = soap;
10780 }
10781 #endif
10782 if (!strncmp(soap->tmpbuf, "xmlns", 5))
10783 { if (soap->tmpbuf[5] == ':')
10784 t = soap->tmpbuf + 6;
10785 else if (soap->tmpbuf[5])
10786 t = NULL;
10787 else
10788 t = SOAP_STR_EOS;
10789 }
10790 else
10791 t = NULL;
10792 tq = NULL;
10793 for (tp = soap->attributes; tp; tq = tp, tp = tp->next)
10794 { if (!SOAP_STRCMP(tp->name, soap->tmpbuf))
10795 break;
10796 }
10797 if (!tp)
10798 { tp = (struct soap_attribute*)SOAP_MALLOC(soap, sizeof(struct soap_attribute) + strlen(soap->tmpbuf));
10799 if (!tp)
10800 return soap->error = SOAP_EOM;
10801 strcpy((char*)tp->name, soap->tmpbuf);
10802 tp->value = NULL;
10803 tp->size = 0;
10804 tp->ns = NULL;
10805 /* if attribute name is qualified, append it to the end of the list */
10806 if (tq && strchr(soap->tmpbuf, ':'))
10807 { tq->next = tp;
10808 tp->next = NULL;
10809 }
10810 else
10811 { tp->next = soap->attributes;
10812 soap->attributes = tp;
10813 }
10814 }
10815 while (soap_blank(c))
10816 c = soap_get1(soap);
10817 if (c == '=')
10818 { do c = soap_getutf8(soap);
10819 while (soap_blank(c));
10820 if (c != SOAP_QT && c != SOAP_AP)
10821 { soap_unget(soap, c);
10822 c = ' '; /* blank delimiter */
10823 }
10824 if (soap_getattrval(soap, tp->value, tp->size, c))
10825 {
10826 #ifdef WITH_FAST
10827 if (soap->error != SOAP_EOM)
10828 return soap->error;
10829 soap->error = SOAP_OK;
10830 if (soap_store_lab(soap, tp->value, tp->size))
10831 return soap->error;
10832 if (tp->value)
10833 SOAP_FREE(soap, tp->value);
10834 tp->value = NULL;
10835 for (;;)
10836 { if (soap_getattrval(soap, soap->labbuf + soap->labidx, soap->lablen - soap->labidx, c))
10837 { if (soap->error != SOAP_EOM)
10838 return soap->error;
10839 soap->error = SOAP_OK;
10840 soap->labidx = soap->lablen;
10841 if (soap_append_lab(soap, NULL, 0))
10842 return soap->error;
10843 }
10844 else
10845 break;
10846 }
10847 if (soap->labidx)
10848 tp->size = soap->lablen;
10849 else
10850 { tp->size = strlen(soap->labbuf) + 1;
10851 if (tp->size < SOAP_LABLEN)
10852 tp->size = SOAP_LABLEN;
10853 }
10854 if (!(tp->value = (char*)SOAP_MALLOC(soap, tp->size)))
10855 return soap->error = SOAP_EOM;
10856 strcpy(tp->value, soap->labbuf);
10857 #else
10858 size_t n;
10859 if (soap->error != SOAP_EOM)
10860 return soap->error;
10861 soap->error = SOAP_OK;
10862 if (soap_new_block(soap) == NULL)
10863 return soap->error;
10864 for (;;)
10865 { if (!(s = (char*)soap_push_block(soap, NULL, SOAP_BLKLEN)))
10866 return soap->error;
10867 if (soap_getattrval(soap, s, SOAP_BLKLEN, c))
10868 { if (soap->error != SOAP_EOM)
10869 return soap->error;
10870 soap->error = SOAP_OK;
10871 }
10872 else
10873 break;
10874 }
10875 n = tp->size + soap->blist->size;
10876 if (!(s = (char*)SOAP_MALLOC(soap, n)))
10877 return soap->error = SOAP_EOM;
10878 if (tp->value)
10879 { memcpy(s, tp->value, tp->size);
10880 SOAP_FREE(soap, tp->value);
10881 }
10882 soap_save_block(soap, NULL, s + tp->size, 0);
10883 tp->value = s;
10884 tp->size = n;
10885 #endif
10886 }
10887 do c = soap_get1(soap);
10888 while (soap_blank(c));
10889 tp->visible = 2; /* seen this attribute w/ value */
10890 #ifdef WITH_DOM
10891 if (att)
10892 (*att)->data = soap_strdup(soap, tp->value);
10893 #endif
10894 }
10895 else
10896 tp->visible = 1; /* seen this attribute w/o value */
10897 #ifdef WITH_DOM
10898 if (att)
10899 att = &(*att)->next;
10900 #endif
10901 if (t && tp->value)
10902 { if (soap_push_namespace(soap, t, tp->value) == NULL)
10903 return soap->error;
10904 }
10905 }
10906 #ifdef WITH_DOM
10907 if (att)
10908 { soap->dom->nstr = soap_current_namespace(soap, soap->tag);
10909 for (att = &soap->dom->atts; *att; att = &(*att)->next)
10910 (*att)->nstr = soap_current_namespace(soap, (*att)->name);
10911 }
10912 #endif
10913 if ((int)c == EOF)
10914 return soap->error = SOAP_CHK_EOF;
10915 if (!(soap->body = (c != '/')))
10916 do c = soap_get1(soap);
10917 while (soap_blank(c));
10918 #ifdef WITH_DOM
10919 if (soap->mode & SOAP_XML_DOM)
10920 { if (!soap->body && soap->dom->prnt)
10921 soap->dom = soap->dom->prnt;
10922 }
10923 #endif
10924 for (tp = soap->attributes; tp; tp = tp->next)
10925 { if (tp->visible && tp->value)
10926 {
10927 #ifndef WITH_NOIDREF
10928 if (!strcmp(tp->name, "id"))
10929 { if ((soap->version > 0 && !(soap->imode & SOAP_XML_TREE))
10930 || (soap->mode & SOAP_XML_GRAPH))
10931 { *soap->id = '#';
10932 strncpy(soap->id + 1, tp->value, sizeof(soap->id) - 2);
10933 soap->id[sizeof(soap->id) - 1] = '\0';
10934 }
10935 }
10936 else if (!strcmp(tp->name, "href"))
10937 { if ((soap->version == 1 && !(soap->imode & SOAP_XML_TREE))
10938 || (soap->mode & SOAP_XML_GRAPH)
10939 || (soap->mode & SOAP_ENC_MTOM)
10940 || (soap->mode & SOAP_ENC_DIME))
10941 { strncpy(soap->href, tp->value, sizeof(soap->href) - 1);
10942 soap->href[sizeof(soap->href) - 1] = '\0';
10943 }
10944 }
10945 else if (!strcmp(tp->name, "ref"))
10946 { if ((soap->version == 2 && !(soap->imode & SOAP_XML_TREE))
10947 || (soap->mode & SOAP_XML_GRAPH))
10948 { *soap->href = '#';
10949 strncpy(soap->href + (*tp->value != '#'), tp->value, sizeof(soap->href) - 2);
10950 soap->href[sizeof(soap->href) - 1] = '\0';
10951 }
10952 }
10953 else
10954 #endif
10955 if (!soap_match_tag(soap, tp->name, "xsi:type"))
10956 { strncpy(soap->type, tp->value, sizeof(soap->type) - 1);
10957 soap->type[sizeof(soap->type) - 1] = '\0';
10958 }
10959 else if ((!soap_match_tag(soap, tp->name, "xsi:null")
10960 || !soap_match_tag(soap, tp->name, "xsi:nil"))
10961 && (!strcmp(tp->value, "1")
10962 || !strcmp(tp->value, "true")))
10963 { soap->null = 1;
10964 }
10965 else if (soap->version == 1)
10966 { if (!soap_match_tag(soap, tp->name, "SOAP-ENC:arrayType"))
10967 { s = soap_strrchr(tp->value, '[');
10968 if (s && (size_t)(s - tp->value) < sizeof(soap->arrayType))
10969 { strncpy(soap->arrayType, tp->value, s - tp->value);
10970 soap->arrayType[s - tp->value] = '\0';
10971 strncpy(soap->arraySize, s, sizeof(soap->arraySize));
10972 }
10973 else
10974 strncpy(soap->arrayType, tp->value, sizeof(soap->arrayType));
10975 soap->arraySize[sizeof(soap->arraySize) - 1] = '\0';
10976 soap->arrayType[sizeof(soap->arrayType) - 1] = '\0';
10977 }
10978 else if (!soap_match_tag(soap, tp->name, "SOAP-ENC:offset"))
10979 strncpy(soap->arrayOffset, tp->value, sizeof(soap->arrayOffset));
10980 else if (!soap_match_tag(soap, tp->name, "SOAP-ENC:position"))
10981 soap->position = soap_getposition(tp->value, soap->positions);
10982 else if (!soap_match_tag(soap, tp->name, "SOAP-ENC:root"))
10983 soap->root = ((!strcmp(tp->value, "1") || !strcmp(tp->value, "true")));
10984 else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:mustUnderstand")
10985 && (!strcmp(tp->value, "1") || !strcmp(tp->value, "true")))
10986 soap->mustUnderstand = 1;
10987 else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:actor"))
10988 { if ((!soap->actor || strcmp(soap->actor, tp->value))
10989 && strcmp(tp->value, "http://schemas.xmlsoap.org/soap/actor/next"))
10990 soap->other = 1;
10991 }
10992 }
10993 else if (soap->version == 2)
10994 {
10995 #ifndef WITH_NOIDREF
10996 if (!soap_match_tag(soap, tp->name, "SOAP-ENC:id"))
10997 { *soap->id = '#';
10998 strncpy(soap->id + 1, tp->value, sizeof(soap->id) - 2);
10999 soap->id[sizeof(soap->id) - 1] = '\0';
11000 }
11001 else if (!soap_match_tag(soap, tp->name, "SOAP-ENC:ref"))
11002 { *soap->href = '#';
11003 strncpy(soap->href + (*tp->value != '#'), tp->value, sizeof(soap->href) - 2);
11004 soap->href[sizeof(soap->href) - 1] = '\0';
11005 }
11006 else
11007 #endif
11008 if (!soap_match_tag(soap, tp->name, "SOAP-ENC:itemType"))
11009 strncpy(soap->arrayType, tp->value, sizeof(soap->arrayType) - 1);
11010 else if (!soap_match_tag(soap, tp->name, "SOAP-ENC:arraySize"))
11011 strncpy(soap->arraySize, tp->value, sizeof(soap->arraySize) - 1);
11012 else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:mustUnderstand")
11013 && (!strcmp(tp->value, "1") || !strcmp(tp->value, "true")))
11014 soap->mustUnderstand = 1;
11015 else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:role"))
11016 { if ((!soap->actor || strcmp(soap->actor, tp->value))
11017 && strcmp(tp->value, "http://www.w3.org/2003/05/soap-envelope/role/next"))
11018 soap->other = 1;
11019 }
11020 }
11021 else
11022 { if (!soap_match_tag(soap, tp->name, "wsdl:required") && !strcmp(tp->value, "true"))
11023 soap->mustUnderstand = 1;
11024 }
11025 }
11026 }
11027 #ifdef WITH_DOM
11028 if (soap->feltbegin)
11029 return soap->error = soap->feltbegin(soap, soap->tag);
11030 #endif
11031 return soap->error = SOAP_OK;
11032 }
11033 #endif
11034
11035 /******************************************************************************/
11036 #ifndef PALM_2
11037 SOAP_FMAC1
11038 void
11039 SOAP_FMAC2
11040 soap_retry(struct soap *soap)
11041 { soap->error = SOAP_OK;
11042 soap_revert(soap);
11043 }
11044 #endif
11045
11046 /******************************************************************************/
11047 #ifndef PALM_2
11048 SOAP_FMAC1
11049 void
11050 SOAP_FMAC2
11051 soap_revert(struct soap *soap)
11052 { if (!soap->peeked)
11053 { soap->peeked = 1;
11054 if (soap->body)
11055 soap->level--;
11056 }
11057 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Reverting to last element '%s' (level=%u)\n", soap->tag, soap->level));
11058 }
11059 #endif
11060
11061 /******************************************************************************/
11062 #ifndef PALM_2
11063 SOAP_FMAC1
11064 int
11065 SOAP_FMAC2
11066 soap_string_out(struct soap *soap, const char *s, int flag)
11067 { register const char *t;
11068 register soap_wchar c;
11069 register soap_wchar mask = (soap_wchar)0xFFFFFF80UL;
11070 #ifdef WITH_DOM
11071 if ((soap->mode & SOAP_XML_DOM) && soap->dom)
11072 { soap->dom->data = soap_strdup(soap, s);
11073 return SOAP_OK;
11074 }
11075 #endif
11076 if (flag == 2 || soap->mode & SOAP_C_UTFSTRING)
11077 mask = 0;
11078 t = s;
11079 while ((c = *t++))
11080 { switch (c)
11081 {
11082 case 0x09:
11083 if (flag)
11084 { if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&#x9;", 5))
11085 return soap->error;
11086 s = t;
11087 }
11088 break;
11089 case 0x0A:
11090 if (flag || !(soap->mode & SOAP_XML_CANONICAL))
11091 { if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&#xA;", 5))
11092 return soap->error;
11093 s = t;
11094 }
11095 break;
11096 case 0x0D:
11097 if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&#xD;", 5))
11098 return soap->error;
11099 s = t;
11100 break;
11101 case '&':
11102 if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&amp;", 5))
11103 return soap->error;
11104 s = t;
11105 break;
11106 case '<':
11107 if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&lt;", 4))
11108 return soap->error;
11109 s = t;
11110 break;
11111 case '>':
11112 if (!flag)
11113 { if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&gt;", 4))
11114 return soap->error;
11115 s = t;
11116 }
11117 break;
11118 case '"':
11119 if (flag)
11120 { if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&quot;", 6))
11121 return soap->error;
11122 s = t;
11123 }
11124 break;
11125 default:
11126 #ifndef WITH_LEANER
11127 #ifdef HAVE_MBTOWC
11128 if (soap->mode & SOAP_C_MBSTRING)
11129 { wchar_t wc;
11130 register int m = mbtowc(&wc, t - 1, MB_CUR_MAX);
11131 if (m > 0 && !((soap_wchar)wc == c && m == 1 && c < 0x80))
11132 { if (soap_send_raw(soap, s, t - s - 1) || soap_pututf8(soap, (unsigned long)wc))
11133 return soap->error;
11134 s = t += m - 1;
11135 continue;
11136 }
11137 }
11138 #endif
11139 #endif
11140 #ifndef WITH_NOSTRINGTOUTF8
11141 if ((c & mask) || !(c & 0xFFFFFFE0UL))
11142 { if (soap_send_raw(soap, s, t - s - 1) || soap_pututf8(soap, (unsigned char)c))
11143 return soap->error;
11144 s = t;
11145 }
11146 #endif
11147 }
11148 }
11149 return soap_send_raw(soap, s, t - s - 1);
11150 }
11151 #endif
11152
11153 /******************************************************************************/
11154 #ifndef PALM_2
11155 SOAP_FMAC1
11156 char *
11157 SOAP_FMAC2
11158 soap_string_in(struct soap *soap, int flag, long minlen, long maxlen)
11159 { register char *s;
11160 char *t = NULL;
11161 register size_t i;
11162 register long l = 0;
11163 register int n = 0, f = 0, m = 0;
11164 register soap_wchar c;
11165 #if !defined(WITH_LEANER) && defined(HAVE_WCTOMB)
11166 char buf[MB_LEN_MAX > 8 ? MB_LEN_MAX : 8];
11167 #else
11168 char buf[8];
11169 #endif
11170 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Reading string content, flag=%d\n", flag));
11171 if (soap->peeked && *soap->tag)
11172 {
11173 #ifndef WITH_LEAN
11174 struct soap_attribute *tp;
11175 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "String content includes tag '%s' and attributes\n", soap->tag));
11176 t = soap->tmpbuf;
11177 *t = '<';
11178 strncpy(t + 1, soap->tag, sizeof(soap->tmpbuf) - 2);
11179 t[sizeof(soap->tmpbuf) - 1] = '\0';
11180 t += strlen(t);
11181 for (tp = soap->attributes; tp; tp = tp->next)
11182 { if (tp->visible)
11183 { if (t >= soap->tmpbuf + sizeof(soap->tmpbuf) - 2)
11184 break;
11185 *t++ = ' ';
11186 strcpy(t, tp->name);
11187 t += strlen(t);
11188 if (t >= soap->tmpbuf + sizeof(soap->tmpbuf) - 2)
11189 break; /* too many or large attribute values */
11190 if (tp->value)
11191 { *t++ = '=';
11192 *t++ = '"';
11193 strcpy(t, tp->value);
11194 t += strlen(t);
11195 *t++ = '"';
11196 }
11197 }
11198 }
11199 if (!soap->body)
11200 *t++ = '/';
11201 *t++ = '>';
11202 *t = '\0';
11203 t = soap->tmpbuf;
11204 m = (int)strlen(soap->tmpbuf);
11205 #endif
11206 if (soap->body)
11207 n = 1;
11208 f = 1;
11209 soap->peeked = 0;
11210 }
11211 #ifdef WITH_CDATA
11212 if (!flag)
11213 { register int state = 0;
11214 #ifdef WITH_FAST
11215 soap->labidx = 0; /* use look-aside buffer */
11216 #else
11217 if (soap_new_block(soap) == NULL)
11218 return NULL;
11219 #endif
11220 for (;;)
11221 {
11222 #ifdef WITH_FAST
11223 register size_t k;
11224 if (soap_append_lab(soap, NULL, 0)) /* allocate more space in look-aside buffer if necessary */
11225 return NULL;
11226 s = soap->labbuf + soap->labidx; /* space to populate */
11227 k = soap->lablen - soap->labidx; /* number of bytes available */
11228 soap->labidx = soap->lablen; /* claim this space */
11229 #else
11230 register size_t k = SOAP_BLKLEN;
11231 if (!(s = (char*)soap_push_block(soap, NULL, k)))
11232 return NULL;
11233 #endif
11234 for (i = 0; i < k; i++)
11235 { if (m > 0)
11236 { *s++ = *t++; /* copy multibyte characters */
11237 m--;
11238 continue;
11239 }
11240 c = soap_getchar(soap);
11241 if ((int)c == EOF)
11242 goto end;
11243 if ((c >= 0x80 || c < SOAP_AP) && state != 1 && !(soap->mode & SOAP_ENC_LATIN))
11244 { if ((c & 0x7FFFFFFF) >= 0x80)
11245 { soap_unget(soap, c);
11246 c = soap_getutf8(soap);
11247 }
11248 if ((c & 0x7FFFFFFF) >= 0x80 && (!flag || (soap->mode & SOAP_C_UTFSTRING)))
11249 { c &= 0x7FFFFFFF;
11250 t = buf;
11251 if (c < 0x0800)
11252 *t++ = (char)(0xC0 | ((c >> 6) & 0x1F));
11253 else
11254 { if (c < 0x010000)
11255 *t++ = (char)(0xE0 | ((c >> 12) & 0x0F));
11256 else
11257 { if (c < 0x200000)
11258 *t++ = (char)(0xF0 | ((c >> 18) & 0x07));
11259 else
11260 { if (c < 0x04000000)
11261 *t++ = (char)(0xF8 | ((c >> 24) & 0x03));
11262 else
11263 { *t++ = (char)(0xFC | ((c >> 30) & 0x01));
11264 *t++ = (char)(0x80 | ((c >> 24) & 0x3F));
11265 }
11266 *t++ = (char)(0x80 | ((c >> 18) & 0x3F));
11267 }
11268 *t++ = (char)(0x80 | ((c >> 12) & 0x3F));
11269 }
11270 *t++ = (char)(0x80 | ((c >> 6) & 0x3F));
11271 }
11272 *t++ = (char)(0x80 | (c & 0x3F));
11273 m = (int)(t - buf) - 1;
11274 t = buf;
11275 *s++ = *t++;
11276 continue;
11277 }
11278 }
11279 switch (state)
11280 { case 1:
11281 if (c == ']')
11282 state = 4;
11283 *s++ = (char)c;
11284 continue;
11285 case 2:
11286 if (c == '-')
11287 state = 6;
11288 *s++ = (char)c;
11289 continue;
11290 case 3:
11291 if (c == '?')
11292 state = 8;
11293 *s++ = (char)c;
11294 continue;
11295 /* CDATA */
11296 case 4:
11297 if (c == ']')
11298 state = 5;
11299 else
11300 state = 1;
11301 *s++ = (char)c;
11302 continue;
11303 case 5:
11304 if (c == '>')
11305 state = 0;
11306 else if (c != ']')
11307 state = 1;
11308 *s++ = (char)c;
11309 continue;
11310 /* comment */
11311 case 6:
11312 if (c == '-')
11313 state = 7;
11314 else
11315 state = 2;
11316 *s++ = (char)c;
11317 continue;
11318 case 7:
11319 if (c == '>')
11320 state = 0;
11321 else if (c != '-')
11322 state = 2;
11323 *s++ = (char)c;
11324 continue;
11325 /* PI */
11326 case 8:
11327 if (c == '>')
11328 state = 0;
11329 else if (c != '?')
11330 state = 3;
11331 *s++ = (char)c;
11332 continue;
11333 }
11334 switch (c)
11335 {
11336 case SOAP_TT:
11337 if (n == 0)
11338 goto end;
11339 n--;
11340 *s++ = '<';
11341 t = (char*)"/";
11342 m = 1;
11343 break;
11344 case SOAP_LT:
11345 if (f && n == 0)
11346 goto end;
11347 n++;
11348 *s++ = '<';
11349 break;
11350 case SOAP_GT:
11351 *s++ = '>';
11352 break;
11353 case SOAP_QT:
11354 *s++ = '"';
11355 break;
11356 case SOAP_AP:
11357 *s++ = '\'';
11358 break;
11359 case '/':
11360 if (n > 0)
11361 { c = soap_getchar(soap);
11362 if (c == '>')
11363 n--;
11364 soap_unget(soap, c);
11365 }
11366 *s++ = '/';
11367 break;
11368 case '<':
11369 c = soap_getchar(soap);
11370 if (c == '/')
11371 { if (n == 0)
11372 { c = SOAP_TT;
11373 goto end;
11374 }
11375 n--;
11376 }
11377 else if (c == '!')
11378 { c = soap_getchar(soap);
11379 if (c == '[')
11380 { do c = soap_getchar(soap);
11381 while ((int)c != EOF && c != '[');
11382 if ((int)c == EOF)
11383 goto end;
11384 t = (char*)"![CDATA[";
11385 m = 8;
11386 state = 1;
11387 }
11388 else if (c == '-')
11389 { if ((c = soap_getchar(soap)) == '-')
11390 state = 2;
11391 t = (char*)"!-";
11392 m = 2;
11393 soap_unget(soap, c);
11394 }
11395 else
11396 { t = (char*)"!";
11397 m = 1;
11398 soap_unget(soap, c);
11399 }
11400 *s++ = '<';
11401 break;
11402 }
11403 else if (c == '?')
11404 state = 3;
11405 else if (f && n == 0)
11406 { soap_revget1(soap);
11407 c = '<';
11408 goto end;
11409 }
11410 else
11411 n++;
11412 soap_unget(soap, c);
11413 *s++ = '<';
11414 break;
11415 case '>':
11416 *s++ = '>';
11417 break;
11418 case '"':
11419 *s++ = '"';
11420 break;
11421 default:
11422 #ifndef WITH_LEANER
11423 #ifdef HAVE_WCTOMB
11424 if (soap->mode & SOAP_C_MBSTRING)
11425 { m = wctomb(buf, (wchar_t)(c & 0x7FFFFFFF));
11426 if (m >= 1 && m <= (int)MB_CUR_MAX)
11427 { t = buf;
11428 *s++ = *t++;
11429 m--;
11430 }
11431 else
11432 { *s++ = SOAP_UNKNOWN_CHAR;
11433 m = 0;
11434 }
11435 }
11436 else
11437 #endif
11438 #endif
11439 *s++ = (char)(c & 0xFF);
11440 }
11441 l++;
11442 if (maxlen >= 0 && l > maxlen)
11443 { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "String too long: maxlen=%ld\n", maxlen));
11444 soap->error = SOAP_LENGTH;
11445 return NULL;
11446 }
11447 }
11448 }
11449 }
11450 #endif
11451 #ifdef WITH_FAST
11452 soap->labidx = 0; /* use look-aside buffer */
11453 #else
11454 if (soap_new_block(soap) == NULL)
11455 return NULL;
11456 #endif
11457 for (;;)
11458 {
11459 #ifdef WITH_FAST
11460 register size_t k;
11461 if (soap_append_lab(soap, NULL, 0)) /* allocate more space in look-aside buffer if necessary */
11462 return NULL;
11463 s = soap->labbuf + soap->labidx; /* space to populate */
11464 k = soap->lablen - soap->labidx; /* number of bytes available */
11465 soap->labidx = soap->lablen; /* claim this space */
11466 #else
11467 register size_t k = SOAP_BLKLEN;
11468 if (!(s = (char*)soap_push_block(soap, NULL, k)))
11469 return NULL;
11470 #endif
11471 for (i = 0; i < k; i++)
11472 { if (m > 0)
11473 { *s++ = *t++; /* copy multibyte characters */
11474 m--;
11475 continue;
11476 }
11477 #ifndef WITH_CDATA
11478 if (!flag)
11479 c = soap_getchar(soap);
11480 else
11481 #endif
11482 if ((soap->mode & SOAP_C_UTFSTRING))
11483 { if (((c = soap_get(soap)) & 0x80000000) && c >= -0x7FFFFF80 && c < SOAP_AP)
11484 { c &= 0x7FFFFFFF;
11485 t = buf;
11486 if (c < 0x0800)
11487 *t++ = (char)(0xC0 | ((c >> 6) & 0x1F));
11488 else
11489 { if (c < 0x010000)
11490 *t++ = (char)(0xE0 | ((c >> 12) & 0x0F));
11491 else
11492 { if (c < 0x200000)
11493 *t++ = (char)(0xF0 | ((c >> 18) & 0x07));
11494 else
11495 { if (c < 0x04000000)
11496 *t++ = (char)(0xF8 | ((c >> 24) & 0x03));
11497 else
11498 { *t++ = (char)(0xFC | ((c >> 30) & 0x01));
11499 *t++ = (char)(0x80 | ((c >> 24) & 0x3F));
11500 }
11501 *t++ = (char)(0x80 | ((c >> 18) & 0x3F));
11502 }
11503 *t++ = (char)(0x80 | ((c >> 12) & 0x3F));
11504 }
11505 *t++ = (char)(0x80 | ((c >> 6) & 0x3F));
11506 }
11507 *t++ = (char)(0x80 | (c & 0x3F));
11508 m = (int)(t - buf) - 1;
11509 t = buf;
11510 *s++ = *t++;
11511 continue;
11512 }
11513 }
11514 else
11515 c = soap_getutf8(soap);
11516 switch (c)
11517 {
11518 case SOAP_TT:
11519 if (n == 0)
11520 goto end;
11521 n--;
11522 *s++ = '<';
11523 t = (char*)"/";
11524 m = 1;
11525 break;
11526 case SOAP_LT:
11527 if (f && n == 0)
11528 goto end;
11529 n++;
11530 *s++ = '<';
11531 break;
11532 case SOAP_GT:
11533 *s++ = '>';
11534 break;
11535 case SOAP_QT:
11536 *s++ = '"';
11537 break;
11538 case SOAP_AP:
11539 *s++ = '\'';
11540 break;
11541 case '/':
11542 if (n > 0)
11543 { if (!flag)
11544 { c = soap_getchar(soap);
11545 if (c == '>')
11546 n--;
11547 }
11548 else
11549 { c = soap_get(soap);
11550 if (c == SOAP_GT)
11551 n--;
11552 }
11553 soap_unget(soap, c);
11554 }
11555 *s++ = '/';
11556 break;
11557 case (soap_wchar)('<' | 0x80000000):
11558 if (flag)
11559 *s++ = '<';
11560 else
11561 { *s++ = '&';
11562 t = (char*)"lt;";
11563 m = 3;
11564 }
11565 break;
11566 case (soap_wchar)('>' | 0x80000000):
11567 if (flag)
11568 *s++ = '>';
11569 else
11570 { *s++ = '&';
11571 t = (char*)"gt;";
11572 m = 3;
11573 }
11574 break;
11575 case (soap_wchar)('&' | 0x80000000):
11576 if (flag)
11577 *s++ = '&';
11578 else
11579 { *s++ = '&';
11580 t = (char*)"amp;";
11581 m = 4;
11582 }
11583 break;
11584 case (soap_wchar)('"' | 0x80000000):
11585 if (flag)
11586 *s++ = '"';
11587 else
11588 { *s++ = '&';
11589 t = (char*)"quot;";
11590 m = 5;
11591 }
11592 break;
11593 case (soap_wchar)('\'' | 0x80000000):
11594 if (flag)
11595 *s++ = '\'';
11596 else
11597 { *s++ = '&';
11598 t = (char*)"apos;";
11599 m = 5;
11600 }
11601 break;
11602 default:
11603 if ((int)c == EOF)
11604 goto end;
11605 #ifndef WITH_CDATA
11606 if (c == '<' && !flag)
11607 { if (f && n == 0)
11608 goto end;
11609 c = soap_getchar(soap);
11610 soap_unget(soap, c);
11611 if (c == '/')
11612 { c = SOAP_TT;
11613 if (n == 0)
11614 goto end;
11615 n--;
11616 }
11617 else
11618 n++;
11619 *s++ = '<';
11620 break;
11621 }
11622 else
11623 #endif
11624 #ifndef WITH_LEANER
11625 #ifdef HAVE_WCTOMB
11626 if (soap->mode & SOAP_C_MBSTRING)
11627 { m = wctomb(buf, (wchar_t)(c & 0x7FFFFFFF));
11628 if (m >= 1 && m <= (int)MB_CUR_MAX)
11629 { t = buf;
11630 *s++ = *t++;
11631 m--;
11632 }
11633 else
11634 { *s++ = SOAP_UNKNOWN_CHAR;
11635 m = 0;
11636 }
11637 }
11638 else
11639 #endif
11640 #endif
11641 *s++ = (char)(c & 0xFF);
11642 }
11643 l++;
11644 if (maxlen >= 0 && l > maxlen)
11645 { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "String too long: maxlen=%ld\n", maxlen));
11646 soap->error = SOAP_LENGTH;
11647 return NULL;
11648 }
11649 }
11650 }
11651 end:
11652 soap_unget(soap, c);
11653 *s = '\0';
11654 #ifdef WITH_FAST
11655 t = soap_strdup(soap, soap->labbuf);
11656 #else
11657 soap_size_block(soap, NULL, i + 1);
11658 t = soap_save_block(soap, NULL, 0);
11659 #endif
11660 if (l < minlen)
11661 { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "String too short: %ld chars, minlen=%ld\n", l, minlen));
11662 soap->error = SOAP_LENGTH;
11663 return NULL;
11664 }
11665 #ifdef WITH_DOM
11666 if ((soap->mode & SOAP_XML_DOM) && soap->dom)
11667 { if (flag == 3)
11668 soap->dom->tail = t;
11669 else
11670 soap->dom->data = t;
11671 }
11672 #endif
11673 if (flag == 2)
11674 if (soap_s2QName(soap, t, &t, minlen, maxlen))
11675 return NULL;
11676 return t;
11677 }
11678 #endif
11679
11680 /******************************************************************************/
11681 #ifndef WITH_LEANER
11682 #ifndef PALM_2
11683 SOAP_FMAC1
11684 int
11685 SOAP_FMAC2
11686 soap_wstring_out(struct soap *soap, const wchar_t *s, int flag)
11687 { const char *t;
11688 char tmp;
11689 register soap_wchar c;
11690 #ifdef WITH_DOM
11691 if ((soap->mode & SOAP_XML_DOM) && soap->dom)
11692 { wchar_t *r = (wchar_t*)s;
11693 int n = 1;
11694 while (*r++)
11695 n++;
11696 soap->dom->wide = r = (wchar_t*)soap_malloc(soap, n * sizeof(wchar_t));
11697 while (n--)
11698 *r++ = *s++;
11699 return SOAP_OK;
11700 }
11701 #endif
11702 while ((c = *s++))
11703 { switch (c)
11704 {
11705 case 0x09:
11706 if (flag)
11707 t = "&#x9;";
11708 else
11709 t = "\t";
11710 break;
11711 case 0x0A:
11712 if (flag || !(soap->mode & SOAP_XML_CANONICAL))
11713 t = "&#xA;";
11714 else
11715 t = "\n";
11716 break;
11717 case 0x0D:
11718 t = "&#xD;";
11719 break;
11720 case '&':
11721 t = "&amp;";
11722 break;
11723 case '<':
11724 t = "&lt;";
11725 break;
11726 case '>':
11727 if (flag)
11728 t = ">";
11729 else
11730 t = "&gt;";
11731 break;
11732 case '"':
11733 if (flag)
11734 t = "&quot;";
11735 else
11736 t = "\"";
11737 break;
11738 default:
11739 if (c >= 0x20 && c < 0x80)
11740 { tmp = (char)c;
11741 if (soap_send_raw(soap, &tmp, 1))
11742 return soap->error;
11743 }
11744 else
11745 { /* check for UTF16 encoding when wchar_t is too small to hold UCS */
11746 if (sizeof(wchar_t) < 4 && (c & 0xFC00) == 0xD800)
11747 { register soap_wchar d = *s++;
11748 if ((d & 0xFC00) == 0xDC00)
11749 c = ((c - 0xD800) << 10) + (d - 0xDC00) + 0x10000;
11750 else
11751 c = 0xFFFD; /* Malformed */
11752 }
11753 if (soap_pututf8(soap, (unsigned long)c))
11754 return soap->error;
11755 }
11756 continue;
11757 }
11758 if (soap_send(soap, t))
11759 return soap->error;
11760 }
11761 return SOAP_OK;
11762 }
11763 #endif
11764 #endif
11765
11766 /******************************************************************************/
11767 #ifndef WITH_LEANER
11768 #ifndef PALM_2
11769 SOAP_FMAC1
11770 wchar_t *
11771 SOAP_FMAC2
11772 soap_wstring_in(struct soap *soap, int flag, long minlen, long maxlen)
11773 { wchar_t *s;
11774 register int i, n = 0, f = 0;
11775 register long l = 0;
11776 register soap_wchar c;
11777 char *t = NULL;
11778 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Reading wide string content\n"));
11779 if (soap->peeked)
11780 { if (*soap->tag)
11781 {
11782 #ifndef WITH_LEAN
11783 struct soap_attribute *tp;
11784 t = soap->tmpbuf;
11785 *t = '<';
11786 strncpy(t + 1, soap->tag, sizeof(soap->tmpbuf) - 2);
11787 t[sizeof(soap->tmpbuf) - 1] = '\0';
11788 t += strlen(t);
11789 for (tp = soap->attributes; tp; tp = tp->next)
11790 { if (tp->visible)
11791 { if (t >= soap->tmpbuf + sizeof(soap->tmpbuf) - 2)
11792 break;
11793 *t++ = ' ';
11794 strcpy(t, tp->name);
11795 t += strlen(t);
11796 if (t >= soap->tmpbuf + sizeof(soap->tmpbuf) - 2)
11797 break;
11798 if (tp->value)
11799 { *t++ = '=';
11800 *t++ = '"';
11801 strcpy(t, tp->value);
11802 t += strlen(t);
11803 *t++ = '"';
11804 }
11805 }
11806 }
11807 if (!soap->body)
11808 *t++ = '/';
11809 *t++ = '>';
11810 *t = '\0';
11811 t = soap->tmpbuf;
11812 #endif
11813 if (soap->body)
11814 n = 1;
11815 f = 1;
11816 soap->peeked = 0;
11817 }
11818 }
11819 if (soap_new_block(soap) == NULL)
11820 return NULL;
11821 for (;;)
11822 { if (!(s = (wchar_t*)soap_push_block(soap, NULL, sizeof(wchar_t)*SOAP_BLKLEN)))
11823 return NULL;
11824 for (i = 0; i < SOAP_BLKLEN; i++)
11825 { if (t)
11826 { *s++ = (wchar_t)*t++;
11827 if (!*t)
11828 t = NULL;
11829 continue;
11830 }
11831 c = soap_getutf8(soap);
11832 switch (c)
11833 {
11834 case SOAP_TT:
11835 if (n == 0)
11836 goto end;
11837 n--;
11838 *s++ = '<';
11839 soap_unget(soap, '/');
11840 break;
11841 case SOAP_LT:
11842 if (f && n == 0)
11843 goto end;
11844 n++;
11845 *s++ = '<';
11846 break;
11847 case SOAP_GT:
11848 *s++ = '>';
11849 break;
11850 case SOAP_QT:
11851 *s++ = '"';
11852 break;
11853 case SOAP_AP:
11854 *s++ = '\'';
11855 break;
11856 case '/':
11857 if (n > 0)
11858 { c = soap_getutf8(soap);
11859 if (c == SOAP_GT)
11860 n--;
11861 soap_unget(soap, c);
11862 }
11863 *s++ = '/';
11864 break;
11865 case '<':
11866 if (flag)
11867 *s++ = (soap_wchar)'<';
11868 else
11869 { *s++ = (soap_wchar)'&';
11870 t = (char*)"lt;";
11871 }
11872 break;
11873 case '>':
11874 if (flag)
11875 *s++ = (soap_wchar)'>';
11876 else
11877 { *s++ = (soap_wchar)'&';
11878 t = (char*)"gt;";
11879 }
11880 break;
11881 case '"':
11882 if (flag)
11883 *s++ = (soap_wchar)'"';
11884 else
11885 { *s++ = (soap_wchar)'&';
11886 t = (char*)"quot;";
11887 }
11888 break;
11889 default:
11890 if ((int)c == EOF)
11891 goto end;
11892 /* use UTF16 encoding when wchar_t is too small to hold UCS */
11893 if (sizeof(wchar_t) < 4 && c > 0xFFFF)
11894 { register soap_wchar c1, c2;
11895 c1 = 0xD800 - (0x10000 >> 10) + (c >> 10);
11896 c2 = 0xDC00 + (c & 0x3FF);
11897 c = c1;
11898 soap_unget(soap, c2);
11899 }
11900 *s++ = (wchar_t)c & 0x7FFFFFFF;
11901 }
11902 l++;
11903 if (maxlen >= 0 && l > maxlen)
11904 { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "String too long: maxlen=%ld\n", maxlen));
11905 soap->error = SOAP_LENGTH;
11906 return NULL;
11907 }
11908 }
11909 }
11910 end:
11911 soap_unget(soap, c);
11912 *s = '\0';
11913 soap_size_block(soap, NULL, sizeof(wchar_t) * (i + 1));
11914 if (l < minlen)
11915 { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "String too short: %ld chars, minlen=%ld\n", l, minlen));
11916 soap->error = SOAP_LENGTH;
11917 return NULL;
11918 }
11919 s = (wchar_t*)soap_save_block(soap, NULL, NULL, 0);
11920 #ifdef WITH_DOM
11921 if ((soap->mode & SOAP_XML_DOM) && soap->dom)
11922 soap->dom->wide = s;
11923 #endif
11924 return s;
11925 }
11926 #endif
11927 #endif
11928
11929 /******************************************************************************/
11930 #ifndef PALM_2
11931 SOAP_FMAC1
11932 const char*
11933 SOAP_FMAC2
11934 soap_int2s(struct soap *soap, int n)
11935 { return soap_long2s(soap, (long)n);
11936 }
11937 #endif
11938
11939 /******************************************************************************/
11940 #ifndef PALM_2
11941 SOAP_FMAC1
11942 int
11943 SOAP_FMAC2
11944 soap_outint(struct soap *soap, const char *tag, int id, const int *p, const char *type, int n)
11945 { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
11946 || soap_string_out(soap, soap_long2s(soap, (long)*p), 0))
11947 return soap->error;
11948 return soap_element_end_out(soap, tag);
11949 }
11950 #endif
11951
11952 /******************************************************************************/
11953 #ifndef PALM_2
11954 SOAP_FMAC1
11955 int
11956 SOAP_FMAC2
11957 soap_s2int(struct soap *soap, const char *s, int *p)
11958 { if (s)
11959 { long n;
11960 char *r;
11961 #ifndef WITH_NOIO
11962 #ifndef WITH_LEAN
11963 soap_reset_errno;
11964 #endif
11965 #endif
11966 n = soap_strtol(s, &r, 10);
11967 if (s == r || *r
11968 #ifndef WITH_LEAN
11969 || n != (int)n
11970 #endif
11971 #ifndef WITH_NOIO
11972 #ifndef WITH_LEAN
11973 || soap_errno == SOAP_ERANGE
11974 #endif
11975 #endif
11976 )
11977 soap->error = SOAP_TYPE;
11978 *p = (int)n;
11979 }
11980 return soap->error;
11981 }
11982 #endif
11983
11984 /******************************************************************************/
11985 #ifndef PALM_2
11986 SOAP_FMAC1
11987 int *
11988 SOAP_FMAC2
11989 soap_inint(struct soap *soap, const char *tag, int *p, const char *type, int t)
11990 { if (soap_element_begin_in(soap, tag, 0, NULL))
11991 return NULL;
11992 #ifndef WITH_LEAN
11993 if (*soap->type
11994 && soap_match_tag(soap, soap->type, type)
11995 && soap_match_tag(soap, soap->type, ":int")
11996 && soap_match_tag(soap, soap->type, ":short")
11997 && soap_match_tag(soap, soap->type, ":byte"))
11998 { soap->error = SOAP_TYPE;
11999 soap_revert(soap);
12000 return NULL;
12001 }
12002 #endif
12003 p = (int*)soap_id_enter(soap, soap->id, p, t, sizeof(int), 0, NULL, NULL, NULL);
12004 if (*soap->href)
12005 p = (int*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(int), 0, NULL);
12006 else if (p)
12007 { if (soap_s2int(soap, soap_value(soap), p))
12008 return NULL;
12009 }
12010 if (soap->body && soap_element_end_in(soap, tag))
12011 return NULL;
12012 return p;
12013 }
12014 #endif
12015
12016 /******************************************************************************/
12017 #ifndef PALM_2
12018 SOAP_FMAC1
12019 const char*
12020 SOAP_FMAC2
12021 soap_long2s(struct soap *soap, long n)
12022 {
12023 #ifdef HAVE_SNPRINTF
12024 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), "%ld", n);
12025 #else
12026 sprintf(soap->tmpbuf, "%ld", n);
12027 #endif
12028 return soap->tmpbuf;
12029 }
12030 #endif
12031
12032 /******************************************************************************/
12033 #ifndef PALM_2
12034 SOAP_FMAC1
12035 int
12036 SOAP_FMAC2
12037 soap_outlong(struct soap *soap, const char *tag, int id, const long *p, const char *type, int n)
12038 { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
12039 || soap_string_out(soap, soap_long2s(soap, *p), 0))
12040 return soap->error;
12041 return soap_element_end_out(soap, tag);
12042 }
12043 #endif
12044
12045 /******************************************************************************/
12046 #ifndef PALM_2
12047 SOAP_FMAC1
12048 int
12049 SOAP_FMAC2
12050 soap_s2long(struct soap *soap, const char *s, long *p)
12051 { if (s)
12052 { char *r;
12053 #ifndef WITH_NOIO
12054 #ifndef WITH_LEAN
12055 soap_reset_errno;
12056 #endif
12057 #endif
12058 *p = soap_strtol(s, &r, 10);
12059 if (s == r || *r
12060 #ifndef WITH_NOIO
12061 #ifndef WITH_LEAN
12062 || soap_errno == SOAP_ERANGE
12063 #endif
12064 #endif
12065 )
12066 soap->error = SOAP_TYPE;
12067 }
12068 return soap->error;
12069 }
12070 #endif
12071
12072 /******************************************************************************/
12073 #ifndef PALM_2
12074 SOAP_FMAC1
12075 long *
12076 SOAP_FMAC2
12077 soap_inlong(struct soap *soap, const char *tag, long *p, const char *type, int t)
12078 { if (soap_element_begin_in(soap, tag, 0, NULL))
12079 return NULL;
12080 #ifndef WITH_LEAN
12081 if (*soap->type
12082 && soap_match_tag(soap, soap->type, type)
12083 && soap_match_tag(soap, soap->type, ":int")
12084 && soap_match_tag(soap, soap->type, ":short")
12085 && soap_match_tag(soap, soap->type, ":byte"))
12086 { soap->error = SOAP_TYPE;
12087 soap_revert(soap);
12088 return NULL;
12089 }
12090 #endif
12091 p = (long*)soap_id_enter(soap, soap->id, p, t, sizeof(long), 0, NULL, NULL, NULL);
12092 if (*soap->href)
12093 p = (long*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(long), 0, NULL);
12094 else if (p)
12095 { if (soap_s2long(soap, soap_value(soap), p))
12096 return NULL;
12097 }
12098 if (soap->body && soap_element_end_in(soap, tag))
12099 return NULL;
12100 return p;
12101 }
12102 #endif
12103
12104 /******************************************************************************/
12105 #ifndef WITH_LEAN
12106 SOAP_FMAC1
12107 const char*
12108 SOAP_FMAC2
12109 soap_LONG642s(struct soap *soap, LONG64 n)
12110 {
12111 #ifdef HAVE_SNPRINTF
12112 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), SOAP_LONG_FORMAT, n);
12113 #else
12114 sprintf(soap->tmpbuf, SOAP_LONG_FORMAT, n);
12115 #endif
12116 return soap->tmpbuf;
12117 }
12118 #endif
12119
12120 /******************************************************************************/
12121 #ifndef WITH_LEAN
12122 SOAP_FMAC1
12123 int
12124 SOAP_FMAC2
12125 soap_outLONG64(struct soap *soap, const char *tag, int id, const LONG64 *p, const char *type, int n)
12126 { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
12127 || soap_string_out(soap, soap_LONG642s(soap, *p), 0))
12128 return soap->error;
12129 return soap_element_end_out(soap, tag);
12130 }
12131 #endif
12132
12133 /******************************************************************************/
12134 #ifndef WITH_LEAN
12135 SOAP_FMAC1
12136 int
12137 SOAP_FMAC2
12138 soap_s2LONG64(struct soap *soap, const char *s, LONG64 *p)
12139 { if (s)
12140 {
12141 #ifdef HAVE_STRTOLL
12142 char *r;
12143 #ifndef WITH_NOIO
12144 #ifndef WITH_LEAN
12145 soap_reset_errno;
12146 #endif
12147 #endif
12148 *p = soap_strtoll(s, &r, 10);
12149 if (s == r || *r
12150 #ifndef WITH_NOIO
12151 #ifndef WITH_LEAN
12152 || soap_errno == SOAP_ERANGE
12153 #endif
12154 #endif
12155 )
12156 #else
12157 # ifdef HAVE_SSCANF
12158 if (sscanf(s, SOAP_LONG_FORMAT, p) != 1)
12159 # endif
12160 #endif
12161 soap->error = SOAP_TYPE;
12162 }
12163 return soap->error;
12164 }
12165 #endif
12166
12167 /******************************************************************************/
12168 #ifndef WITH_LEAN
12169 SOAP_FMAC1
12170 LONG64 *
12171 SOAP_FMAC2
12172 soap_inLONG64(struct soap *soap, const char *tag, LONG64 *p, const char *type, int t)
12173 { if (soap_element_begin_in(soap, tag, 0, NULL))
12174 return NULL;
12175 #ifndef WITH_LEAN
12176 if (*soap->type
12177 && soap_match_tag(soap, soap->type, type)
12178 && soap_match_tag(soap, soap->type, ":integer")
12179 && soap_match_tag(soap, soap->type, ":positiveInteger")
12180 && soap_match_tag(soap, soap->type, ":negativeInteger")
12181 && soap_match_tag(soap, soap->type, ":nonPositiveInteger")
12182 && soap_match_tag(soap, soap->type, ":nonNegativeInteger")
12183 && soap_match_tag(soap, soap->type, ":long")
12184 && soap_match_tag(soap, soap->type, ":int")
12185 && soap_match_tag(soap, soap->type, ":short")
12186 && soap_match_tag(soap, soap->type, ":byte"))
12187 { soap->error = SOAP_TYPE;
12188 soap_revert(soap);
12189 return NULL;
12190 }
12191 #endif
12192 p = (LONG64*)soap_id_enter(soap, soap->id, p, t, sizeof(LONG64), 0, NULL, NULL, NULL);
12193 if (*soap->href)
12194 p = (LONG64*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(LONG64), 0, NULL);
12195 else if (p)
12196 { if (soap_s2LONG64(soap, soap_value(soap), p))
12197 return NULL;
12198 }
12199 if (soap->body && soap_element_end_in(soap, tag))
12200 return NULL;
12201 return p;
12202 }
12203 #endif
12204
12205 /******************************************************************************/
12206 #ifndef PALM_2
12207 SOAP_FMAC1
12208 const char*
12209 SOAP_FMAC2
12210 soap_byte2s(struct soap *soap, char n)
12211 { return soap_long2s(soap, (long)n);
12212 }
12213 #endif
12214
12215 /******************************************************************************/
12216 #ifndef PALM_2
12217 SOAP_FMAC1
12218 int
12219 SOAP_FMAC2
12220 soap_outbyte(struct soap *soap, const char *tag, int id, const char *p, const char *type, int n)
12221 { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
12222 || soap_string_out(soap, soap_long2s(soap, (long)*p), 0))
12223 return soap->error;
12224 return soap_element_end_out(soap, tag);
12225 }
12226 #endif
12227
12228 /******************************************************************************/
12229 #ifndef PALM_2
12230 SOAP_FMAC1
12231 int
12232 SOAP_FMAC2
12233 soap_s2byte(struct soap *soap, const char *s, char *p)
12234 { if (s)
12235 { long n;
12236 char *r;
12237 n = soap_strtol(s, &r, 10);
12238 if (s == r || *r || n < -128 || n > 127)
12239 soap->error = SOAP_TYPE;
12240 *p = (char)n;
12241 }
12242 return soap->error;
12243 }
12244 #endif
12245
12246 /******************************************************************************/
12247 #ifndef PALM_2
12248 SOAP_FMAC1
12249 char *
12250 SOAP_FMAC2
12251 soap_inbyte(struct soap *soap, const char *tag, char *p, const char *type, int t)
12252 { if (soap_element_begin_in(soap, tag, 0, NULL))
12253 return NULL;
12254 #ifndef WITH_LEAN
12255 if (*soap->type
12256 && soap_match_tag(soap, soap->type, type)
12257 && soap_match_tag(soap, soap->type, ":byte"))
12258 { soap->error = SOAP_TYPE;
12259 soap_revert(soap);
12260 return NULL;
12261 }
12262 #endif
12263 p = (char*)soap_id_enter(soap, soap->id, p, t, sizeof(char), 0, NULL, NULL, NULL);
12264 if (*soap->href)
12265 p = (char*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(char), 0, NULL);
12266 else if (p)
12267 { if (soap_s2byte(soap, soap_value(soap), p))
12268 return NULL;
12269 }
12270 if (soap->body && soap_element_end_in(soap, tag))
12271 return NULL;
12272 return p;
12273 }
12274 #endif
12275
12276 /******************************************************************************/
12277 #ifndef PALM_2
12278 SOAP_FMAC1
12279 const char*
12280 SOAP_FMAC2
12281 soap_short2s(struct soap *soap, short n)
12282 { return soap_long2s(soap, (long)n);
12283 }
12284 #endif
12285
12286 /******************************************************************************/
12287 #ifndef PALM_2
12288 SOAP_FMAC1
12289 int
12290 SOAP_FMAC2
12291 soap_outshort(struct soap *soap, const char *tag, int id, const short *p, const char *type, int n)
12292 { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
12293 || soap_string_out(soap, soap_long2s(soap, (long)*p), 0))
12294 return soap->error;
12295 return soap_element_end_out(soap, tag);
12296 }
12297 #endif
12298
12299 /******************************************************************************/
12300 #ifndef PALM_2
12301 SOAP_FMAC1
12302 int
12303 SOAP_FMAC2
12304 soap_s2short(struct soap *soap, const char *s, short *p)
12305 { if (s)
12306 { long n;
12307 char *r;
12308 n = soap_strtol(s, &r, 10);
12309 if (s == r || *r || n < -32768 || n > 32767)
12310 soap->error = SOAP_TYPE;
12311 *p = (short)n;
12312 }
12313 return soap->error;
12314 }
12315 #endif
12316
12317 /******************************************************************************/
12318 #ifndef PALM_2
12319 SOAP_FMAC1
12320 short *
12321 SOAP_FMAC2
12322 soap_inshort(struct soap *soap, const char *tag, short *p, const char *type, int t)
12323 { if (soap_element_begin_in(soap, tag, 0, NULL))
12324 return NULL;
12325 #ifndef WITH_LEAN
12326 if (*soap->type
12327 && soap_match_tag(soap, soap->type, type)
12328 && soap_match_tag(soap, soap->type, ":short")
12329 && soap_match_tag(soap, soap->type, ":byte"))
12330 { soap->error = SOAP_TYPE;
12331 soap_revert(soap);
12332 return NULL;
12333 }
12334 #endif
12335 p = (short*)soap_id_enter(soap, soap->id, p, t, sizeof(short), 0, NULL, NULL, NULL);
12336 if (*soap->href)
12337 p = (short*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(short), 0, NULL);
12338 else if (p)
12339 { if (soap_s2short(soap, soap_value(soap), p))
12340 return NULL;
12341 }
12342 if (soap->body && soap_element_end_in(soap, tag))
12343 return NULL;
12344 return p;
12345 }
12346 #endif
12347
12348 /******************************************************************************/
12349 #ifndef PALM_2
12350 SOAP_FMAC1
12351 const char*
12352 SOAP_FMAC2
12353 soap_float2s(struct soap *soap, float n)
12354 { char *s;
12355 if (soap_isnan((double)n))
12356 return "NaN";
12357 if (soap_ispinff(n))
12358 return "INF";
12359 if (soap_isninff(n))
12360 return "-INF";
12361 #if defined(HAVE_SPRINTF_L)
12362 # ifdef WIN32
12363 _sprintf_s_l(soap->tmpbuf, _countof(soap->tmpbuf), soap->float_format, soap->c_locale, n);
12364 # else
12365 sprintf_l(soap->tmpbuf, soap->c_locale, soap->float_format, n);
12366 # endif
12367 #else
12368 # ifdef HAVE_SNPRINTF
12369 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), soap->float_format, n);
12370 # else
12371 sprintf(soap->tmpbuf, soap->float_format, n);
12372 # endif
12373 s = strchr(soap->tmpbuf, ','); /* convert decimal comma to DP */
12374 if (s)
12375 *s = '.';
12376 #endif
12377 return soap->tmpbuf;
12378 }
12379 #endif
12380
12381 /******************************************************************************/
12382 #ifndef PALM_2
12383 SOAP_FMAC1
12384 int
12385 SOAP_FMAC2
12386 soap_outfloat(struct soap *soap, const char *tag, int id, const float *p, const char *type, int n)
12387 { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
12388 || soap_string_out(soap, soap_float2s(soap, *p), 0))
12389 return soap->error;
12390 return soap_element_end_out(soap, tag);
12391 }
12392 #endif
12393
12394 /******************************************************************************/
12395 #ifndef PALM_2
12396 SOAP_FMAC1
12397 int
12398 SOAP_FMAC2
12399 soap_s2float(struct soap *soap, const char *s, float *p)
12400 { if (s)
12401 { if (!*s)
12402 return soap->error = SOAP_TYPE;
12403 if (!soap_tag_cmp(s, "INF"))
12404 *p = FLT_PINFTY;
12405 else if (!soap_tag_cmp(s, "+INF"))
12406 *p = FLT_PINFTY;
12407 else if (!soap_tag_cmp(s, "-INF"))
12408 *p = FLT_NINFTY;
12409 else if (!soap_tag_cmp(s, "NaN"))
12410 *p = FLT_NAN;
12411 else
12412 {
12413 /* On some systems strtof requires -std=c99 or does not even link: so we try to use strtod first */
12414 #if defined(HAVE_STRTOD_L)
12415 char *r;
12416 # ifdef WIN32
12417 *p = (float)_strtod_l(s, &r, soap->c_locale);
12418 # else
12419 *p = (float)strtod_l(s, &r, soap->c_locale);
12420 # endif
12421 if (*r)
12422 #elif defined(HAVE_STRTOD)
12423 char *r;
12424 *p = (float)strtod(s, &r);
12425 if (*r)
12426 #elif defined(HAVE_STRTOF_L)
12427 char *r;
12428 *p = strtof_l((char*)s, &r, soap->c_locale);
12429 if (*r)
12430 #elif defined(HAVE_STRTOF)
12431 char *r;
12432 *p = strtof((char*)s, &r);
12433 if (*r)
12434 #endif
12435 {
12436 #if defined(HAVE_SSCANF_L) && !defined(HAVE_STRTOF_L) && !defined(HAVE_STRTOD_L)
12437 if (sscanf_l(s, soap->c_locale, "%f", p) != 1)
12438 soap->error = SOAP_TYPE;
12439 #elif defined(HAVE_SSCANF)
12440 if (sscanf(s, "%f", p) != 1)
12441 soap->error = SOAP_TYPE;
12442 #else
12443 soap->error = SOAP_TYPE;
12444 #endif
12445 }
12446 }
12447 }
12448 return soap->error;
12449 }
12450 #endif
12451
12452 /******************************************************************************/
12453 #ifndef WITH_LEAN
12454 static int soap_isnumeric(struct soap *soap, const char *type)
12455 { if (soap_match_tag(soap, soap->type, type)
12456 && soap_match_tag(soap, soap->type, ":float")
12457 && soap_match_tag(soap, soap->type, ":double")
12458 && soap_match_tag(soap, soap->type, ":decimal")
12459 && soap_match_tag(soap, soap->type, ":integer")
12460 && soap_match_tag(soap, soap->type, ":positiveInteger")
12461 && soap_match_tag(soap, soap->type, ":negativeInteger")
12462 && soap_match_tag(soap, soap->type, ":nonPositiveInteger")
12463 && soap_match_tag(soap, soap->type, ":nonNegativeInteger")
12464 && soap_match_tag(soap, soap->type, ":long")
12465 && soap_match_tag(soap, soap->type, ":int")
12466 && soap_match_tag(soap, soap->type, ":short")
12467 && soap_match_tag(soap, soap->type, ":byte")
12468 && soap_match_tag(soap, soap->type, ":unsignedLong")
12469 && soap_match_tag(soap, soap->type, ":unsignedInt")
12470 && soap_match_tag(soap, soap->type, ":unsignedShort")
12471 && soap_match_tag(soap, soap->type, ":unsignedByte"))
12472 { soap->error = SOAP_TYPE;
12473 soap_revert(soap);
12474 return SOAP_ERR;
12475 }
12476 return SOAP_OK;
12477 }
12478 #endif
12479
12480 /******************************************************************************/
12481 #ifndef PALM_2
12482 SOAP_FMAC1
12483 float *
12484 SOAP_FMAC2
12485 soap_infloat(struct soap *soap, const char *tag, float *p, const char *type, int t)
12486 { if (soap_element_begin_in(soap, tag, 0, NULL))
12487 return NULL;
12488 #ifndef WITH_LEAN
12489 if (*soap->type != '\0' && soap_isnumeric(soap, type))
12490 return NULL;
12491 #endif
12492 p = (float*)soap_id_enter(soap, soap->id, p, t, sizeof(float), 0, NULL, NULL, NULL);
12493 if (*soap->href)
12494 p = (float*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(float), 0, NULL);
12495 else if (p)
12496 { if (soap_s2float(soap, soap_value(soap), p))
12497 return NULL;
12498 }
12499 if (soap->body && soap_element_end_in(soap, tag))
12500 return NULL;
12501 return p;
12502 }
12503 #endif
12504
12505 /******************************************************************************/
12506 #ifndef PALM_2
12507 SOAP_FMAC1
12508 const char*
12509 SOAP_FMAC2
12510 soap_double2s(struct soap *soap, double n)
12511 { char *s;
12512 if (soap_isnan(n))
12513 return "NaN";
12514 if (soap_ispinfd(n))
12515 return "INF";
12516 if (soap_isninfd(n))
12517 return "-INF";
12518 #if defined(HAVE_SPRINTF_L)
12519 # ifdef WIN32
12520 _sprintf_s_l(soap->tmpbuf, _countof(soap->tmpbuf), soap->double_format, soap->c_locale, n);
12521 # else
12522 sprintf_l(soap->tmpbuf, soap->c_locale, soap->double_format, n);
12523 # endif
12524 #else
12525 # ifdef HAVE_SNPRINTF
12526 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), soap->double_format, n);
12527 #else
12528 sprintf(soap->tmpbuf, soap->double_format, n);
12529 #endif
12530 s = strchr(soap->tmpbuf, ','); /* convert decimal comma to DP */
12531 if (s)
12532 *s = '.';
12533 #endif
12534 return soap->tmpbuf;
12535 }
12536 #endif
12537
12538 /******************************************************************************/
12539 #ifndef PALM_2
12540 SOAP_FMAC1
12541 int
12542 SOAP_FMAC2
12543 soap_outdouble(struct soap *soap, const char *tag, int id, const double *p, const char *type, int n)
12544 { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
12545 || soap_string_out(soap, soap_double2s(soap, *p), 0))
12546 return soap->error;
12547 return soap_element_end_out(soap, tag);
12548 }
12549 #endif
12550
12551 /******************************************************************************/
12552 #ifndef PALM_2
12553 SOAP_FMAC1
12554 int
12555 SOAP_FMAC2
12556 soap_s2double(struct soap *soap, const char *s, double *p)
12557 { if (s)
12558 { if (!*s)
12559 return soap->error = SOAP_TYPE;
12560 if (!soap_tag_cmp(s, "INF"))
12561 *p = DBL_PINFTY;
12562 else if (!soap_tag_cmp(s, "+INF"))
12563 *p = DBL_PINFTY;
12564 else if (!soap_tag_cmp(s, "-INF"))
12565 *p = DBL_NINFTY;
12566 else if (!soap_tag_cmp(s, "NaN"))
12567 *p = DBL_NAN;
12568 else
12569 {
12570 #if defined(HAVE_STRTOD_L)
12571 char *r;
12572 # ifdef WIN32
12573 *p = _strtod_l(s, &r, soap->c_locale);
12574 # else
12575 *p = strtod_l(s, &r, soap->c_locale);
12576 # endif
12577 if (*r)
12578 #elif defined(HAVE_STRTOD)
12579 char *r;
12580 *p = strtod(s, &r);
12581 if (*r)
12582 #endif
12583 {
12584 #if defined(HAVE_SSCANF_L) && !defined(HAVE_STRTOF_L) && !defined(HAVE_STRTOD_L)
12585 if (sscanf_l(s, soap->c_locale, "%lf", p) != 1)
12586 soap->error = SOAP_TYPE;
12587 #elif defined(HAVE_SSCANF)
12588 if (sscanf(s, "%lf", p) != 1)
12589 soap->error = SOAP_TYPE;
12590 #else
12591 soap->error = SOAP_TYPE;
12592 #endif
12593 }
12594 }
12595 }
12596 return soap->error;
12597 }
12598 #endif
12599
12600 /******************************************************************************/
12601 #ifndef PALM_2
12602 SOAP_FMAC1
12603 double *
12604 SOAP_FMAC2
12605 soap_indouble(struct soap *soap, const char *tag, double *p, const char *type, int t)
12606 { if (soap_element_begin_in(soap, tag, 0, NULL))
12607 return NULL;
12608 #ifndef WITH_LEAN
12609 if (*soap->type != '\0' && soap_isnumeric(soap, type))
12610 return NULL;
12611 #endif
12612 p = (double*)soap_id_enter(soap, soap->id, p, t, sizeof(double), 0, NULL, NULL, NULL);
12613 if (*soap->href)
12614 p = (double*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(double), 0, NULL);
12615 else if (p)
12616 { if (soap_s2double(soap, soap_value(soap), p))
12617 return NULL;
12618 }
12619 if (soap->body && soap_element_end_in(soap, tag))
12620 return NULL;
12621 return p;
12622 }
12623 #endif
12624
12625 /******************************************************************************/
12626 #ifndef PALM_2
12627 SOAP_FMAC1
12628 const char*
12629 SOAP_FMAC2
12630 soap_unsignedByte2s(struct soap *soap, unsigned char n)
12631 { return soap_unsignedLong2s(soap, (unsigned long)n);
12632 }
12633 #endif
12634
12635 /******************************************************************************/
12636 #ifndef PALM_2
12637 SOAP_FMAC1
12638 int
12639 SOAP_FMAC2
12640 soap_outunsignedByte(struct soap *soap, const char *tag, int id, const unsigned char *p, const char *type, int n)
12641 { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
12642 || soap_string_out(soap, soap_unsignedLong2s(soap, (unsigned long)*p), 0))
12643 return soap->error;
12644 return soap_element_end_out(soap, tag);
12645 }
12646 #endif
12647
12648 /******************************************************************************/
12649 #ifndef PALM_2
12650 SOAP_FMAC1
12651 int
12652 SOAP_FMAC2
12653 soap_s2unsignedByte(struct soap *soap, const char *s, unsigned char *p)
12654 { if (s)
12655 { unsigned long n;
12656 char *r;
12657 n = soap_strtoul(s, &r, 10);
12658 if (s == r || *r || n > 255)
12659 soap->error = SOAP_TYPE;
12660 *p = (unsigned char)n;
12661 }
12662 return soap->error;
12663 }
12664 #endif
12665
12666 /******************************************************************************/
12667 #ifndef PALM_2
12668 SOAP_FMAC1
12669 unsigned char *
12670 SOAP_FMAC2
12671 soap_inunsignedByte(struct soap *soap, const char *tag, unsigned char *p, const char *type, int t)
12672 { if (soap_element_begin_in(soap, tag, 0, NULL))
12673 return NULL;
12674 #ifndef WITH_LEAN
12675 if (*soap->type
12676 && soap_match_tag(soap, soap->type, type)
12677 && soap_match_tag(soap, soap->type, ":unsignedByte"))
12678 { soap->error = SOAP_TYPE;
12679 soap_revert(soap);
12680 return NULL;
12681 }
12682 #endif
12683 p = (unsigned char*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned char), 0, NULL, NULL, NULL);
12684 if (*soap->href)
12685 p = (unsigned char*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned char), 0, NULL);
12686 else if (p)
12687 { if (soap_s2unsignedByte(soap, soap_value(soap), p))
12688 return NULL;
12689 }
12690 if (soap->body && soap_element_end_in(soap, tag))
12691 return NULL;
12692 return p;
12693 }
12694 #endif
12695
12696 /******************************************************************************/
12697 #ifndef PALM_2
12698 SOAP_FMAC1
12699 const char*
12700 SOAP_FMAC2
12701 soap_unsignedShort2s(struct soap *soap, unsigned short n)
12702 { return soap_unsignedLong2s(soap, (unsigned long)n);
12703 }
12704 #endif
12705
12706 /******************************************************************************/
12707 #ifndef PALM_2
12708 SOAP_FMAC1
12709 int
12710 SOAP_FMAC2
12711 soap_outunsignedShort(struct soap *soap, const char *tag, int id, const unsigned short *p, const char *type, int n)
12712 { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
12713 || soap_string_out(soap, soap_unsignedLong2s(soap, (unsigned long)*p), 0))
12714 return soap->error;
12715 return soap_element_end_out(soap, tag);
12716 }
12717 #endif
12718
12719 /******************************************************************************/
12720 #ifndef PALM_2
12721 SOAP_FMAC1
12722 int
12723 SOAP_FMAC2
12724 soap_s2unsignedShort(struct soap *soap, const char *s, unsigned short *p)
12725 { if (s)
12726 { unsigned long n;
12727 char *r;
12728 n = soap_strtoul(s, &r, 10);
12729 if (s == r || *r || n > 65535)
12730 soap->error = SOAP_TYPE;
12731 *p = (unsigned short)n;
12732 }
12733 return soap->error;
12734 }
12735 #endif
12736
12737 /******************************************************************************/
12738 #ifndef PALM_2
12739 SOAP_FMAC1
12740 unsigned short *
12741 SOAP_FMAC2
12742 soap_inunsignedShort(struct soap *soap, const char *tag, unsigned short *p, const char *type, int t)
12743 { if (soap_element_begin_in(soap, tag, 0, NULL))
12744 return NULL;
12745 #ifndef WITH_LEAN
12746 if (*soap->type
12747 && soap_match_tag(soap, soap->type, type)
12748 && soap_match_tag(soap, soap->type, ":unsignedShort")
12749 && soap_match_tag(soap, soap->type, ":unsignedByte"))
12750 { soap->error = SOAP_TYPE;
12751 soap_revert(soap);
12752 return NULL;
12753 }
12754 #endif
12755 p = (unsigned short*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned short), 0, NULL, NULL, NULL);
12756 if (*soap->href)
12757 p = (unsigned short*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned short), 0, NULL);
12758 else if (p)
12759 { if (soap_s2unsignedShort(soap, soap_value(soap), p))
12760 return NULL;
12761 }
12762 if (soap->body && soap_element_end_in(soap, tag))
12763 return NULL;
12764 return p;
12765 }
12766 #endif
12767
12768 /******************************************************************************/
12769 #ifndef PALM_2
12770 SOAP_FMAC1
12771 const char*
12772 SOAP_FMAC2
12773 soap_unsignedInt2s(struct soap *soap, unsigned int n)
12774 { return soap_unsignedLong2s(soap, (unsigned long)n);
12775 }
12776 #endif
12777
12778 /******************************************************************************/
12779 #ifndef PALM_2
12780 SOAP_FMAC1
12781 int
12782 SOAP_FMAC2
12783 soap_outunsignedInt(struct soap *soap, const char *tag, int id, const unsigned int *p, const char *type, int n)
12784 { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
12785 || soap_string_out(soap, soap_unsignedLong2s(soap, (unsigned long)*p), 0))
12786 return soap->error;
12787 return soap_element_end_out(soap, tag);
12788 }
12789 #endif
12790
12791 /******************************************************************************/
12792 #ifndef PALM_2
12793 SOAP_FMAC1
12794 int
12795 SOAP_FMAC2
12796 soap_s2unsignedInt(struct soap *soap, const char *s, unsigned int *p)
12797 { if (s)
12798 { char *r;
12799 #ifndef WITH_NOIO
12800 #ifndef WITH_LEAN
12801 soap_reset_errno;
12802 #endif
12803 #endif
12804 *p = (unsigned int)soap_strtoul(s, &r, 10);
12805 if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r
12806 #ifndef WITH_NOIO
12807 #ifndef WITH_LEAN
12808 || soap_errno == SOAP_ERANGE
12809 #endif
12810 #endif
12811 )
12812 soap->error = SOAP_TYPE;
12813 }
12814 return soap->error;
12815 }
12816 #endif
12817
12818 /******************************************************************************/
12819 #ifndef PALM_2
12820 SOAP_FMAC1
12821 unsigned int *
12822 SOAP_FMAC2
12823 soap_inunsignedInt(struct soap *soap, const char *tag, unsigned int *p, const char *type, int t)
12824 { if (soap_element_begin_in(soap, tag, 0, NULL))
12825 return NULL;
12826 #ifndef WITH_LEAN
12827 if (*soap->type
12828 && soap_match_tag(soap, soap->type, type)
12829 && soap_match_tag(soap, soap->type, ":unsignedInt")
12830 && soap_match_tag(soap, soap->type, ":unsignedShort")
12831 && soap_match_tag(soap, soap->type, ":unsignedByte"))
12832 { soap->error = SOAP_TYPE;
12833 soap_revert(soap);
12834 return NULL;
12835 }
12836 #endif
12837 p = (unsigned int*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned int), 0, NULL, NULL, NULL);
12838 if (*soap->href)
12839 p = (unsigned int*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned int), 0, NULL);
12840 else if (p)
12841 { if (soap_s2unsignedInt(soap, soap_value(soap), p))
12842 return NULL;
12843 }
12844 if (soap->body && soap_element_end_in(soap, tag))
12845 return NULL;
12846 return p;
12847 }
12848 #endif
12849
12850 /******************************************************************************/
12851 #ifndef PALM_2
12852 SOAP_FMAC1
12853 const char*
12854 SOAP_FMAC2
12855 soap_unsignedLong2s(struct soap *soap, unsigned long n)
12856 {
12857 #ifdef HAVE_SNPRINTF
12858 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), "%lu", n);
12859 #else
12860 sprintf(soap->tmpbuf, "%lu", n);
12861 #endif
12862 return soap->tmpbuf;
12863 }
12864 #endif
12865
12866 /******************************************************************************/
12867 #ifndef PALM_2
12868 SOAP_FMAC1
12869 int
12870 SOAP_FMAC2
12871 soap_outunsignedLong(struct soap *soap, const char *tag, int id, const unsigned long *p, const char *type, int n)
12872 { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
12873 || soap_string_out(soap, soap_unsignedLong2s(soap, *p), 0))
12874 return soap->error;
12875 return soap_element_end_out(soap, tag);
12876 }
12877 #endif
12878
12879 /******************************************************************************/
12880 #ifndef PALM_2
12881 SOAP_FMAC1
12882 int
12883 SOAP_FMAC2
12884 soap_s2unsignedLong(struct soap *soap, const char *s, unsigned long *p)
12885 { if (s)
12886 { char *r;
12887 #ifndef WITH_NOIO
12888 #ifndef WITH_LEAN
12889 soap_reset_errno;
12890 #endif
12891 #endif
12892 *p = soap_strtoul(s, &r, 10);
12893 if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r
12894 #ifndef WITH_NOIO
12895 #ifndef WITH_LEAN
12896 || soap_errno == SOAP_ERANGE
12897 #endif
12898 #endif
12899 )
12900 soap->error = SOAP_TYPE;
12901 }
12902 return soap->error;
12903 }
12904 #endif
12905
12906 /******************************************************************************/
12907 #ifndef PALM_2
12908 SOAP_FMAC1
12909 unsigned long *
12910 SOAP_FMAC2
12911 soap_inunsignedLong(struct soap *soap, const char *tag, unsigned long *p, const char *type, int t)
12912 { if (soap_element_begin_in(soap, tag, 0, NULL))
12913 return NULL;
12914 #ifndef WITH_LEAN
12915 if (*soap->type
12916 && soap_match_tag(soap, soap->type, type)
12917 && soap_match_tag(soap, soap->type, ":unsignedInt")
12918 && soap_match_tag(soap, soap->type, ":unsignedShort")
12919 && soap_match_tag(soap, soap->type, ":unsignedByte"))
12920 { soap->error = SOAP_TYPE;
12921 soap_revert(soap);
12922 return NULL;
12923 }
12924 #endif
12925 p = (unsigned long*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned long), 0, NULL, NULL, NULL);
12926 if (*soap->href)
12927 p = (unsigned long*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned long), 0, NULL);
12928 else if (p)
12929 { if (soap_s2unsignedLong(soap, soap_value(soap), p))
12930 return NULL;
12931 }
12932 if (soap->body && soap_element_end_in(soap, tag))
12933 return NULL;
12934 return p;
12935 }
12936 #endif
12937
12938 /******************************************************************************/
12939 #ifndef WITH_LEAN
12940 SOAP_FMAC1
12941 const char*
12942 SOAP_FMAC2
12943 soap_ULONG642s(struct soap *soap, ULONG64 n)
12944 {
12945 #ifdef HAVE_SNPRINTF
12946 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), SOAP_ULONG_FORMAT, n);
12947 #else
12948 sprintf(soap->tmpbuf, SOAP_ULONG_FORMAT, n);
12949 #endif
12950 return soap->tmpbuf;
12951 }
12952 #endif
12953
12954 /******************************************************************************/
12955 #ifndef WITH_LEAN
12956 SOAP_FMAC1
12957 int
12958 SOAP_FMAC2
12959 soap_outULONG64(struct soap *soap, const char *tag, int id, const ULONG64 *p, const char *type, int n)
12960 { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
12961 || soap_string_out(soap, soap_ULONG642s(soap, *p), 0))
12962 return soap->error;
12963 return soap_element_end_out(soap, tag);
12964 }
12965 #endif
12966
12967 /******************************************************************************/
12968 #ifndef WITH_LEAN
12969 SOAP_FMAC1
12970 int
12971 SOAP_FMAC2
12972 soap_s2ULONG64(struct soap *soap, const char *s, ULONG64 *p)
12973 { if (s)
12974 {
12975 #ifdef HAVE_STRTOULL
12976 char *r;
12977 #ifndef WITH_NOIO
12978 #ifndef WITH_LEAN
12979 soap_reset_errno;
12980 #endif
12981 #endif
12982 *p = soap_strtoull(s, &r, 10);
12983 if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r
12984 #ifndef WITH_NOIO
12985 #ifndef WITH_LEAN
12986 || soap_errno == SOAP_ERANGE
12987 #endif
12988 #endif
12989 )
12990 #else
12991 #ifdef HAVE_SSCANF
12992 if (sscanf(s, SOAP_ULONG_FORMAT, p) != 1)
12993 #endif
12994 #endif
12995 soap->error = SOAP_TYPE;
12996 }
12997 return soap->error;
12998 }
12999 #endif
13000
13001 /******************************************************************************/
13002 #ifndef WITH_LEAN
13003 SOAP_FMAC1
13004 ULONG64 *
13005 SOAP_FMAC2
13006 soap_inULONG64(struct soap *soap, const char *tag, ULONG64 *p, const char *type, int t)
13007 { if (soap_element_begin_in(soap, tag, 0, NULL))
13008 return NULL;
13009 if (*soap->type
13010 && soap_match_tag(soap, soap->type, type)
13011 && soap_match_tag(soap, soap->type, ":positiveInteger")
13012 && soap_match_tag(soap, soap->type, ":nonNegativeInteger")
13013 && soap_match_tag(soap, soap->type, ":unsignedLong")
13014 && soap_match_tag(soap, soap->type, ":unsignedInt")
13015 && soap_match_tag(soap, soap->type, ":unsignedShort")
13016 && soap_match_tag(soap, soap->type, ":unsignedByte"))
13017 { soap->error = SOAP_TYPE;
13018 soap_revert(soap);
13019 return NULL;
13020 }
13021 p = (ULONG64*)soap_id_enter(soap, soap->id, p, t, sizeof(ULONG64), 0, NULL, NULL, NULL);
13022 if (*soap->href)
13023 p = (ULONG64*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(ULONG64), 0, NULL);
13024 else if (p)
13025 { if (soap_s2ULONG64(soap, soap_value(soap), p))
13026 return NULL;
13027 }
13028 if (soap->body && soap_element_end_in(soap, tag))
13029 return NULL;
13030 return p;
13031 }
13032 #endif
13033
13034 /******************************************************************************/
13035 #ifndef PALM_2
13036 SOAP_FMAC1
13037 int
13038 SOAP_FMAC2
13039 soap_s2string(struct soap *soap, const char *s, char **t, long minlen, long maxlen)
13040 { if (s)
13041 { long l = (long)strlen(s);
13042 if ((maxlen >= 0 && l > maxlen) || l < minlen)
13043 return soap->error = SOAP_LENGTH;
13044 if (!(*t = soap_strdup(soap, s)))
13045 return soap->error = SOAP_EOM;
13046 if (!(soap->mode & (SOAP_ENC_LATIN | SOAP_C_UTFSTRING)))
13047 { char *r = *t;
13048 /* remove non-ASCII chars */
13049 for (s = *t; *s; s++)
13050 if (!(*s & 0x80))
13051 *r++ = *s;
13052 *r = '\0';
13053 }
13054 }
13055 return soap->error;
13056 }
13057 #endif
13058
13059 /******************************************************************************/
13060 #ifndef PALM_2
13061 SOAP_FMAC1
13062 int
13063 SOAP_FMAC2
13064 soap_s2QName(struct soap *soap, const char *s, char **t, long minlen, long maxlen)
13065 { if (s)
13066 { long l = (long)strlen(s);
13067 if ((maxlen >= 0 && l > maxlen) || l < minlen)
13068 return soap->error = SOAP_LENGTH;
13069 soap->labidx = 0;
13070 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Normalized namespace(s) of QNames '%s'", s));
13071 /* convert (by prefix normalize prefix) all QNames in s */
13072 for (;;)
13073 { size_t n;
13074 struct soap_nlist *np;
13075 register const char *p;
13076 /* skip blanks */
13077 while (*s && soap_blank((soap_wchar)*s))
13078 s++;
13079 if (!*s)
13080 break;
13081 /* find next QName */
13082 n = 1;
13083 while (s[n] && !soap_blank((soap_wchar)s[n]))
13084 n++;
13085 np = soap->nlist;
13086 /* if there is no namespace stack, or prefix is "#" or "xml" then copy string */
13087 if (!np || *s == '#' || !strncmp(s, "xml:", 4))
13088 { soap_append_lab(soap, s, n);
13089 }
13090 else /* we normalize the QName by replacing its prefix */
13091 { const char *q;
13092 for (p = s; *p && p < s + n; p++)
13093 if (*p == ':')
13094 break;
13095 if (*p == ':')
13096 { size_t k = p - s;
13097 while (np && (strncmp(np->id, s, k) || np->id[k]))
13098 np = np->next;
13099 p++;
13100 }
13101 else
13102 { while (np && *np->id)
13103 np = np->next;
13104 p = s;
13105 }
13106 /* replace prefix */
13107 if (np)
13108 { if (np->index >= 0 && soap->local_namespaces && (q = soap->local_namespaces[np->index].id))
13109 { size_t k = strlen(q);
13110 if (q[k-1] != '_')
13111 soap_append_lab(soap, q, k);
13112 else
13113 { soap_append_lab(soap, "\"", 1);
13114 soap_append_lab(soap, soap->local_namespaces[np->index].ns, strlen(soap->local_namespaces[np->index].ns));
13115 soap_append_lab(soap, "\"", 1);
13116 }
13117 }
13118 else if (np->ns)
13119 { soap_append_lab(soap, "\"", 1);
13120 soap_append_lab(soap, np->ns, strlen(np->ns));
13121 soap_append_lab(soap, "\"", 1);
13122 }
13123 else
13124 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "\nNamespace prefix of '%s' not defined (index=%d, URI='%s')\n", s, np->index, np->ns ? np->ns : SOAP_STR_EOS));
13125 return soap->error = SOAP_NAMESPACE;
13126 }
13127 }
13128 else if (s[n]) /* no namespace, part of string */
13129 { soap_append_lab(soap, s, n);
13130 }
13131 else /* no namespace: assume "" namespace */
13132 { soap_append_lab(soap, "\"\"", 2);
13133 }
13134 soap_append_lab(soap, ":", 1);
13135 soap_append_lab(soap, p, n - (p-s));
13136 }
13137 /* advance to next and add spacing */
13138 s += n;
13139 if (*s)
13140 soap_append_lab(soap, " ", 1);
13141 }
13142 soap_append_lab(soap, SOAP_STR_EOS, 1);
13143 *t = soap_strdup(soap, soap->labbuf);
13144 DBGLOG(TEST, SOAP_MESSAGE(fdebug, " into '%s'\n", *t));
13145 }
13146 return soap->error;
13147 }
13148 #endif
13149
13150 /******************************************************************************/
13151 #ifndef PALM_2
13152 SOAP_FMAC1
13153 const char*
13154 SOAP_FMAC2
13155 soap_QName2s(struct soap *soap, const char *s)
13156 { const char *t = NULL;
13157 if (s)
13158 { soap->labidx = 0;
13159 for (;;)
13160 { size_t n;
13161 /* skip blanks */
13162 while (*s && soap_blank((soap_wchar)*s))
13163 s++;
13164 if (!*s)
13165 break;
13166 /* find next QName */
13167 n = 1;
13168 while (s[n] && !soap_blank((soap_wchar)s[n]))
13169 n++;
13170 /* normal prefix: pass string as is */
13171 if (*s != '"')
13172 {
13173 #ifndef WITH_LEAN
13174 if ((soap->mode & SOAP_XML_CANONICAL))
13175 soap_utilize_ns(soap, s);
13176 if ((soap->mode & SOAP_XML_DEFAULTNS))
13177 { const char *r = strchr(s, ':');
13178 if (r && soap->nlist && !strncmp(soap->nlist->id, s, r-s) && !soap->nlist->id[r-s])
13179 { n -= r-s + 1;
13180 s = r + 1;
13181 }
13182 }
13183 #endif
13184 soap_append_lab(soap, s, n);
13185 }
13186 else /* URL-based string prefix */
13187 { const char *q;
13188 s++;
13189 q = strchr(s, '"');
13190 if (q)
13191 { struct Namespace *p = soap->local_namespaces;
13192 if (p)
13193 { for (; p->id; p++)
13194 { if (p->ns)
13195 if (!soap_tag_cmp(s, p->ns))
13196 break;
13197 if (p->in)
13198 if (!soap_tag_cmp(s, p->in))
13199 break;
13200 }
13201 }
13202 /* URL is in the namespace table? */
13203 if (p && p->id)
13204 { const char *r = p->id;
13205 #ifndef WITH_LEAN
13206 if ((soap->mode & SOAP_XML_DEFAULTNS) && soap->nlist && !strcmp(soap->nlist->id, r))
13207 q++;
13208 else
13209 #endif
13210 soap_append_lab(soap, r, strlen(r));
13211 }
13212 else /* not in namespace table: create xmlns binding */
13213 { char *r = soap_strdup(soap, s);
13214 r[q-s] = '\0';
13215 #ifdef HAVE_SNPRINTF
13216 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), "xmlns:_%d", soap->idnum++);
13217 #else
13218 sprintf(soap->tmpbuf, "xmlns:_%d", soap->idnum++);
13219 #endif
13220 soap_set_attr(soap, soap->tmpbuf, r, 1);
13221 soap_append_lab(soap, soap->tmpbuf + 6, strlen(soap->tmpbuf + 6));
13222 }
13223 soap_append_lab(soap, q + 1, n - (q-s) - 1);
13224 }
13225 }
13226 /* advance to next and add spacing */
13227 s += n;
13228 if (*s)
13229 soap_append_lab(soap, " ", 1);
13230 }
13231 soap_append_lab(soap, SOAP_STR_EOS, 1);
13232 t = soap_strdup(soap, soap->labbuf);
13233 }
13234 return t;
13235 }
13236 #endif
13237
13238 /******************************************************************************/
13239 #ifndef WITH_LEAN
13240 SOAP_FMAC1
13241 int
13242 SOAP_FMAC2
13243 soap_s2wchar(struct soap *soap, const char *s, wchar_t **t, long minlen, long maxlen)
13244 { if (s)
13245 { long l;
13246 wchar_t *r;
13247 *t = r = (wchar_t*)soap_malloc(soap, sizeof(wchar_t) * (strlen(s) + 1));
13248 if (!r)
13249 return soap->error = SOAP_EOM;
13250 if (soap->mode & SOAP_ENC_LATIN)
13251 { while (*s)
13252 *r++ = (wchar_t)*s++;
13253 }
13254 else
13255 { /* Convert UTF8 to wchar */
13256 while (*s)
13257 { register soap_wchar c, c1, c2, c3, c4;
13258 c = (unsigned char)*s++;
13259 if (c < 0x80)
13260 *r++ = (wchar_t)c;
13261 else
13262 { c1 = (soap_wchar)*s++ & 0x3F;
13263 if (c < 0xE0)
13264 *r++ = (wchar_t)(((soap_wchar)(c & 0x1F) << 6) | c1);
13265 else
13266 { c2 = (soap_wchar)*s++ & 0x3F;
13267 if (c < 0xF0)
13268 *r++ = (wchar_t)(((soap_wchar)(c & 0x0F) << 12) | (c1 << 6) | c2);
13269 else
13270 { c3 = (soap_wchar)*s++ & 0x3F;
13271 if (c < 0xF8)
13272 *r++ = (wchar_t)(((soap_wchar)(c & 0x07) << 18) | (c1 << 12) | (c2 << 6) | c3);
13273 else
13274 { c4 = (soap_wchar)*s++ & 0x3F;
13275 if (c < 0xFC)
13276 *r++ = (wchar_t)(((soap_wchar)(c & 0x03) << 24) | (c1 << 18) | (c2 << 12) | (c3 << 6) | c4);
13277 else
13278 *r++ = (wchar_t)(((soap_wchar)(c & 0x01) << 30) | (c1 << 24) | (c2 << 18) | (c3 << 12) | (c4 << 6) | (soap_wchar)(*s++ & 0x3F));
13279 }
13280 }
13281 }
13282 }
13283 }
13284 }
13285 *r = L'\0';
13286 l = (long)(r - *t);
13287 if ((maxlen >= 0 && l > maxlen) || l < minlen)
13288 return soap->error = SOAP_LENGTH;
13289 }
13290 return soap->error;
13291 }
13292 #endif
13293
13294 /******************************************************************************/
13295 #ifndef WITH_LEAN
13296 SOAP_FMAC1
13297 const char*
13298 SOAP_FMAC2
13299 soap_wchar2s(struct soap *soap, const wchar_t *s)
13300 { register soap_wchar c;
13301 register char *r, *t;
13302 const wchar_t *q = s;
13303 size_t n = 0;
13304 while ((c = *q++))
13305 { if (c > 0 && c < 0x80)
13306 n++;
13307 else
13308 n += 6;
13309 }
13310 r = t = (char*)soap_malloc(soap, n + 1);
13311 if (r)
13312 { /* Convert wchar to UTF8 */
13313 while ((c = *s++))
13314 { if (c > 0 && c < 0x80)
13315 *t++ = (char)c;
13316 else
13317 { if (c < 0x0800)
13318 *t++ = (char)(0xC0 | ((c >> 6) & 0x1F));
13319 else
13320 { if (c < 0x010000)
13321 *t++ = (char)(0xE0 | ((c >> 12) & 0x0F));
13322 else
13323 { if (c < 0x200000)
13324 *t++ = (char)(0xF0 | ((c >> 18) & 0x07));
13325 else
13326 { if (c < 0x04000000)
13327 *t++ = (char)(0xF8 | ((c >> 24) & 0x03));
13328 else
13329 { *t++ = (char)(0xFC | ((c >> 30) & 0x01));
13330 *t++ = (char)(0x80 | ((c >> 24) & 0x3F));
13331 }
13332 *t++ = (char)(0x80 | ((c >> 18) & 0x3F));
13333 }
13334 *t++ = (char)(0x80 | ((c >> 12) & 0x3F));
13335 }
13336 *t++ = (char)(0x80 | ((c >> 6) & 0x3F));
13337 }
13338 *t++ = (char)(0x80 | (c & 0x3F));
13339 }
13340 }
13341 *t = '\0';
13342 }
13343 return r;
13344 }
13345 #endif
13346
13347 /******************************************************************************/
13348 #ifndef PALM_2
13349 SOAP_FMAC1
13350 int
13351 SOAP_FMAC2
13352 soap_outstring(struct soap *soap, const char *tag, int id, char *const*p, const char *type, int n)
13353 { id = soap_element_id(soap, tag, id, *p, NULL, 0, type, n);
13354 if (id < 0)
13355 return soap->error;
13356 if (!**p && (soap->mode & SOAP_C_NILSTRING))
13357 return soap_element_null(soap, tag, id, type);
13358 if (soap_element_begin_out(soap, tag, id, type)
13359 || soap_string_out(soap, *p, 0)
13360 || soap_element_end_out(soap, tag))
13361 return soap->error;
13362 return SOAP_OK;
13363 }
13364 #endif
13365
13366 /******************************************************************************/
13367 #ifndef PALM_2
13368 SOAP_FMAC1
13369 char **
13370 SOAP_FMAC2
13371 soap_instring(struct soap *soap, const char *tag, char **p, const char *type, int t, int flag, long minlen, long maxlen)
13372 { (void)type;
13373 if (soap_element_begin_in(soap, tag, 1, NULL))
13374 { if (!tag || *tag != '-' || soap->error != SOAP_NO_TAG)
13375 return NULL;
13376 soap->error = SOAP_OK;
13377 }
13378 if (!p)
13379 { if (!(p = (char**)soap_malloc(soap, sizeof(char*))))
13380 return NULL;
13381 }
13382 if (soap->null)
13383 *p = NULL;
13384 else if (soap->body)
13385 { *p = soap_string_in(soap, flag, minlen, maxlen);
13386 if (!*p || !(char*)soap_id_enter(soap, soap->id, *p, t, sizeof(char*), 0, NULL, NULL, NULL))
13387 return NULL;
13388 if (!**p && tag && *tag == '-')
13389 { soap->error = SOAP_NO_TAG;
13390 return NULL;
13391 }
13392 }
13393 else if (tag && *tag == '-')
13394 { soap->error = SOAP_NO_TAG;
13395 return NULL;
13396 }
13397 else if (!*soap->href && minlen > 0)
13398 { soap->error = SOAP_LENGTH;
13399 return NULL;
13400 }
13401 else
13402 *p = soap_strdup(soap, SOAP_STR_EOS);
13403 if (*soap->href)
13404 p = (char**)soap_id_lookup(soap, soap->href, (void**)p, t, sizeof(char**), 0);
13405 if (soap->body && soap_element_end_in(soap, tag))
13406 return NULL;
13407 return p;
13408 }
13409 #endif
13410
13411 /******************************************************************************/
13412 #ifndef WITH_LEANER
13413 #ifndef PALM_2
13414 SOAP_FMAC1
13415 int
13416 SOAP_FMAC2
13417 soap_outwstring(struct soap *soap, const char *tag, int id, wchar_t *const*p, const char *type, int n)
13418 { id = soap_element_id(soap, tag, id, *p, NULL, 0, type, n);
13419 if (id < 0)
13420 return soap->error;
13421 if (!**p && (soap->mode & SOAP_C_NILSTRING))
13422 return soap_element_null(soap, tag, id, type);
13423 if (soap_element_begin_out(soap, tag, id, type)
13424 || soap_wstring_out(soap, *p, 0)
13425 || soap_element_end_out(soap, tag))
13426 return soap->error;
13427 return SOAP_OK;
13428 }
13429 #endif
13430 #endif
13431
13432 /******************************************************************************/
13433 #ifndef WITH_LEANER
13434 #ifndef PALM_2
13435 SOAP_FMAC1
13436 wchar_t **
13437 SOAP_FMAC2
13438 soap_inwstring(struct soap *soap, const char *tag, wchar_t **p, const char *type, int t, long minlen, long maxlen)
13439 { (void)type;
13440 if (soap_element_begin_in(soap, tag, 1, NULL))
13441 { if (!tag || *tag != '-' || soap->error != SOAP_NO_TAG)
13442 return NULL;
13443 soap->error = SOAP_OK;
13444 }
13445 if (!p)
13446 { if (!(p = (wchar_t**)soap_malloc(soap, sizeof(wchar_t*))))
13447 return NULL;
13448 }
13449 if (soap->body)
13450 { *p = soap_wstring_in(soap, 1, minlen, maxlen);
13451 if (!*p || !(wchar_t*)soap_id_enter(soap, soap->id, *p, t, sizeof(wchar_t*), 0, NULL, NULL, NULL))
13452 return NULL;
13453 if (!**p && tag && *tag == '-')
13454 { soap->error = SOAP_NO_TAG;
13455 return NULL;
13456 }
13457 }
13458 else if (tag && *tag == '-')
13459 { soap->error = SOAP_NO_TAG;
13460 return NULL;
13461 }
13462 else if (soap->null)
13463 *p = NULL;
13464 else
13465 *p = soap_wstrdup(soap, (wchar_t*)SOAP_STR_EOS);
13466 if (*soap->href)
13467 p = (wchar_t**)soap_id_lookup(soap, soap->href, (void**)p, t, sizeof(wchar_t**), 0);
13468 if (soap->body && soap_element_end_in(soap, tag))
13469 return NULL;
13470 return p;
13471 }
13472 #endif
13473 #endif
13474
13475 /******************************************************************************/
13476 #ifndef WITH_LEAN
13477 SOAP_FMAC1
13478 time_t
13479 SOAP_FMAC2
13480 soap_timegm(struct tm *T)
13481 {
13482 #if defined(HAVE_TIMEGM)
13483 return timegm(T);
13484 #else
13485 time_t t, g, z;
13486 struct tm tm;
13487 t = mktime(T);
13488 if (t == (time_t)-1)
13489 return (time_t)-1;
13490 #ifdef HAVE_GMTIME_R
13491 gmtime_r(&t, &tm);
13492 #else
13493 tm = *gmtime(&t);
13494 #endif
13495 tm.tm_isdst = 0;
13496 g = mktime(&tm);
13497 if (g == (time_t)-1)
13498 return (time_t)-1;
13499 z = g - t;
13500 return t - z;
13501 #endif
13502 }
13503 #endif
13504
13505 /******************************************************************************/
13506 #ifndef WITH_LEAN
13507 SOAP_FMAC1
13508 const char*
13509 SOAP_FMAC2
13510 soap_dateTime2s(struct soap *soap, time_t n)
13511 { struct tm T, *pT = &T;
13512 #if defined(HAVE_GMTIME_R)
13513 if (gmtime_r(&n, pT))
13514 strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%SZ", pT);
13515 #elif defined(HAVE_GMTIME)
13516 if ((pT = gmtime(&n)))
13517 strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%SZ", pT);
13518 #elif defined(HAVE_TM_GMTOFF) || defined(HAVE_STRUCT_TM_TM_GMTOFF) || defined(HAVE_STRUCT_TM___TM_GMTOFF)
13519 #if defined(HAVE_LOCALTIME_R)
13520 if (localtime_r(&n, pT))
13521 { strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S%z", pT);
13522 memmove(soap->tmpbuf + 23, soap->tmpbuf + 22, 3); /* 2000-03-01T02:00:00+0300 */
13523 soap->tmpbuf[22] = ':'; /* 2000-03-01T02:00:00+03:00 */
13524 }
13525 #else
13526 if ((pT = localtime(&n)))
13527 { strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S%z", pT);
13528 memmove(soap->tmpbuf + 23, soap->tmpbuf + 22, 3); /* 2000-03-01T02:00:00+0300 */
13529 soap->tmpbuf[22] = ':'; /* 2000-03-01T02:00:00+03:00 */
13530 }
13531 #endif
13532 #elif defined(HAVE_GETTIMEOFDAY)
13533 struct timezone tz;
13534 memset((void*)&tz, 0, sizeof(tz));
13535 #if defined(HAVE_LOCALTIME_R)
13536 if (localtime_r(&n, pT))
13537 { struct timeval tv;
13538 gettimeofday(&tv, &tz);
13539 strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
13540 #ifdef HAVE_SNPRINTF
13541 soap_snprintf(soap->tmpbuf + strlen(soap->tmpbuf), sizeof(soap->tmpbuf) - strlen(soap->tmpbuf), "%+03d:%02d", -tz.tz_minuteswest/60+(pT->tm_isdst!=0), abs(tz.tz_minuteswest)%60);
13542 #else
13543 sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -tz.tz_minuteswest/60+(pT->tm_isdst!=0), abs(tz.tz_minuteswest)%60);
13544 #endif
13545 }
13546 #else
13547 if ((pT = localtime(&n)))
13548 { struct timeval tv;
13549 gettimeofday(&tv, &tz);
13550 strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
13551 #ifdef HAVE_SNPRINTF
13552 soap_snprintf(soap->tmpbuf + strlen(soap->tmpbuf), sizeof(soap->tmpbuf) - strlen(soap->tmpbuf), "%+03d:%02d", -tz.tz_minuteswest/60+(pT->tm_isdst!=0), abs(tz.tz_minuteswest)%60);
13553 #else
13554 sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -tz.tz_minuteswest/60+(pT->tm_isdst!=0), abs(tz.tz_minuteswest)%60);
13555 #endif
13556 }
13557 #endif
13558 #elif defined(HAVE_FTIME)
13559 struct timeb t;
13560 memset((void*)&t, 0, sizeof(t));
13561 #if defined(HAVE_LOCALTIME_R)
13562 if (localtime_r(&n, pT))
13563 {
13564 #ifdef __BORLANDC__
13565 ::ftime(&t);
13566 #else
13567 ftime(&t);
13568 #endif
13569 strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
13570 #ifdef HAVE_SNPRINTF
13571 soap_snprintf(soap->tmpbuf + strlen(soap->tmpbuf), sizeof(soap->tmpbuf) - strlen(soap->tmpbuf), "%+03d:%02d", -t.timezone/60+(pT->tm_isdst!=0), abs(t.timezone)%60);
13572 #else
13573 sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -t.timezone/60+(pT->tm_isdst!=0), abs(t.timezone)%60);
13574 #endif
13575 }
13576 #else
13577 if ((pT = localtime(&n)))
13578 {
13579 #ifdef __BORLANDC__
13580 ::ftime(&t);
13581 #else
13582 ftime(&t);
13583 #endif
13584 strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
13585 #ifdef HAVE_SNPRINTF
13586 soap_snprintf(soap->tmpbuf + strlen(soap->tmpbuf), sizeof(soap->tmpbuf) - strlen(soap->tmpbuf), "%+03d:%02d", -t.timezone/60+(pT->tm_isdst!=0), abs(t.timezone)%60);
13587 #else
13588 sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -t.timezone/60+(pT->tm_isdst!=0), abs(t.timezone)%60);
13589 #endif
13590 }
13591 #endif
13592 #elif defined(HAVE_LOCALTIME_R)
13593 if (localtime_r(&n, pT))
13594 strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
13595 #else
13596 if ((pT = localtime(&n)))
13597 strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
13598 #endif
13599 else
13600 strcpy(soap->tmpbuf, "1969-12-31T23:59:59Z");
13601 return soap->tmpbuf;
13602 }
13603 #endif
13604
13605 /******************************************************************************/
13606 #ifndef WITH_LEAN
13607 SOAP_FMAC1
13608 int
13609 SOAP_FMAC2
13610 soap_outdateTime(struct soap *soap, const char *tag, int id, const time_t *p, const char *type, int n)
13611 { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
13612 || soap_string_out(soap, soap_dateTime2s(soap, *p), 0))
13613 return soap->error;
13614 return soap_element_end_out(soap, tag);
13615 }
13616 #endif
13617
13618 /******************************************************************************/
13619 #ifndef WITH_LEAN
13620 SOAP_FMAC1
13621 int
13622 SOAP_FMAC2
13623 soap_s2dateTime(struct soap *soap, const char *s, time_t *p)
13624 { if (s)
13625 { char zone[32];
13626 struct tm T;
13627 const char *t;
13628 *zone = '\0';
13629 memset((void*)&T, 0, sizeof(T));
13630 if (strchr(s, '-'))
13631 t = "%d-%d-%dT%d:%d:%d%31s";
13632 else if (strchr(s, ':'))
13633 t = "%4d%2d%2dT%d:%d:%d%31s";
13634 else /* parse non-XSD-standard alternative ISO 8601 format */
13635 t = "%4d%2d%2dT%2d%2d%2d%31s";
13636 if (sscanf(s, t, &T.tm_year, &T.tm_mon, &T.tm_mday, &T.tm_hour, &T.tm_min, &T.tm_sec, zone) < 6)
13637 return soap->error = SOAP_TYPE;
13638 if (T.tm_year == 1)
13639 T.tm_year = 70;
13640 else
13641 T.tm_year -= 1900;
13642 T.tm_mon--;
13643 if (*zone == '.')
13644 { for (s = zone + 1; *s; s++)
13645 if (*s < '0' || *s > '9')
13646 break;
13647 }
13648 else
13649 s = zone;
13650 if (*s)
13651 {
13652 #ifndef WITH_NOZONE
13653 if (*s == '+' || *s == '-')
13654 { int h = 0, m = 0;
13655 if (s[3] == ':')
13656 { /* +hh:mm */
13657 sscanf(s, "%d:%d", &h, &m);
13658 if (h < 0)
13659 m = -m;
13660 }
13661 else /* +hhmm */
13662 { m = (int)soap_strtol(s, NULL, 10);
13663 h = m / 100;
13664 m = m % 100;
13665 }
13666 T.tm_min -= m;
13667 T.tm_hour -= h;
13668 /* put hour and min in range */
13669 T.tm_hour += T.tm_min / 60;
13670 T.tm_min %= 60;
13671 if (T.tm_min < 0)
13672 { T.tm_min += 60;
13673 T.tm_hour--;
13674 }
13675 T.tm_mday += T.tm_hour / 24;
13676 T.tm_hour %= 24;
13677 if (T.tm_hour < 0)
13678 { T.tm_hour += 24;
13679 T.tm_mday--;
13680 }
13681 /* note: day of the month may be out of range, timegm() handles it */
13682 }
13683 #endif
13684 *p = soap_timegm(&T);
13685 }
13686 else /* no UTC or timezone, so assume we got a localtime */
13687 { T.tm_isdst = -1;
13688 *p = mktime(&T);
13689 }
13690 }
13691 return soap->error;
13692 }
13693 #endif
13694
13695 /******************************************************************************/
13696 #ifndef WITH_LEAN
13697 SOAP_FMAC1
13698 time_t *
13699 SOAP_FMAC2
13700 soap_indateTime(struct soap *soap, const char *tag, time_t *p, const char *type, int t)
13701 { if (soap_element_begin_in(soap, tag, 0, NULL))
13702 return NULL;
13703 if (*soap->type
13704 && soap_match_tag(soap, soap->type, type)
13705 && soap_match_tag(soap, soap->type, ":dateTime"))
13706 { soap->error = SOAP_TYPE;
13707 soap_revert(soap);
13708 return NULL;
13709 }
13710 p = (time_t*)soap_id_enter(soap, soap->id, p, t, sizeof(time_t), 0, NULL, NULL, NULL);
13711 if (*soap->href)
13712 p = (time_t*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(time_t), 0, NULL);
13713 else if (p)
13714 { if (soap_s2dateTime(soap, soap_value(soap), p))
13715 return NULL;
13716 }
13717 if (soap->body && soap_element_end_in(soap, tag))
13718 return NULL;
13719 return p;
13720 }
13721 #endif
13722
13723 /******************************************************************************/
13724 #ifndef PALM_2
13725 SOAP_FMAC1
13726 int
13727 SOAP_FMAC2
13728 soap_outliteral(struct soap *soap, const char *tag, char *const*p, const char *type)
13729 { int i;
13730 const char *t = NULL;
13731 if (tag && *tag != '-')
13732 { if (soap->local_namespaces && (t = strchr(tag, ':')))
13733 { size_t n = t - tag;
13734 if (n >= sizeof(soap->tmpbuf))
13735 n = sizeof(soap->tmpbuf) - 1;
13736 strncpy(soap->tmpbuf, tag, n);
13737 soap->tmpbuf[n] = '\0';
13738 for (i = 0; soap->local_namespaces[i].id; i++)
13739 if (!strcmp(soap->tmpbuf, soap->local_namespaces[i].id))
13740 break;
13741 t++;
13742 if (soap_element(soap, t, 0, type)
13743 || soap_attribute(soap, "xmlns", soap->local_namespaces[i].ns ? soap->local_namespaces[i].ns : SOAP_STR_EOS)
13744 || soap_element_start_end_out(soap, NULL))
13745 return soap->error;
13746 }
13747 else
13748 { t = tag;
13749 if (soap_element_begin_out(soap, t, 0, type))
13750 return soap->error;
13751 }
13752 }
13753 if (p && *p)
13754 { if (soap_send(soap, *p)) /* send as-is */
13755 return soap->error;
13756 }
13757 if (t)
13758 return soap_element_end_out(soap, t);
13759 return SOAP_OK;
13760 }
13761 #endif
13762
13763 /******************************************************************************/
13764 #ifndef PALM_2
13765 SOAP_FMAC1
13766 char **
13767 SOAP_FMAC2
13768 soap_inliteral(struct soap *soap, const char *tag, char **p)
13769 { if (soap_element_begin_in(soap, tag, 1, NULL))
13770 { if (soap->error != SOAP_NO_TAG || soap_unget(soap, soap_get(soap)) == SOAP_TT)
13771 return NULL;
13772 soap->error = SOAP_OK;
13773 }
13774 if (!p)
13775 { if (!(p = (char**)soap_malloc(soap, sizeof(char*))))
13776 return NULL;
13777 }
13778 if (soap->body || (tag && *tag == '-'))
13779 { *p = soap_string_in(soap, 0, -1, -1);
13780 if (!*p)
13781 return NULL;
13782 if (!**p && tag && *tag == '-')
13783 { soap->error = SOAP_NO_TAG;
13784 return NULL;
13785 }
13786 }
13787 else if (soap->null)
13788 *p = NULL;
13789 else
13790 *p = soap_strdup(soap, SOAP_STR_EOS);
13791 if (soap->body && soap_element_end_in(soap, tag))
13792 return NULL;
13793 return p;
13794 }
13795 #endif
13796
13797 /******************************************************************************/
13798 #ifndef WITH_LEANER
13799 #ifndef PALM_2
13800 SOAP_FMAC1
13801 int
13802 SOAP_FMAC2
13803 soap_outwliteral(struct soap *soap, const char *tag, wchar_t *const*p, const char *type)
13804 { int i;
13805 const char *t = NULL;
13806 if (tag && *tag != '-')
13807 { if (soap->local_namespaces && (t = strchr(tag, ':')))
13808 { size_t n = t - tag;
13809 if (n >= sizeof(soap->tmpbuf))
13810 n = sizeof(soap->tmpbuf) - 1;
13811 strncpy(soap->tmpbuf, tag, n);
13812 soap->tmpbuf[n] = '\0';
13813 for (i = 0; soap->local_namespaces[i].id; i++)
13814 if (!strcmp(soap->tmpbuf, soap->local_namespaces[i].id))
13815 break;
13816 t++;
13817 if (soap_element(soap, t, 0, type)
13818 || soap_attribute(soap, "xmlns", soap->local_namespaces[i].ns ? soap->local_namespaces[i].ns : SOAP_STR_EOS)
13819 || soap_element_start_end_out(soap, NULL))
13820 return soap->error;
13821 }
13822 else
13823 { t = tag;
13824 if (soap_element_begin_out(soap, t, 0, type))
13825 return soap->error;
13826 }
13827 }
13828 if (p)
13829 { wchar_t c;
13830 const wchar_t *s = *p;
13831 while ((c = *s++))
13832 { if (soap_pututf8(soap, (unsigned long)c)) /* send as-is in UTF8 */
13833 return soap->error;
13834 }
13835 }
13836 if (t)
13837 return soap_element_end_out(soap, t);
13838 return SOAP_OK;
13839 }
13840 #endif
13841 #endif
13842
13843 /******************************************************************************/
13844 #ifndef WITH_LEANER
13845 #ifndef PALM_2
13846 SOAP_FMAC1
13847 wchar_t **
13848 SOAP_FMAC2
13849 soap_inwliteral(struct soap *soap, const char *tag, wchar_t **p)
13850 { if (soap_element_begin_in(soap, tag, 1, NULL))
13851 { if (soap->error != SOAP_NO_TAG || soap_unget(soap, soap_get(soap)) == SOAP_TT)
13852 return NULL;
13853 soap->error = SOAP_OK;
13854 }
13855 if (!p)
13856 { if (!(p = (wchar_t**)soap_malloc(soap, sizeof(wchar_t*))))
13857 return NULL;
13858 }
13859 if (soap->body)
13860 { *p = soap_wstring_in(soap, 0, -1, -1);
13861 if (!*p)
13862 return NULL;
13863 if (!**p && tag && *tag == '-')
13864 { soap->error = SOAP_NO_TAG;
13865 return NULL;
13866 }
13867 }
13868 else if (tag && *tag == '-')
13869 { soap->error = SOAP_NO_TAG;
13870 return NULL;
13871 }
13872 else if (soap->null)
13873 *p = NULL;
13874 else
13875 *p = soap_wstrdup(soap, (wchar_t*)SOAP_STR_EOS);
13876 if (soap->body && soap_element_end_in(soap, tag))
13877 return NULL;
13878 return p;
13879 }
13880 #endif
13881 #endif
13882
13883 /******************************************************************************/
13884 #ifndef PALM_2
13885 SOAP_FMAC1
13886 const char *
13887 SOAP_FMAC2
13888 soap_value(struct soap *soap)
13889 { register size_t i;
13890 register soap_wchar c = 0;
13891 register char *s = soap->tmpbuf;
13892 if (!soap->body)
13893 return SOAP_STR_EOS;
13894 do c = soap_get(soap);
13895 while (soap_blank(c));
13896 for (i = 0; i < sizeof(soap->tmpbuf) - 1; i++)
13897 { if (c == SOAP_TT || c == SOAP_LT || (int)c == EOF)
13898 break;
13899 *s++ = (char)c;
13900 c = soap_get(soap);
13901 }
13902 for (s--; i > 0; i--, s--)
13903 { if (!soap_blank((soap_wchar)*s))
13904 break;
13905 }
13906 s[1] = '\0';
13907 soap->tmpbuf[sizeof(soap->tmpbuf) - 1] = '\0'; /* appease */
13908 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element content value='%s'\n", soap->tmpbuf));
13909 if (c == SOAP_TT || c == SOAP_LT || (int)c == EOF)
13910 soap_unget(soap, c);
13911 else if (soap->mode & SOAP_XML_STRICT)
13912 { soap->error = SOAP_LENGTH;
13913 return NULL;
13914 }
13915 #ifdef WITH_DOM
13916 if ((soap->mode & SOAP_XML_DOM) && soap->dom)
13917 soap->dom->data = soap_strdup(soap, soap->tmpbuf);
13918 #endif
13919 return soap->tmpbuf; /* return non-null pointer */
13920 }
13921 #endif
13922
13923 /******************************************************************************/
13924 #if !defined(WITH_LEANER) || !defined(WITH_NOHTTP)
13925 #ifndef PALM_2
13926 SOAP_FMAC1
13927 int
13928 SOAP_FMAC2
13929 soap_getline(struct soap *soap, char *s, int len)
13930 { int i = len;
13931 soap_wchar c = 0;
13932 for (;;)
13933 { while (--i > 0)
13934 { c = soap_getchar(soap);
13935 if (c == '\r' || c == '\n')
13936 break;
13937 if ((int)c == EOF)
13938 return soap->error = SOAP_CHK_EOF;
13939 *s++ = (char)c;
13940 }
13941 *s = '\0';
13942 if (c != '\n')
13943 c = soap_getchar(soap); /* got \r or something else, now get \n */
13944 if (c == '\n')
13945 { if (i + 1 == len) /* empty line: end of HTTP/MIME header */
13946 break;
13947 c = soap_get0(soap);
13948 if (c != ' ' && c != '\t') /* HTTP line continuation? */
13949 break;
13950 }
13951 else if ((int)c == EOF)
13952 return soap->error = SOAP_CHK_EOF;
13953 if (i <= 0)
13954 return soap->error = SOAP_HDR;
13955 }
13956 return SOAP_OK;
13957 }
13958 #endif
13959 #endif
13960
13961 /******************************************************************************/
13962 #ifndef PALM_1
13963 static size_t
13964 soap_count_attachments(struct soap *soap)
13965 {
13966 #ifndef WITH_LEANER
13967 register struct soap_multipart *content;
13968 register size_t count = soap->count;
13969 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Calculating the message size with attachments, current count=%lu\n", (unsigned long)count));
13970 if ((soap->mode & SOAP_ENC_DIME) && !(soap->mode & SOAP_ENC_MTOM))
13971 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Calculating the size of DIME attachments\n"));
13972 for (content = soap->dime.first; content; content = content->next)
13973 { count += 12 + ((content->size+3)&(~3));
13974 if (content->id)
13975 count += ((strlen(content->id)+3)&(~3));
13976 if (content->type)
13977 count += ((strlen(content->type)+3)&(~3));
13978 if (content->options)
13979 count += ((((unsigned char)content->options[2] << 8) | ((unsigned char)content->options[3]))+7)&(~3);
13980 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Size of DIME attachment content is %lu bytes\n", (unsigned long)content->size));
13981 }
13982 }
13983 if ((soap->mode & SOAP_ENC_MIME) && soap->mime.boundary)
13984 { register size_t n = strlen(soap->mime.boundary);
13985 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Calculating the size of MIME attachments\n"));
13986 for (content = soap->mime.first; content; content = content->next)
13987 { register const char *s;
13988 /* count \r\n--boundary\r\n */
13989 count += 6 + n;
13990 /* count Content-Type: ...\r\n */
13991 if (content->type)
13992 count += 16 + strlen(content->type);
13993 /* count Content-Transfer-Encoding: ...\r\n */
13994 s = soap_code_str(mime_codes, content->encoding);
13995 if (s)
13996 count += 29 + strlen(s);
13997 /* count Content-ID: ...\r\n */
13998 if (content->id)
13999 count += 14 + strlen(content->id);
14000 /* count Content-Location: ...\r\n */
14001 if (content->location)
14002 count += 20 + strlen(content->location);
14003 /* count Content-Description: ...\r\n */
14004 if (content->description)
14005 count += 23 + strlen(content->description);
14006 /* count \r\n...content */
14007 count += 2 + content->size;
14008 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Size of MIME attachment content is %lu bytes\n", (unsigned long)content->size));
14009 }
14010 /* count \r\n--boundary-- */
14011 count += 6 + n;
14012 }
14013 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "New count=%lu\n", (unsigned long)count));
14014 return count;
14015 #else
14016 return soap->count;
14017 #endif
14018 }
14019 #endif
14020
14021 /******************************************************************************/
14022 #ifndef WITH_LEANER
14023 #ifndef PALM_1
14024 static int
14025 soap_putdimefield(struct soap *soap, const char *s, size_t n)
14026 { if (soap_send_raw(soap, s, n))
14027 return soap->error;
14028 return soap_send_raw(soap, SOAP_STR_PADDING, -(long)n&3);
14029 }
14030 #endif
14031 #endif
14032
14033 /******************************************************************************/
14034 #ifndef WITH_LEANER
14035 #ifndef PALM_1
14036 SOAP_FMAC1
14037 char *
14038 SOAP_FMAC2
14039 soap_dime_option(struct soap *soap, unsigned short optype, const char *option)
14040 { size_t n;
14041 char *s = NULL;
14042 if (option)
14043 { n = strlen(option);
14044 s = (char*)soap_malloc(soap, n + 5);
14045 if (s)
14046 { s[0] = (char)(optype >> 8);
14047 s[1] = (char)(optype & 0xFF);
14048 s[2] = (char)(n >> 8);
14049 s[3] = (char)(n & 0xFF);
14050 strcpy(s + 4, option);
14051 }
14052 }
14053 return s;
14054 }
14055 #endif
14056 #endif
14057
14058 /******************************************************************************/
14059 #ifndef WITH_LEANER
14060 #ifndef PALM_1
14061 SOAP_FMAC1
14062 int
14063 SOAP_FMAC2
14064 soap_putdimehdr(struct soap *soap)
14065 { unsigned char tmp[12];
14066 size_t optlen = 0, idlen = 0, typelen = 0;
14067 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Put DIME header id='%s'\n", soap->dime.id ? soap->dime.id : SOAP_STR_EOS));
14068 if (soap->dime.options)
14069 optlen = (((unsigned char)soap->dime.options[2] << 8) | ((unsigned char)soap->dime.options[3])) + 4;
14070 if (soap->dime.id)
14071 { idlen = strlen(soap->dime.id);
14072 if (idlen > 0x0000FFFF)
14073 idlen = 0x0000FFFF;
14074 }
14075 if (soap->dime.type)
14076 { typelen = strlen(soap->dime.type);
14077 if (typelen > 0x0000FFFF)
14078 typelen = 0x0000FFFF;
14079 }
14080 tmp[0] = SOAP_DIME_VERSION | (soap->dime.flags & 0x7);
14081 tmp[1] = soap->dime.flags & 0xF0;
14082 tmp[2] = (char)(optlen >> 8);
14083 tmp[3] = (char)(optlen & 0xFF);
14084 tmp[4] = (char)(idlen >> 8);
14085 tmp[5] = (char)(idlen & 0xFF);
14086 tmp[6] = (char)(typelen >> 8);
14087 tmp[7] = (char)(typelen & 0xFF);
14088 tmp[8] = (char)(soap->dime.size >> 24);
14089 tmp[9] = (char)((soap->dime.size >> 16) & 0xFF);
14090 tmp[10] = (char)((soap->dime.size >> 8) & 0xFF);
14091 tmp[11] = (char)(soap->dime.size & 0xFF);
14092 if (soap_send_raw(soap, (char*)tmp, 12)
14093 || soap_putdimefield(soap, soap->dime.options, optlen)
14094 || soap_putdimefield(soap, soap->dime.id, idlen)
14095 || soap_putdimefield(soap, soap->dime.type, typelen))
14096 return soap->error;
14097 return SOAP_OK;
14098 }
14099 #endif
14100 #endif
14101
14102 /******************************************************************************/
14103 #ifndef WITH_LEANER
14104 #ifndef PALM_1
14105 SOAP_FMAC1
14106 int
14107 SOAP_FMAC2
14108 soap_putdime(struct soap *soap)
14109 { struct soap_multipart *content;
14110 if (!(soap->mode & SOAP_ENC_DIME))
14111 return SOAP_OK;
14112 for (content = soap->dime.first; content; content = content->next)
14113 { void *handle;
14114 soap->dime.size = content->size;
14115 soap->dime.id = content->id;
14116 soap->dime.type = content->type;
14117 soap->dime.options = content->options;
14118 soap->dime.flags = SOAP_DIME_VERSION | SOAP_DIME_MEDIA;
14119 if (soap->fdimereadopen && ((handle = soap->fdimereadopen(soap, (void*)content->ptr, content->id, content->type, content->options)) || soap->error))
14120 { size_t size = content->size;
14121 if (!handle)
14122 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimereadopen failed\n"));
14123 return soap->error;
14124 }
14125 if (!size && ((soap->mode & SOAP_ENC_XML) || (soap->mode & SOAP_IO) == SOAP_IO_CHUNK || (soap->mode & SOAP_IO) == SOAP_IO_STORE))
14126 { size_t chunksize = sizeof(soap->tmpbuf);
14127 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunked streaming DIME\n"));
14128 do
14129 { size = soap->fdimeread(soap, handle, soap->tmpbuf, chunksize);
14130 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimeread returned %lu bytes\n", (unsigned long)size));
14131 if (size < chunksize)
14132 { soap->dime.flags &= ~SOAP_DIME_CF;
14133 if (!content->next)
14134 soap->dime.flags |= SOAP_DIME_ME;
14135 }
14136 else
14137 soap->dime.flags |= SOAP_DIME_CF;
14138 soap->dime.size = size;
14139 if (soap_putdimehdr(soap)
14140 || soap_putdimefield(soap, soap->tmpbuf, size))
14141 break;
14142 if (soap->dime.id)
14143 { soap->dime.flags &= ~(SOAP_DIME_MB | SOAP_DIME_MEDIA);
14144 soap->dime.id = NULL;
14145 soap->dime.type = NULL;
14146 soap->dime.options = NULL;
14147 }
14148 } while (size >= chunksize);
14149 }
14150 else
14151 { if (!content->next)
14152 soap->dime.flags |= SOAP_DIME_ME;
14153 if (soap_putdimehdr(soap))
14154 return soap->error;
14155 do
14156 { size_t bufsize;
14157 if (size < sizeof(soap->tmpbuf))
14158 bufsize = size;
14159 else
14160 bufsize = sizeof(soap->tmpbuf);
14161 if (!(bufsize = soap->fdimeread(soap, handle, soap->tmpbuf, bufsize)))
14162 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimeread failed: insufficient data (%lu bytes remaining from %lu bytes)\n", (unsigned long)size, (unsigned long)content->size));
14163 soap->error = SOAP_CHK_EOF;
14164 break;
14165 }
14166 if (soap_send_raw(soap, soap->tmpbuf, bufsize))
14167 break;
14168 size -= bufsize;
14169 } while (size);
14170 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimereadclose\n"));
14171 soap_send_raw(soap, SOAP_STR_PADDING, -(long)soap->dime.size&3);
14172 }
14173 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimereadclose\n"));
14174 if (soap->fdimereadclose)
14175 soap->fdimereadclose(soap, handle);
14176 }
14177 else
14178 { if (!content->next)
14179 soap->dime.flags |= SOAP_DIME_ME;
14180 if (soap_putdimehdr(soap)
14181 || soap_putdimefield(soap, (char*)content->ptr, content->size))
14182 return soap->error;
14183 }
14184 }
14185 return SOAP_OK;
14186 }
14187 #endif
14188 #endif
14189
14190 /******************************************************************************/
14191 #ifndef WITH_LEANER
14192 #ifndef PALM_1
14193 static char *
14194 soap_getdimefield(struct soap *soap, size_t n)
14195 { register soap_wchar c;
14196 register size_t i;
14197 register char *s;
14198 register char *p = NULL;
14199 if (n)
14200 { p = (char*)soap_malloc(soap, n + 1);
14201 if (p)
14202 { s = p;
14203 for (i = n; i > 0; i--)
14204 { if ((int)(c = soap_get1(soap)) == EOF)
14205 { soap->error = SOAP_CHK_EOF;
14206 return NULL;
14207 }
14208 *s++ = (char)c;
14209 }
14210 *s = '\0';
14211 if ((soap->error = soap_move(soap, (size_t)(-(long)n&3))))
14212 return NULL;
14213 }
14214 else
14215 soap->error = SOAP_EOM;
14216 }
14217 return p;
14218 }
14219 #endif
14220 #endif
14221
14222 /******************************************************************************/
14223 #ifndef WITH_LEANER
14224 #ifndef PALM_1
14225 SOAP_FMAC1
14226 int
14227 SOAP_FMAC2
14228 soap_getdimehdr(struct soap *soap)
14229 { register soap_wchar c;
14230 register char *s;
14231 register int i;
14232 unsigned char tmp[12];
14233 size_t optlen, idlen, typelen;
14234 if (!(soap->mode & SOAP_ENC_DIME))
14235 return soap->error = SOAP_DIME_END;
14236 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get DIME header\n"));
14237 if (soap->dime.buflen || soap->dime.chunksize)
14238 { if (soap_move(soap, soap->dime.size - soap_tell(soap)))
14239 return soap->error = SOAP_CHK_EOF;
14240 soap_unget(soap, soap_getchar(soap)); /* skip padding and get hdr */
14241 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "... From chunked\n"));
14242 return SOAP_OK;
14243 }
14244 s = (char*)tmp;
14245 for (i = 12; i > 0; i--)
14246 { if ((int)(c = soap_getchar(soap)) == EOF)
14247 return soap->error = SOAP_CHK_EOF;
14248 *s++ = (char)c;
14249 }
14250 if ((tmp[0] & 0xF8) != SOAP_DIME_VERSION)
14251 return soap->error = SOAP_DIME_MISMATCH;
14252 soap->dime.flags = (tmp[0] & 0x7) | (tmp[1] & 0xF0);
14253 optlen = (tmp[2] << 8) | tmp[3];
14254 idlen = (tmp[4] << 8) | tmp[5];
14255 typelen = (tmp[6] << 8) | tmp[7];
14256 soap->dime.size = ((size_t)tmp[8] << 24) | ((size_t)tmp[9] << 16) | ((size_t)tmp[10] << 8) | ((size_t)tmp[11]);
14257 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DIME size=%lu flags=0x%X\n", (unsigned long)soap->dime.size, soap->dime.flags));
14258 if (!(soap->dime.options = soap_getdimefield(soap, optlen)) && soap->error)
14259 return soap->error;
14260 if (!(soap->dime.id = soap_getdimefield(soap, idlen)) && soap->error)
14261 return soap->error;
14262 if (!(soap->dime.type = soap_getdimefield(soap, typelen)) && soap->error)
14263 return soap->error;
14264 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DIME id='%s', type='%s', options='%s'\n", soap->dime.id ? soap->dime.id : SOAP_STR_EOS, soap->dime.type ? soap->dime.type : "", soap->dime.options ? soap->dime.options+4 : SOAP_STR_EOS));
14265 if (soap->dime.flags & SOAP_DIME_ME)
14266 soap->mode &= ~SOAP_ENC_DIME;
14267 return SOAP_OK;
14268 }
14269 #endif
14270 #endif
14271
14272 /******************************************************************************/
14273 #ifndef WITH_LEANER
14274 #ifndef PALM_1
14275 SOAP_FMAC1
14276 int
14277 SOAP_FMAC2
14278 soap_getdime(struct soap *soap)
14279 { while (soap->dime.flags & SOAP_DIME_CF)
14280 { if (soap_getdimehdr(soap))
14281 return soap->error;
14282 if (soap_move(soap, soap->dime.size))
14283 return soap->error = SOAP_EOF;
14284 }
14285 if (soap_move(soap, (size_t)(((soap->dime.size+3)&(~3)) - soap_tell(soap))))
14286 return soap->error = SOAP_EOF;
14287 for (;;)
14288 { register struct soap_multipart *content;
14289 if (soap_getdimehdr(soap))
14290 break;
14291 if (soap->fdimewriteopen && ((soap->dime.ptr = (char*)soap->fdimewriteopen(soap, soap->dime.id, soap->dime.type, soap->dime.options)) || soap->error))
14292 { const char *id, *type, *options;
14293 size_t size, n;
14294 if (!soap->dime.ptr)
14295 return soap->error;
14296 id = soap->dime.id;
14297 type = soap->dime.type;
14298 options = soap->dime.options;
14299 for (;;)
14300 { size = soap->dime.size;
14301 for (;;)
14302 { n = soap->buflen - soap->bufidx;
14303 if (size < n)
14304 n = size;
14305 if ((soap->error = soap->fdimewrite(soap, (void*)soap->dime.ptr, soap->buf + soap->bufidx, n)))
14306 break;
14307 size -= n;
14308 if (!size)
14309 { soap->bufidx += n;
14310 break;
14311 }
14312 if (soap_recv(soap))
14313 { soap->error = SOAP_EOF;
14314 goto end;
14315 }
14316 }
14317 if (soap_move(soap, (size_t)(-(long)soap->dime.size&3)))
14318 { soap->error = SOAP_EOF;
14319 break;
14320 }
14321 if (!(soap->dime.flags & SOAP_DIME_CF))
14322 break;
14323 if (soap_getdimehdr(soap))
14324 break;
14325 }
14326 end:
14327 if (soap->fdimewriteclose)
14328 soap->fdimewriteclose(soap, (void*)soap->dime.ptr);
14329 soap->dime.size = 0;
14330 soap->dime.id = id;
14331 soap->dime.type = type;
14332 soap->dime.options = options;
14333 }
14334 else if (soap->dime.flags & SOAP_DIME_CF)
14335 { const char *id, *type, *options;
14336 id = soap->dime.id;
14337 type = soap->dime.type;
14338 options = soap->dime.options;
14339 if (soap_new_block(soap) == NULL)
14340 return SOAP_EOM;
14341 for (;;)
14342 { register soap_wchar c;
14343 register size_t i;
14344 register char *s;
14345 if (soap->dime.size > SOAP_MAXDIMESIZE)
14346 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DIME size=%lu exceeds SOAP_MAXDIMESIZE=%lu\n", (unsigned long)soap->dime.size, (unsigned long)SOAP_MAXDIMESIZE));
14347 return soap->error = SOAP_DIME_ERROR;
14348 }
14349 s = (char*)soap_push_block(soap, NULL, soap->dime.size);
14350 if (!s)
14351 return soap->error = SOAP_EOM;
14352 for (i = soap->dime.size; i > 0; i--)
14353 { if ((int)(c = soap_get1(soap)) == EOF)
14354 return soap->error = SOAP_EOF;
14355 *s++ = (char)c;
14356 }
14357 if (soap_move(soap, (size_t)(-(long)soap->dime.size&3)))
14358 return soap->error = SOAP_EOF;
14359 if (!(soap->dime.flags & SOAP_DIME_CF))
14360 break;
14361 if (soap_getdimehdr(soap))
14362 return soap->error;
14363 }
14364 soap->dime.size = soap->blist->size++; /* allocate one more byte in blist for the terminating '\0' */
14365 if (!(soap->dime.ptr = soap_save_block(soap, NULL, NULL, 0)))
14366 return soap->error;
14367 soap->dime.ptr[soap->dime.size] = '\0'; /* make 0-terminated */
14368 soap->dime.id = id;
14369 soap->dime.type = type;
14370 soap->dime.options = options;
14371 }
14372 else
14373 soap->dime.ptr = soap_getdimefield(soap, soap->dime.size);
14374 content = soap_new_multipart(soap, &soap->dime.first, &soap->dime.last, soap->dime.ptr, soap->dime.size);
14375 if (!content)
14376 return soap->error = SOAP_EOM;
14377 content->id = soap->dime.id;
14378 content->type = soap->dime.type;
14379 content->options = soap->dime.options;
14380 if (soap->error)
14381 return soap->error;
14382 soap_resolve_attachment(soap, content);
14383 }
14384 if (soap->error != SOAP_DIME_END)
14385 return soap->error;
14386 return soap->error = SOAP_OK;
14387 }
14388 #endif
14389 #endif
14390
14391 /******************************************************************************/
14392 #ifndef WITH_LEANER
14393 #ifndef PALM_1
14394 SOAP_FMAC1
14395 int
14396 SOAP_FMAC2
14397 soap_getmimehdr(struct soap *soap)
14398 { struct soap_multipart *content;
14399 do
14400 { if (soap_getline(soap, soap->msgbuf, sizeof(soap->msgbuf)))
14401 return soap->error;
14402 }
14403 while (!*soap->msgbuf);
14404 if (soap->msgbuf[0] == '-' && soap->msgbuf[1] == '-')
14405 { char *s = soap->msgbuf + strlen(soap->msgbuf) - 1;
14406 /* remove white space */
14407 while (soap_blank((soap_wchar)*s))
14408 s--;
14409 s[1] = '\0';
14410 if (soap->mime.boundary)
14411 { if (strcmp(soap->msgbuf + 2, soap->mime.boundary))
14412 return soap->error = SOAP_MIME_ERROR;
14413 }
14414 else
14415 soap->mime.boundary = soap_strdup(soap, soap->msgbuf + 2);
14416 if (soap_getline(soap, soap->msgbuf, sizeof(soap->msgbuf)))
14417 return soap->error;
14418 }
14419 if (soap_set_mime_attachment(soap, NULL, 0, SOAP_MIME_NONE, NULL, NULL, NULL, NULL))
14420 return soap->error = SOAP_EOM;
14421 content = soap->mime.last;
14422 for (;;)
14423 { register char *key = soap->msgbuf;
14424 register char *val;
14425 if (!*key)
14426 break;
14427 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "MIME header: %s\n", key));
14428 val = strchr(soap->msgbuf, ':');
14429 if (val)
14430 { *val = '\0';
14431 do val++;
14432 while (*val && *val <= 32);
14433 if (!soap_tag_cmp(key, "Content-ID"))
14434 content->id = soap_strdup(soap, val);
14435 else if (!soap_tag_cmp(key, "Content-Location"))
14436 content->location = soap_strdup(soap, val);
14437 else if (!soap_tag_cmp(key, "Content-Disposition"))
14438 content->id = soap_strdup(soap, soap_get_header_attribute(soap, val, "name"));
14439 else if (!soap_tag_cmp(key, "Content-Type"))
14440 content->type = soap_strdup(soap, val);
14441 else if (!soap_tag_cmp(key, "Content-Description"))
14442 content->description = soap_strdup(soap, val);
14443 else if (!soap_tag_cmp(key, "Content-Transfer-Encoding"))
14444 content->encoding = (enum soap_mime_encoding)soap_code_int(mime_codes, val, (long)SOAP_MIME_NONE);
14445 }
14446 if (soap_getline(soap, key, sizeof(soap->msgbuf)))
14447 return soap->error;
14448 }
14449 return SOAP_OK;
14450 }
14451 #endif
14452 #endif
14453
14454 /******************************************************************************/
14455 #ifndef WITH_LEANER
14456 #ifndef PALM_1
14457 SOAP_FMAC1
14458 int
14459 SOAP_FMAC2
14460 soap_getmime(struct soap *soap)
14461 { while (soap_get_mime_attachment(soap, NULL))
14462 ;
14463 return soap->error;
14464 }
14465 #endif
14466 #endif
14467
14468 /******************************************************************************/
14469 #ifndef WITH_LEANER
14470 #ifndef PALM_1
14471 SOAP_FMAC1
14472 void
14473 SOAP_FMAC2
14474 soap_post_check_mime_attachments(struct soap *soap)
14475 { soap->imode |= SOAP_MIME_POSTCHECK;
14476 }
14477 #endif
14478 #endif
14479
14480 /******************************************************************************/
14481 #ifndef WITH_LEANER
14482 #ifndef PALM_1
14483 SOAP_FMAC1
14484 int
14485 SOAP_FMAC2
14486 soap_check_mime_attachments(struct soap *soap)
14487 { if (soap->mode & SOAP_MIME_POSTCHECK)
14488 return soap_get_mime_attachment(soap, NULL) != NULL;
14489 return SOAP_OK;
14490 }
14491 #endif
14492 #endif
14493
14494 /******************************************************************************/
14495 #ifndef WITH_LEANER
14496 #ifndef PALM_1
14497 SOAP_FMAC1
14498 struct soap_multipart *
14499 SOAP_FMAC2
14500 soap_get_mime_attachment(struct soap *soap, void *handle)
14501 { register soap_wchar c = 0;
14502 register size_t i, m = 0;
14503 register char *s, *t = NULL;
14504 register struct soap_multipart *content;
14505 register short flag = 0;
14506 if (!(soap->mode & SOAP_ENC_MIME))
14507 return NULL;
14508 content = soap->mime.last;
14509 if (!content)
14510 { if (soap_getmimehdr(soap))
14511 return NULL;
14512 content = soap->mime.last;
14513 }
14514 else if (content != soap->mime.first)
14515 { if (soap->fmimewriteopen && ((content->ptr = (char*)soap->fmimewriteopen(soap, (void*)handle, content->id, content->type, content->description, content->encoding)) || soap->error))
14516 { if (!content->ptr)
14517 return NULL;
14518 }
14519 }
14520 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Parsing MIME content id='%s' type='%s'\n", content->id ? content->id : SOAP_STR_EOS, content->type ? content->type : SOAP_STR_EOS));
14521 if (!content->ptr && soap_new_block(soap) == NULL)
14522 { soap->error = SOAP_EOM;
14523 return NULL;
14524 }
14525 for (;;)
14526 { if (content->ptr)
14527 s = soap->tmpbuf;
14528 else if (!(s = (char*)soap_push_block(soap, NULL, sizeof(soap->tmpbuf))))
14529 { soap->error = SOAP_EOM;
14530 return NULL;
14531 }
14532 for (i = 0; i < sizeof(soap->tmpbuf); i++)
14533 { if (m > 0)
14534 { *s++ = *t++;
14535 m--;
14536 }
14537 else
14538 { if (!flag)
14539 { c = soap_get1(soap);
14540 if ((int)c == EOF)
14541 { if (content->ptr && soap->fmimewriteclose)
14542 soap->fmimewriteclose(soap, (void*)content->ptr);
14543 soap->error = SOAP_CHK_EOF;
14544 return NULL;
14545 }
14546 }
14547 if (flag || c == '\r')
14548 { t = soap->msgbuf;
14549 memset(t, 0, sizeof(soap->msgbuf));
14550 strcpy(t, "\n--");
14551 if (soap->mime.boundary)
14552 strncat(t, soap->mime.boundary, sizeof(soap->msgbuf)-4);
14553 do c = soap_getchar(soap);
14554 while (c == *t++);
14555 if ((int)c == EOF)
14556 { if (content->ptr && soap->fmimewriteclose)
14557 soap->fmimewriteclose(soap, (void*)content->ptr);
14558 soap->error = SOAP_CHK_EOF;
14559 return NULL;
14560 }
14561 if (!*--t)
14562 goto end;
14563 *t = (char)c;
14564 flag = (c == '\r');
14565 m = t - soap->msgbuf + 1 - flag;
14566 t = soap->msgbuf;
14567 c = '\r';
14568 }
14569 *s++ = (char)c;
14570 }
14571 }
14572 if (content->ptr && soap->fmimewrite)
14573 { if ((soap->error = soap->fmimewrite(soap, (void*)content->ptr, soap->tmpbuf, i)))
14574 break;
14575 }
14576 }
14577 end:
14578 *s = '\0'; /* make 0-terminated */
14579 if (content->ptr)
14580 { if (!soap->error && soap->fmimewrite)
14581 soap->error = soap->fmimewrite(soap, (void*)content->ptr, soap->tmpbuf, i);
14582 if (soap->fmimewriteclose)
14583 soap->fmimewriteclose(soap, (void*)content->ptr);
14584 if (soap->error)
14585 return NULL;
14586 }
14587 else
14588 { content->size = soap_size_block(soap, NULL, i+1) - 1; /* last block with '\0' */
14589 content->ptr = soap_save_block(soap, NULL, NULL, 0);
14590 }
14591 soap_resolve_attachment(soap, content);
14592 if (c == '-' && soap_getchar(soap) == '-')
14593 { soap->mode &= ~SOAP_ENC_MIME;
14594 if ((soap->mode & SOAP_MIME_POSTCHECK) && soap_end_recv(soap))
14595 { if (soap->keep_alive < 0)
14596 soap->keep_alive = 0;
14597 soap_closesock(soap);
14598 return NULL;
14599 }
14600 }
14601 else
14602 { while (c != '\r' && (int)c != EOF && soap_blank(c))
14603 c = soap_getchar(soap);
14604 if (c != '\r' || soap_getchar(soap) != '\n')
14605 { soap->error = SOAP_MIME_ERROR;
14606 return NULL;
14607 }
14608 if (soap_getmimehdr(soap))
14609 return NULL;
14610 }
14611 return content;
14612 }
14613 #endif
14614 #endif
14615
14616 /******************************************************************************/
14617 #ifndef WITH_LEANER
14618 #ifndef PALM_1
14619 SOAP_FMAC1
14620 int
14621 SOAP_FMAC2
14622 soap_match_cid(struct soap *soap, const char *s, const char *t)
14623 { register size_t n;
14624 if (!s)
14625 return 1;
14626 if (!strcmp(s, t))
14627 return 0;
14628 if (!strncmp(s, "cid:", 4))
14629 s += 4;
14630 n = strlen(t);
14631 if (*t == '<')
14632 { t++;
14633 n -= 2;
14634 }
14635 if (!strncmp(s, t, n) && !s[n])
14636 return 0;
14637 soap_decode(soap->tmpbuf, sizeof(soap->tmpbuf), s, SOAP_STR_EOS);
14638 if (!strncmp(soap->tmpbuf, t, n) && !soap->tmpbuf[n])
14639 return 0;
14640 return 1;
14641 }
14642 #endif
14643 #endif
14644
14645 /******************************************************************************/
14646 #ifndef WITH_LEANER
14647 #ifndef PALM_1
14648 static void
14649 soap_resolve_attachment(struct soap *soap, struct soap_multipart *content)
14650 { if (content->id)
14651 { register struct soap_xlist **xp = &soap->xlist;
14652 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolving attachment data for id='%s'\n", content->id));
14653 while (*xp)
14654 { register struct soap_xlist *xq = *xp;
14655 if (!soap_match_cid(soap, xq->id, content->id))
14656 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Found matching attachment id='%s' for content id='%s'\n", xq->id, content->id));
14657 *xp = xq->next;
14658 *xq->ptr = (unsigned char*)content->ptr;
14659 *xq->size = (int)content->size;
14660 *xq->type = (char*)content->type;
14661 if (content->options)
14662 *xq->options = (char*)content->options;
14663 else
14664 *xq->options = (char*)content->description;
14665 SOAP_FREE(soap, xq);
14666 }
14667 else
14668 xp = &(*xp)->next;
14669 }
14670 }
14671 }
14672 #endif
14673 #endif
14674
14675 /******************************************************************************/
14676 #ifndef WITH_LEANER
14677 #ifndef PALM_1
14678 SOAP_FMAC1
14679 int
14680 SOAP_FMAC2
14681 soap_putmimehdr(struct soap *soap, struct soap_multipart *content)
14682 { const char *s;
14683 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "MIME attachment type='%s'\n", content->type ? content->type : SOAP_STR_EOS));
14684 if (soap_send3(soap, "\r\n--", soap->mime.boundary, "\r\n"))
14685 return soap->error;
14686 if (content->type && soap_send3(soap, "Content-Type: ", content->type, "\r\n"))
14687 return soap->error;
14688 s = soap_code_str(mime_codes, content->encoding);
14689 if (s && soap_send3(soap, "Content-Transfer-Encoding: ", s, "\r\n"))
14690 return soap->error;
14691 if (content->id && soap_send3(soap, "Content-ID: ", content->id, "\r\n"))
14692 return soap->error;
14693 if (content->location && soap_send3(soap, "Content-Location: ", content->location, "\r\n"))
14694 return soap->error;
14695 if (content->description && soap_send3(soap, "Content-Description: ", content->description, "\r\n"))
14696 return soap->error;
14697 return soap_send_raw(soap, "\r\n", 2);
14698 }
14699 #endif
14700 #endif
14701
14702 /******************************************************************************/
14703 #ifndef WITH_LEANER
14704 #ifndef PALM_1
14705 SOAP_FMAC1
14706 int
14707 SOAP_FMAC2
14708 soap_putmime(struct soap *soap)
14709 { struct soap_multipart *content;
14710 if (!(soap->mode & SOAP_ENC_MIME) || !soap->mime.boundary)
14711 return SOAP_OK;
14712 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Sending MIME attachments\n"));
14713 for (content = soap->mime.first; content; content = content->next)
14714 { void *handle;
14715 if (soap->fmimereadopen && ((handle = soap->fmimereadopen(soap, (void*)content->ptr, content->id, content->type, content->description)) || soap->error))
14716 { size_t size = content->size;
14717 if (!handle)
14718 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fmimereadopen failed\n"));
14719 return soap->error;
14720 }
14721 if (soap_putmimehdr(soap, content))
14722 return soap->error;
14723 if (!size)
14724 { if ((soap->mode & SOAP_ENC_XML) || (soap->mode & SOAP_IO) == SOAP_IO_CHUNK || (soap->mode & SOAP_IO) == SOAP_IO_STORE)
14725 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunked streaming MIME\n"));
14726 do
14727 { size = soap->fmimeread(soap, handle, soap->tmpbuf, sizeof(soap->tmpbuf));
14728 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fmimeread returned %lu bytes\n", (unsigned long)size));
14729 if (soap_send_raw(soap, soap->tmpbuf, size))
14730 break;
14731 } while (size);
14732 }
14733 else
14734 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Error: cannot chunk streaming MIME (no HTTP chunking)\n"));
14735 }
14736 }
14737 else
14738 { do
14739 { size_t bufsize;
14740 if (size < sizeof(soap->tmpbuf))
14741 bufsize = size;
14742 else
14743 bufsize = sizeof(soap->tmpbuf);
14744 if (!(bufsize = soap->fmimeread(soap, handle, soap->tmpbuf, bufsize)))
14745 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fmimeread failed: insufficient data (%lu bytes remaining from %lu bytes)\n", (unsigned long)size, (unsigned long)content->size));
14746 soap->error = SOAP_EOF;
14747 break;
14748 }
14749 if (soap_send_raw(soap, soap->tmpbuf, bufsize))
14750 break;
14751 size -= bufsize;
14752 } while (size);
14753 }
14754 if (soap->fmimereadclose)
14755 soap->fmimereadclose(soap, handle);
14756 }
14757 else
14758 { if (soap_putmimehdr(soap, content)
14759 || soap_send_raw(soap, content->ptr, content->size))
14760 return soap->error;
14761 }
14762 }
14763 return soap_send3(soap, "\r\n--", soap->mime.boundary, "--");
14764 }
14765 #endif
14766 #endif
14767
14768 /******************************************************************************/
14769 #ifndef WITH_LEANER
14770 #ifndef PALM_1
14771 SOAP_FMAC1
14772 void
14773 SOAP_FMAC2
14774 soap_set_dime(struct soap *soap)
14775 { soap->omode |= SOAP_ENC_DIME;
14776 soap->dime.first = NULL;
14777 soap->dime.last = NULL;
14778 }
14779 #endif
14780 #endif
14781
14782 /******************************************************************************/
14783 #ifndef WITH_LEANER
14784 #ifndef PALM_1
14785 SOAP_FMAC1
14786 void
14787 SOAP_FMAC2
14788 soap_set_mime(struct soap *soap, const char *boundary, const char *start)
14789 { soap->omode |= SOAP_ENC_MIME;
14790 soap->mime.first = NULL;
14791 soap->mime.last = NULL;
14792 soap->mime.boundary = soap_strdup(soap, boundary);
14793 soap->mime.start = soap_strdup(soap, start);
14794 }
14795 #endif
14796 #endif
14797
14798 /******************************************************************************/
14799 #ifndef WITH_LEANER
14800 #ifndef PALM_1
14801 SOAP_FMAC1
14802 void
14803 SOAP_FMAC2
14804 soap_clr_dime(struct soap *soap)
14805 { soap->omode &= ~SOAP_ENC_DIME;
14806 soap->dime.first = NULL;
14807 soap->dime.last = NULL;
14808 }
14809 #endif
14810 #endif
14811
14812 /******************************************************************************/
14813 #ifndef WITH_LEANER
14814 #ifndef PALM_1
14815 SOAP_FMAC1
14816 void
14817 SOAP_FMAC2
14818 soap_clr_mime(struct soap *soap)
14819 { soap->omode &= ~SOAP_ENC_MIME;
14820 soap->mime.first = NULL;
14821 soap->mime.last = NULL;
14822 soap->mime.boundary = NULL;
14823 soap->mime.start = NULL;
14824 }
14825 #endif
14826 #endif
14827
14828 /******************************************************************************/
14829 #ifndef WITH_LEANER
14830 #ifndef PALM_1
14831 static struct soap_multipart*
14832 soap_new_multipart(struct soap *soap, struct soap_multipart **first, struct soap_multipart **last, char *ptr, size_t size)
14833 { struct soap_multipart *content;
14834 content = (struct soap_multipart*)soap_malloc(soap, sizeof(struct soap_multipart));
14835 if (content)
14836 { content->next = NULL;
14837 content->ptr = ptr;
14838 content->size = size;
14839 content->id = NULL;
14840 content->type = NULL;
14841 content->options = NULL;
14842 content->encoding = SOAP_MIME_NONE;
14843 content->location = NULL;
14844 content->description = NULL;
14845 if (!*first)
14846 *first = content;
14847 if (*last)
14848 (*last)->next = content;
14849 *last = content;
14850 }
14851 return content;
14852 }
14853 #endif
14854 #endif
14855
14856 /******************************************************************************/
14857 #ifndef WITH_LEANER
14858 #ifndef PALM_1
14859 SOAP_FMAC1
14860 int
14861 SOAP_FMAC2
14862 soap_set_dime_attachment(struct soap *soap, char *ptr, size_t size, const char *type, const char *id, unsigned short optype, const char *option)
14863 { struct soap_multipart *content = soap_new_multipart(soap, &soap->dime.first, &soap->dime.last, ptr, size);
14864 if (!content)
14865 return SOAP_EOM;
14866 content->id = soap_strdup(soap, id);
14867 content->type = soap_strdup(soap, type);
14868 content->options = soap_dime_option(soap, optype, option);
14869 return SOAP_OK;
14870 }
14871 #endif
14872 #endif
14873
14874 /******************************************************************************/
14875 #ifndef WITH_LEANER
14876 #ifndef PALM_1
14877 SOAP_FMAC1
14878 int
14879 SOAP_FMAC2
14880 soap_set_mime_attachment(struct soap *soap, char *ptr, size_t size, enum soap_mime_encoding encoding, const char *type, const char *id, const char *location, const char *description)
14881 { struct soap_multipart *content = soap_new_multipart(soap, &soap->mime.first, &soap->mime.last, ptr, size);
14882 if (!content)
14883 return SOAP_EOM;
14884 content->id = soap_strdup(soap, id);
14885 content->type = soap_strdup(soap, type);
14886 content->encoding = encoding;
14887 content->location = soap_strdup(soap, location);
14888 content->description = soap_strdup(soap, description);
14889 return SOAP_OK;
14890 }
14891 #endif
14892 #endif
14893
14894 /******************************************************************************/
14895 #ifndef WITH_LEANER
14896 #ifndef PALM_1
14897 SOAP_FMAC1
14898 struct soap_multipart*
14899 SOAP_FMAC2
14900 soap_next_multipart(struct soap_multipart *content)
14901 { if (content)
14902 return content->next;
14903 return NULL;
14904 }
14905 #endif
14906 #endif
14907
14908 /******************************************************************************/
14909 #ifndef WITH_LEANER
14910 #ifndef PALM_1
14911 static void
14912 soap_select_mime_boundary(struct soap *soap)
14913 { while (!soap->mime.boundary || soap_valid_mime_boundary(soap))
14914 { register char *s = soap->mime.boundary;
14915 register size_t n = 0;
14916 if (s)
14917 n = strlen(s);
14918 if (n < 16)
14919 { n = 64;
14920 s = soap->mime.boundary = (char*)soap_malloc(soap, n + 1);
14921 if (!s)
14922 return;
14923 }
14924 strcpy(s, "==");
14925 s += 2;
14926 n -= 4;
14927 while (n)
14928 { *s++ = soap_base64o[soap_random & 0x3F];
14929 n--;
14930 }
14931 strcpy(s, "==");
14932 }
14933 if (!soap->mime.start)
14934 soap->mime.start = "<SOAP-ENV:Envelope>";
14935 }
14936 #endif
14937 #endif
14938
14939 /******************************************************************************/
14940 #ifndef WITH_LEANER
14941 #ifndef PALM_1
14942 static int
14943 soap_valid_mime_boundary(struct soap *soap)
14944 { register struct soap_multipart *content;
14945 register size_t k;
14946 if (soap->fmimeread)
14947 return SOAP_OK;
14948 k = strlen(soap->mime.boundary);
14949 for (content = soap->mime.first; content; content = content->next)
14950 { if (content->ptr && content->size >= k)
14951 { register const char *p = (const char*)content->ptr;
14952 register size_t i;
14953 for (i = 0; i < content->size - k; i++, p++)
14954 { if (!strncmp(p, soap->mime.boundary, k))
14955 return SOAP_ERR;
14956 }
14957 }
14958 }
14959 return SOAP_OK;
14960 }
14961 #endif
14962 #endif
14963
14964 /******************************************************************************/
14965 #ifdef WITH_GZIP
14966 #ifndef PALM_1
14967 static int
14968 soap_getgziphdr(struct soap *soap)
14969 { int i;
14970 soap_wchar c = 0, f = 0;
14971 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get gzip header\n"));
14972 for (i = 0; i < 9; i++)
14973 { if ((int)(c = soap_get1(soap) == EOF))
14974 return soap->error = SOAP_ZLIB_ERROR;
14975 if (i == 1 && c == 8)
14976 soap->z_dict = 0;
14977 if (i == 2)
14978 f = c;
14979 }
14980 if (f & 0x04) /* FEXTRA */
14981 { for (i = soap_get1(soap) | (soap_get1(soap) << 8); i; i--)
14982 { if ((int)soap_get1(soap) == EOF)
14983 return soap->error = SOAP_ZLIB_ERROR;
14984 }
14985 }
14986 if (f & 0x08) /* skip FNAME */
14987 { do
14988 c = soap_get1(soap);
14989 while (c && (int)c != EOF);
14990 }
14991 if ((int)c != EOF && (f & 0x10)) /* skip FCOMMENT */
14992 { do
14993 c = soap_get1(soap);
14994 while (c && (int)c != EOF);
14995 }
14996 if ((int)c != EOF && (f & 0x02)) /* skip FHCRC (CRC32 is used) */
14997 { if ((int)(c = soap_get1(soap)) != EOF)
14998 c = soap_get1(soap);
14999 }
15000 if ((int)c == EOF)
15001 return soap->error = SOAP_ZLIB_ERROR;
15002 return SOAP_OK;
15003 }
15004 #endif
15005 #endif
15006
15007 /******************************************************************************/
15008 #ifndef PALM_1
15009 SOAP_FMAC1
15010 int
15011 SOAP_FMAC2
15012 soap_begin_serve(struct soap *soap)
15013 {
15014 #ifdef WITH_FASTCGI
15015 if (FCGI_Accept() < 0)
15016 { soap->error = SOAP_EOF;
15017 return soap_send_fault(soap);
15018 }
15019 #endif
15020 soap_begin(soap);
15021 if (soap_begin_recv(soap)
15022 || soap_envelope_begin_in(soap)
15023 || soap_recv_header(soap)
15024 || soap_body_begin_in(soap))
15025 { if (soap->error < SOAP_STOP)
15026 {
15027 #ifdef WITH_FASTCGI
15028 soap_send_fault(soap);
15029 #else
15030 return soap_send_fault(soap);
15031 #endif
15032 }
15033 return soap_closesock(soap);
15034 }
15035 return SOAP_OK;
15036 }
15037 #endif
15038
15039 /******************************************************************************/
15040 #ifndef PALM_1
15041 SOAP_FMAC1
15042 int
15043 SOAP_FMAC2
15044 soap_begin_recv(struct soap *soap)
15045 { register soap_wchar c;
15046 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Initializing for input from socket=%d/fd=%d\n", soap->socket, soap->recvfd));
15047 soap->error = SOAP_OK;
15048 soap->filterstop = SOAP_OK;
15049 soap_free_temp(soap);
15050 soap_set_local_namespaces(soap);
15051 soap->version = 0; /* don't assume we're parsing SOAP content by default */
15052 #ifndef WITH_NOIDREF
15053 soap_free_iht(soap);
15054 #endif
15055 if ((soap->imode & SOAP_IO) == SOAP_IO_CHUNK)
15056 soap->omode |= SOAP_IO_CHUNK;
15057 soap->imode &= ~(SOAP_IO | SOAP_ENC_MIME);
15058 soap->mode = soap->imode;
15059 if (!soap->keep_alive)
15060 { soap->buflen = 0;
15061 soap->bufidx = 0;
15062 }
15063 if (!(soap->mode & SOAP_IO_KEEPALIVE))
15064 soap->keep_alive = 0;
15065 soap->ahead = 0;
15066 soap->peeked = 0;
15067 soap->level = 0;
15068 soap->part = SOAP_BEGIN;
15069 soap->alloced = 0;
15070 soap->body = 1;
15071 soap->count = 0;
15072 soap->length = 0;
15073 soap->cdata = 0;
15074 *soap->endpoint = '\0';
15075 soap->action = NULL;
15076 soap->header = NULL;
15077 soap->fault = NULL;
15078 soap->status = 0;
15079 soap->fform = NULL;
15080 #ifndef WITH_LEANER
15081 soap->dom = NULL;
15082 soap->dime.chunksize = 0;
15083 soap->dime.buflen = 0;
15084 soap->dime.list = NULL;
15085 soap->dime.first = NULL;
15086 soap->dime.last = NULL;
15087 soap->mime.list = NULL;
15088 soap->mime.first = NULL;
15089 soap->mime.last = NULL;
15090 soap->mime.boundary = NULL;
15091 soap->mime.start = NULL;
15092 #endif
15093 #ifdef WIN32
15094 #ifndef UNDER_CE
15095 #ifndef WITH_FASTCGI
15096 if (!soap_valid_socket(soap->socket) && !soap->is) /* Set win32 stdout or soap->sendfd to BINARY, e.g. to support DIME */
15097 #ifdef __BORLANDC__
15098 setmode(soap->recvfd, _O_BINARY);
15099 #else
15100 _setmode(soap->recvfd, _O_BINARY);
15101 #endif
15102 #endif
15103 #endif
15104 #endif
15105 #ifdef WITH_ZLIB
15106 soap->mode &= ~SOAP_ENC_ZLIB;
15107 soap->zlib_in = SOAP_ZLIB_NONE;
15108 soap->zlib_out = SOAP_ZLIB_NONE;
15109 soap->d_stream->next_in = Z_NULL;
15110 soap->d_stream->avail_in = 0;
15111 soap->d_stream->next_out = (Byte*)soap->buf;
15112 soap->d_stream->avail_out = SOAP_BUFLEN;
15113 soap->z_ratio_in = 1.0;
15114 #endif
15115 #ifdef WITH_OPENSSL
15116 if (soap->ssl)
15117 ERR_clear_error();
15118 #endif
15119 #ifndef WITH_LEANER
15120 if (soap->fprepareinitrecv && (soap->error = soap->fprepareinitrecv(soap)))
15121 return soap->error;
15122 #endif
15123 c = soap_getchar(soap);
15124 #ifdef WITH_GZIP
15125 if (c == 0x1F)
15126 { if (soap_getgziphdr(soap))
15127 return soap->error;
15128 if (inflateInit2(soap->d_stream, -MAX_WBITS) != Z_OK)
15129 return soap->error = SOAP_ZLIB_ERROR;
15130 if (soap->z_dict)
15131 { if (inflateSetDictionary(soap->d_stream, (const Bytef*)soap->z_dict, soap->z_dict_len) != Z_OK)
15132 return soap->error = SOAP_ZLIB_ERROR;
15133 }
15134 soap->zlib_state = SOAP_ZLIB_INFLATE;
15135 soap->mode |= SOAP_ENC_ZLIB;
15136 soap->zlib_in = SOAP_ZLIB_GZIP;
15137 soap->z_crc = crc32(0L, NULL, 0);
15138 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "gzip initialized\n"));
15139 if (!soap->z_buf)
15140 soap->z_buf = (char*)SOAP_MALLOC(soap, SOAP_BUFLEN);
15141 memcpy(soap->z_buf, soap->buf, SOAP_BUFLEN);
15142 /* should not chunk over plain transport, so why bother to check? */
15143 /* if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK) */
15144 /* soap->z_buflen = soap->bufidx; */
15145 /* else */
15146 soap->d_stream->next_in = (Byte*)(soap->z_buf + soap->bufidx);
15147 soap->d_stream->avail_in = (unsigned int)(soap->buflen - soap->bufidx);
15148 soap->z_buflen = soap->buflen;
15149 soap->buflen = soap->bufidx;
15150 c = ' ';
15151 }
15152 #endif
15153 while (soap_blank(c))
15154 c = soap_getchar(soap);
15155 #ifndef WITH_LEANER
15156 if (c == '-' && soap_get0(soap) == '-')
15157 soap->mode |= SOAP_ENC_MIME;
15158 else if ((c & 0xFFFC) == (SOAP_DIME_VERSION | SOAP_DIME_MB) && (soap_get0(soap) & 0xFFF0) == 0x20)
15159 soap->mode |= SOAP_ENC_DIME;
15160 else
15161 #endif
15162 { /* skip BOM */
15163 if (c == 0xEF && soap_get0(soap) == 0xBB)
15164 { c = soap_get1(soap);
15165 if ((c = soap_get1(soap)) == 0xBF)
15166 { soap->mode &= ~SOAP_ENC_LATIN;
15167 c = soap_getchar(soap);
15168 }
15169 else
15170 c = (0x0F << 12) | (0xBB << 6) | (c & 0x3F); /* UTF-8 */
15171 }
15172 else if ((c == 0xFE && soap_get0(soap) == 0xFF) /* UTF-16 BE */
15173 || (c == 0xFF && soap_get0(soap) == 0xFE)) /* UTF-16 LE */
15174 return soap->error = SOAP_UTF_ERROR;
15175 /* skip space */
15176 while (soap_blank(c))
15177 c = soap_getchar(soap);
15178 }
15179 if ((int)c == EOF)
15180 return soap->error = SOAP_CHK_EOF;
15181 soap_unget(soap, c);
15182 #ifndef WITH_NOHTTP
15183 /* if not XML/MIME/DIME/ZLIB, assume HTTP method or status line */
15184 if (((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) && !(soap->mode & (SOAP_ENC_MIME | SOAP_ENC_DIME | SOAP_ENC_ZLIB | SOAP_ENC_XML)))
15185 { soap_mode m = soap->imode;
15186 soap->mode &= ~SOAP_IO;
15187 soap->error = soap->fparse(soap);
15188 if (soap->error && soap->error < SOAP_STOP)
15189 { soap->keep_alive = 0; /* force close later */
15190 return soap->error;
15191 }
15192 if (soap->error == SOAP_STOP)
15193 { if (soap->fform)
15194 { soap->error = soap->fform(soap);
15195 if (soap->error == SOAP_OK)
15196 soap->error = SOAP_STOP; /* prevents further processing */
15197 }
15198 return soap->error;
15199 }
15200 soap->mode = soap->imode; /* if imode is changed, effectuate */
15201 soap->imode = m; /* restore imode */
15202 #ifdef WITH_ZLIB
15203 soap->mode &= ~SOAP_ENC_ZLIB;
15204 #endif
15205 if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK)
15206 { soap->chunkbuflen = soap->buflen;
15207 soap->buflen = soap->bufidx;
15208 soap->chunksize = 0;
15209 }
15210 /* Note: fparse should not use soap_unget to push back last char */
15211 #if 0
15212 if (soap->status > 200 && soap->length == 0 && !(soap->http_content && (!soap->keep_alive || soap->recv_timeout)) && (soap->imode & SOAP_IO) != SOAP_IO_CHUNK)
15213 #endif
15214 if (soap->status && !soap->body)
15215 return soap->error = soap->status;
15216 #ifdef WITH_ZLIB
15217 if (soap->zlib_in != SOAP_ZLIB_NONE)
15218 {
15219 #ifdef WITH_GZIP
15220 if (soap->zlib_in != SOAP_ZLIB_DEFLATE)
15221 { c = soap_get1(soap);
15222 if (c == (int)EOF)
15223 return soap->error = SOAP_EOF;
15224 if (c == 0x1F)
15225 { if (soap_getgziphdr(soap))
15226 return soap->error;
15227 if (inflateInit2(soap->d_stream, -MAX_WBITS) != Z_OK)
15228 return soap->error = SOAP_ZLIB_ERROR;
15229 soap->z_crc = crc32(0L, NULL, 0);
15230 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "gzip initialized\n"));
15231 }
15232 else
15233 { soap_revget1(soap);
15234 if (inflateInit(soap->d_stream) != Z_OK)
15235 return soap->error = SOAP_ZLIB_ERROR;
15236 soap->zlib_in = SOAP_ZLIB_DEFLATE;
15237 }
15238 }
15239 else
15240 #endif
15241 if (inflateInit(soap->d_stream) != Z_OK)
15242 return soap->error = SOAP_ZLIB_ERROR;
15243 if (soap->z_dict)
15244 { if (inflateSetDictionary(soap->d_stream, (const Bytef*)soap->z_dict, soap->z_dict_len) != Z_OK)
15245 return soap->error = SOAP_ZLIB_ERROR;
15246 }
15247 soap->zlib_state = SOAP_ZLIB_INFLATE;
15248 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflate initialized\n"));
15249 soap->mode |= SOAP_ENC_ZLIB;
15250 if (!soap->z_buf)
15251 soap->z_buf = (char*)SOAP_MALLOC(soap, SOAP_BUFLEN);
15252 memcpy(soap->z_buf, soap->buf, SOAP_BUFLEN);
15253 soap->d_stream->next_in = (Byte*)(soap->z_buf + soap->bufidx);
15254 soap->d_stream->avail_in = (unsigned int)(soap->buflen - soap->bufidx);
15255 soap->z_buflen = soap->buflen;
15256 soap->buflen = soap->bufidx;
15257 }
15258 #endif
15259 #ifndef WITH_LEANER
15260 if (soap->fpreparerecv && (soap->mode & SOAP_IO) != SOAP_IO_CHUNK && soap->buflen > soap->bufidx)
15261 { int r;
15262 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Invoking fpreparerecv\n"));
15263 if ((r = soap->fpreparerecv(soap, soap->buf + soap->bufidx, soap->buflen - soap->bufidx)))
15264 return soap->error = r;
15265 }
15266 #endif
15267 if (soap_get0(soap) == (int)EOF)
15268 { if (soap->status == 0 || soap->status == 200)
15269 return soap->error = SOAP_NO_DATA; /* HTTP OK: always expect data */
15270 return soap->error = soap->status;
15271 }
15272 if (soap->error)
15273 { if (soap->error == SOAP_FORM && soap->fform)
15274 { soap->error = soap->fform(soap);
15275 if (soap->error == SOAP_OK)
15276 soap->error = SOAP_STOP; /* prevents further processing */
15277 }
15278 return soap->error;
15279 }
15280 }
15281 #endif
15282 #ifndef WITH_LEANER
15283 if (soap->mode & SOAP_ENC_MIME)
15284 { do /* skip preamble */
15285 { if ((int)(c = soap_getchar(soap)) == EOF)
15286 return soap->error = SOAP_CHK_EOF;
15287 } while (c != '-' || soap_get0(soap) != '-');
15288 soap_unget(soap, c);
15289 if (soap_getmimehdr(soap))
15290 return soap->error;
15291 if (soap->mime.start)
15292 { do
15293 { if (!soap->mime.last->id)
15294 break;
15295 if (!soap_match_cid(soap, soap->mime.start, soap->mime.last->id))
15296 break;
15297 } while (soap_get_mime_attachment(soap, NULL));
15298 }
15299 if (soap_get_header_attribute(soap, soap->mime.first->type, "application/dime"))
15300 soap->mode |= SOAP_ENC_DIME;
15301 }
15302 if (soap->mode & SOAP_ENC_DIME)
15303 { if (soap_getdimehdr(soap))
15304 return soap->error;
15305 if (soap->dime.flags & SOAP_DIME_CF)
15306 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunked DIME SOAP message\n"));
15307 soap->dime.chunksize = soap->dime.size;
15308 if (soap->buflen - soap->bufidx >= soap->dime.chunksize)
15309 { soap->dime.buflen = soap->buflen;
15310 soap->buflen = soap->bufidx + soap->dime.chunksize;
15311 }
15312 else
15313 soap->dime.chunksize -= soap->buflen - soap->bufidx;
15314 }
15315 soap->count = soap->buflen - soap->bufidx;
15316 }
15317 #endif
15318 return SOAP_OK;
15319 }
15320 #endif
15321
15322 /******************************************************************************/
15323 #ifndef PALM_2
15324 SOAP_FMAC1
15325 int
15326 SOAP_FMAC2
15327 soap_envelope_begin_out(struct soap *soap)
15328 {
15329 #ifndef WITH_LEANER
15330 size_t n = 0;
15331 if ((soap->mode & SOAP_ENC_MIME) && soap->mime.boundary && soap->mime.start && strlen(soap->mime.boundary) + strlen(soap->mime.start) < sizeof(soap->tmpbuf) - 80 )
15332 { const char *s;
15333 if ((soap->mode & SOAP_ENC_DIME) && !(soap->mode & SOAP_ENC_MTOM))
15334 s = "application/dime";
15335 else if (soap->version == 2)
15336 { if (soap->mode & SOAP_ENC_MTOM)
15337 s = "application/xop+xml; charset=utf-8; type=\"application/soap+xml\"";
15338 else
15339 s = "application/soap+xml; charset=utf-8";
15340 }
15341 else if (soap->mode & SOAP_ENC_MTOM)
15342 s = "application/xop+xml; charset=utf-8; type=\"text/xml\"";
15343 else
15344 s = "text/xml; charset=utf-8";
15345 #ifdef HAVE_SNPRINTF
15346 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), "--%s\r\nContent-Type: %s\r\nContent-Transfer-Encoding: binary\r\nContent-ID: %s\r\n\r\n", soap->mime.boundary, s, soap->mime.start);
15347 #else
15348 sprintf(soap->tmpbuf, "--%s\r\nContent-Type: %s\r\nContent-Transfer-Encoding: binary\r\nContent-ID: %s\r\n\r\n", soap->mime.boundary, s, soap->mime.start);
15349 #endif
15350 n = strlen(soap->tmpbuf);
15351 if (soap_send_raw(soap, soap->tmpbuf, n))
15352 return soap->error;
15353 }
15354 if (soap->mode & SOAP_IO_LENGTH)
15355 soap->dime.size = soap->count; /* DIME in MIME correction */
15356 if (!(soap->mode & SOAP_IO_LENGTH) && (soap->mode & SOAP_ENC_DIME))
15357 { if (soap_putdimehdr(soap))
15358 return soap->error;
15359 }
15360 #endif
15361 if (soap->version == 0)
15362 return SOAP_OK;
15363 soap->part = SOAP_IN_ENVELOPE;
15364 return soap_element_begin_out(soap, "SOAP-ENV:Envelope", 0, NULL);
15365 }
15366 #endif
15367
15368 /******************************************************************************/
15369 #ifndef PALM_2
15370 SOAP_FMAC1
15371 int
15372 SOAP_FMAC2
15373 soap_envelope_end_out(struct soap *soap)
15374 { if (soap->version == 0)
15375 return SOAP_OK;
15376 if (soap_element_end_out(soap, "SOAP-ENV:Envelope")
15377 || soap_send_raw(soap, "\r\n", 2)) /* 2.8: always emit \r\n */
15378 return soap->error;
15379 #ifndef WITH_LEANER
15380 if ((soap->mode & SOAP_IO_LENGTH) && (soap->mode & SOAP_ENC_DIME) && !(soap->mode & SOAP_ENC_MTOM))
15381 { soap->dime.size = soap->count - soap->dime.size; /* DIME in MIME correction */
15382 #ifdef HAVE_SNPRINTF
15383 soap_snprintf(soap->id, sizeof(soap->id), soap->dime_id_format, 0);
15384 #else
15385 sprintf(soap->id, soap->dime_id_format, 0);
15386 #endif
15387 soap->dime.id = soap->id;
15388 if (soap->local_namespaces)
15389 { if (soap->local_namespaces[0].out)
15390 soap->dime.type = (char*)soap->local_namespaces[0].out;
15391 else
15392 soap->dime.type = (char*)soap->local_namespaces[0].ns;
15393 }
15394 soap->dime.options = NULL;
15395 soap->dime.flags = SOAP_DIME_MB | SOAP_DIME_ABSURI;
15396 if (!soap->dime.first)
15397 soap->dime.flags |= SOAP_DIME_ME;
15398 soap->count += 12 + ((strlen(soap->dime.id)+3)&(~3)) + (soap->dime.type ? ((strlen(soap->dime.type)+3)&(~3)) : 0);
15399 }
15400 if ((soap->mode & SOAP_ENC_DIME) && !(soap->mode & SOAP_ENC_MTOM))
15401 return soap_send_raw(soap, SOAP_STR_PADDING, -(long)soap->dime.size&3);
15402 #endif
15403 soap->part = SOAP_END_ENVELOPE;
15404 return SOAP_OK;
15405 }
15406 #endif
15407
15408 /******************************************************************************/
15409 #ifndef WITH_LEAN
15410 #ifndef PALM_1
15411 SOAP_FMAC1
15412 char*
15413 SOAP_FMAC2
15414 soap_get_http_body(struct soap *soap, size_t *len)
15415 { if (len)
15416 *len = 0;
15417 #ifndef WITH_LEAN
15418 register size_t l = 0, n = 0;
15419 register char *s;
15420 /* get HTTP body length */
15421 if (!(soap->mode & SOAP_ENC_ZLIB) && (soap->mode & SOAP_IO) != SOAP_IO_CHUNK)
15422 { n = soap->length;
15423 if (!n)
15424 return NULL;
15425 }
15426 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Parsing HTTP body (mode=0x%x,len=%lu)\n", soap->mode, (unsigned long)n));
15427 #ifdef WITH_FAST
15428 soap->labidx = 0; /* use look-aside buffer */
15429 #else
15430 if (soap_new_block(soap) == NULL)
15431 return NULL;
15432 #endif
15433 for (;;)
15434 {
15435 #ifdef WITH_FAST
15436 register size_t i, k;
15437 if (soap_append_lab(soap, NULL, 0)) /* allocate more space in look-aside buffer if necessary */
15438 return NULL;
15439 s = soap->labbuf + soap->labidx; /* space to populate */
15440 k = soap->lablen - soap->labidx; /* number of bytes available */
15441 soap->labidx = soap->lablen; /* claim this space */
15442 #else
15443 register size_t i, k = SOAP_BLKLEN;
15444 if (!(s = (char*)soap_push_block(soap, NULL, k)))
15445 return NULL;
15446 #endif
15447 for (i = 0; i < k; i++)
15448 { register soap_wchar c;
15449 l++;
15450 if (n > 0 && l > n)
15451 goto end;
15452 c = soap_get1(soap);
15453 if ((int)c == EOF)
15454 goto end;
15455 *s++ = (char)(c & 0xFF);
15456 }
15457 }
15458 end:
15459 *s = '\0';
15460 if (len)
15461 *len = l - 1; /* len excludes terminating \0 */
15462 #ifdef WITH_FAST
15463 if ((s = (char*)soap_malloc(soap, l)))
15464 memcpy(s, soap->labbuf, l);
15465 #else
15466 soap_size_block(soap, NULL, i+1);
15467 s = soap_save_block(soap, NULL, 0);
15468 #endif
15469 return s;
15470 #else
15471 return NULL;
15472 #endif
15473 }
15474 #endif
15475 #endif
15476
15477 /******************************************************************************/
15478 #ifndef PALM_1
15479 SOAP_FMAC1
15480 int
15481 SOAP_FMAC2
15482 soap_envelope_begin_in(struct soap *soap)
15483 { register struct Namespace *p;
15484 soap->part = SOAP_IN_ENVELOPE;
15485 if (soap_element_begin_in(soap, "SOAP-ENV:Envelope", 0, NULL))
15486 { if (soap->error == SOAP_TAG_MISMATCH)
15487 { if (!soap_element_begin_in(soap, "Envelope", 0, NULL))
15488 soap->error = SOAP_VERSIONMISMATCH;
15489 else if (soap->status == 0 || (soap->status >= 200 && soap->status <= 299))
15490 return SOAP_OK; /* allow non-SOAP XML content to be captured */
15491 soap->error = soap->status;
15492 }
15493 else if (soap->status)
15494 soap->error = soap->status;
15495 return soap->error;
15496 }
15497 p = soap->local_namespaces;
15498 if (p)
15499 { const char *ns = p[0].out;
15500 if (!ns)
15501 ns = p[0].ns;
15502 if (!strcmp(ns, soap_env1))
15503 { soap->version = 1; /* make sure we use SOAP 1.1 */
15504 if (p[1].out)
15505 SOAP_FREE(soap, p[1].out);
15506 if ((p[1].out = (char*)SOAP_MALLOC(soap, sizeof(soap_enc1))))
15507 strcpy(p[1].out, soap_enc1);
15508 }
15509 else if (!strcmp(ns, soap_env2))
15510 { soap->version = 2; /* make sure we use SOAP 1.2 */
15511 if (p[1].out)
15512 SOAP_FREE(soap, p[1].out);
15513 if ((p[1].out = (char*)SOAP_MALLOC(soap, sizeof(soap_enc2))))
15514 strcpy(p[1].out, soap_enc2);
15515 }
15516 }
15517 return SOAP_OK;
15518 }
15519 #endif
15520
15521 /******************************************************************************/
15522 #ifndef PALM_1
15523 SOAP_FMAC1
15524 int
15525 SOAP_FMAC2
15526 soap_envelope_end_in(struct soap *soap)
15527 { if (soap->version == 0)
15528 return SOAP_OK;
15529 soap->part = SOAP_END_ENVELOPE;
15530 return soap_element_end_in(soap, "SOAP-ENV:Envelope");
15531 }
15532 #endif
15533
15534 /******************************************************************************/
15535 #ifndef PALM_2
15536 SOAP_FMAC1
15537 int
15538 SOAP_FMAC2
15539 soap_body_begin_out(struct soap *soap)
15540 { if (soap->version == 1)
15541 soap->encoding = 1;
15542 #ifndef WITH_LEAN
15543 if ((soap->mode & SOAP_SEC_WSUID) && soap_set_attr(soap, "wsu:Id", "Body", 1))
15544 return soap->error;
15545 #endif
15546 if (soap->version == 0)
15547 return SOAP_OK;
15548 soap->part = SOAP_IN_BODY;
15549 return soap_element_begin_out(soap, "SOAP-ENV:Body", 0, NULL);
15550 }
15551 #endif
15552
15553 /******************************************************************************/
15554 #ifndef PALM_2
15555 SOAP_FMAC1
15556 int
15557 SOAP_FMAC2
15558 soap_body_end_out(struct soap *soap)
15559 { if (soap->version == 0)
15560 return SOAP_OK;
15561 if (soap_element_end_out(soap, "SOAP-ENV:Body"))
15562 return soap->error;
15563 soap->part = SOAP_END_BODY;
15564 return SOAP_OK;
15565 }
15566 #endif
15567
15568 /******************************************************************************/
15569 #ifndef PALM_2
15570 SOAP_FMAC1
15571 int
15572 SOAP_FMAC2
15573 soap_body_begin_in(struct soap *soap)
15574 { if (soap->version == 0)
15575 return SOAP_OK;
15576 soap->part = SOAP_IN_BODY;
15577 if (soap_element_begin_in(soap, "SOAP-ENV:Body", 0, NULL))
15578 return soap->error;
15579 if (!soap->body)
15580 soap->part = SOAP_NO_BODY;
15581 return SOAP_OK;
15582 }
15583 #endif
15584
15585 /******************************************************************************/
15586 #ifndef PALM_2
15587 SOAP_FMAC1
15588 int
15589 SOAP_FMAC2
15590 soap_body_end_in(struct soap *soap)
15591 { if (soap->version == 0)
15592 return SOAP_OK;
15593 if (soap->part == SOAP_NO_BODY)
15594 return soap->error = SOAP_OK;
15595 soap->part = SOAP_END_BODY;
15596 return soap_element_end_in(soap, "SOAP-ENV:Body");
15597 }
15598 #endif
15599
15600 /******************************************************************************/
15601 #ifndef PALM_2
15602 SOAP_FMAC1
15603 int
15604 SOAP_FMAC2
15605 soap_recv_header(struct soap *soap)
15606 { if (soap_getheader(soap) && soap->error == SOAP_TAG_MISMATCH)
15607 soap->error = SOAP_OK;
15608 if (soap->error == SOAP_OK && soap->fheader)
15609 soap->error = soap->fheader(soap);
15610 return soap->error;
15611 }
15612 #endif
15613
15614 /******************************************************************************/
15615 #ifndef PALM_1
15616 SOAP_FMAC1
15617 void
15618 SOAP_FMAC2
15619 soap_set_endpoint(struct soap *soap, const char *endpoint)
15620 { register const char *s;
15621 register size_t i, n;
15622 soap->endpoint[0] = '\0';
15623 soap->host[0] = '\0';
15624 soap->path[0] = '/';
15625 soap->path[1] = '\0';
15626 soap->port = 80;
15627 if (!endpoint || !*endpoint)
15628 return;
15629 #ifdef WITH_OPENSSL
15630 if (!soap_tag_cmp(endpoint, "https:*"))
15631 soap->port = 443;
15632 #endif
15633 strncpy(soap->endpoint, endpoint, sizeof(soap->endpoint));
15634 soap->endpoint[sizeof(soap->endpoint) - 1] = '\0';
15635 s = strchr(endpoint, ':');
15636 if (s && s[1] == '/' && s[2] == '/')
15637 s += 3;
15638 else
15639 s = endpoint;
15640 n = strlen(s);
15641 if (n >= sizeof(soap->host))
15642 n = sizeof(soap->host) - 1;
15643 #ifdef WITH_IPV6
15644 if (s[0] == '[')
15645 { s++;
15646 for (i = 0; i < n; i++)
15647 { if (s[i] == ']')
15648 { s++;
15649 --n;
15650 break;
15651 }
15652 soap->host[i] = s[i];
15653 }
15654 }
15655 else
15656 { for (i = 0; i < n; i++)
15657 { soap->host[i] = s[i];
15658 if (s[i] == '/' || s[i] == ':')
15659 break;
15660 }
15661 }
15662 #else
15663 for (i = 0; i < n; i++)
15664 { soap->host[i] = s[i];
15665 if (s[i] == '/' || s[i] == ':')
15666 break;
15667 }
15668 #endif
15669 soap->host[i] = '\0';
15670 if (s[i] == ':')
15671 { soap->port = (int)soap_strtol(s + i + 1, NULL, 10);
15672 for (i++; i < n; i++)
15673 if (s[i] == '/')
15674 break;
15675 }
15676 if (i < n && s[i])
15677 { strncpy(soap->path, s + i, sizeof(soap->path));
15678 soap->path[sizeof(soap->path) - 1] = '\0';
15679 }
15680 }
15681 #endif
15682
15683 /******************************************************************************/
15684 #ifndef PALM_1
15685 SOAP_FMAC1
15686 int
15687 SOAP_FMAC2
15688 soap_connect(struct soap *soap, const char *endpoint, const char *action)
15689 { return soap_connect_command(soap, SOAP_POST, endpoint, action);
15690 }
15691 #endif
15692
15693 /******************************************************************************/
15694 #ifndef PALM_1
15695 SOAP_FMAC1
15696 int
15697 SOAP_FMAC2
15698 soap_connect_command(struct soap *soap, int http_command, const char *endpoints, const char *action)
15699 { char *endpoint;
15700 const char *s;
15701 if (endpoints && (s = strchr(endpoints, ' ')))
15702 { endpoint = (char*)SOAP_MALLOC(soap, strlen(endpoints) + 1);
15703 for (;;)
15704 { strncpy(endpoint, endpoints, s - endpoints);
15705 endpoint[s - endpoints] = '\0';
15706 if (soap_try_connect_command(soap, http_command, endpoint, action) != SOAP_TCP_ERROR)
15707 break;
15708 if (!*s)
15709 break;
15710 soap->error = SOAP_OK;
15711 while (*s == ' ')
15712 s++;
15713 endpoints = s;
15714 s = strchr(endpoints, ' ');
15715 if (!s)
15716 s = endpoints + strlen(endpoints);
15717 }
15718 SOAP_FREE(soap, endpoint);
15719 }
15720 else
15721 soap_try_connect_command(soap, http_command, endpoints, action);
15722 return soap->error;
15723 }
15724 #endif
15725
15726 /******************************************************************************/
15727 #ifndef PALM_1
15728 static int
15729 soap_try_connect_command(struct soap *soap, int http_command, const char *endpoint, const char *action)
15730 { char host[sizeof(soap->host)];
15731 int port;
15732 size_t count;
15733 soap->error = SOAP_OK;
15734 strcpy(host, soap->host); /* save previous host name: if != then reconnect */
15735 port = soap->port; /* save previous port to compare */
15736 soap->status = http_command;
15737 soap_set_endpoint(soap, endpoint);
15738 #ifndef WITH_LEANER
15739 if (soap->fconnect)
15740 { if ((soap->error = soap->fconnect(soap, endpoint, soap->host, soap->port)))
15741 return soap->error;
15742 }
15743 else
15744 #endif
15745 soap->action = soap_strdup(soap, action);
15746 if (soap->fopen && *soap->host)
15747 { if (!soap->keep_alive || !soap_valid_socket(soap->socket) || strcmp(soap->host, host) || soap->port != port || !soap->fpoll || soap->fpoll(soap))
15748 { soap->error = SOAP_OK;
15749 #ifndef WITH_LEAN
15750 if (!strncmp(endpoint, "soap.udp:", 9))
15751 soap->omode |= SOAP_IO_UDP;
15752 else
15753 #endif
15754 { soap->keep_alive = 0; /* to force close */
15755 soap->omode &= ~SOAP_IO_UDP; /* to force close */
15756 }
15757 soap_closesock(soap);
15758 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Connect/reconnect to '%s' host='%s' path='%s' port=%d\n", endpoint?endpoint:"(null)", soap->host, soap->path, soap->port));
15759 if (!soap->keep_alive || !soap_valid_socket(soap->socket))
15760 { soap->socket = soap->fopen(soap, endpoint, soap->host, soap->port);
15761 if (soap->error)
15762 return soap->error;
15763 soap->keep_alive = ((soap->omode & SOAP_IO_KEEPALIVE) != 0);
15764 }
15765 }
15766 }
15767 #ifdef WITH_NTLM
15768 if (soap_ntlm_handshake(soap, SOAP_GET, endpoint, soap->host, soap->port))
15769 return soap->error;
15770 #endif
15771 count = soap_count_attachments(soap);
15772 if (soap_begin_send(soap))
15773 return soap->error;
15774 if (http_command == SOAP_GET)
15775 { soap->mode &= ~SOAP_IO;
15776 soap->mode |= SOAP_IO_BUFFER;
15777 }
15778 #ifndef WITH_NOHTTP
15779 if ((soap->mode & SOAP_IO) != SOAP_IO_STORE && !(soap->mode & SOAP_ENC_XML) && endpoint)
15780 { unsigned int k = soap->mode;
15781 soap->mode &= ~(SOAP_IO | SOAP_ENC_ZLIB);
15782 if ((k & SOAP_IO) != SOAP_IO_FLUSH)
15783 soap->mode |= SOAP_IO_BUFFER;
15784 if ((soap->error = soap->fpost(soap, endpoint, soap->host, soap->port, soap->path, action, count)))
15785 return soap->error;
15786 #ifndef WITH_LEANER
15787 if ((k & SOAP_IO) == SOAP_IO_CHUNK)
15788 { if (soap_flush(soap))
15789 return soap->error;
15790 }
15791 #endif
15792 soap->mode = k;
15793 }
15794 if (http_command == SOAP_GET || http_command == SOAP_DEL)
15795 return soap_end_send_flush(soap);
15796 #endif
15797 return SOAP_OK;
15798 }
15799 #endif
15800
15801 /******************************************************************************/
15802 #ifdef WITH_NTLM
15803 #ifndef PALM_1
15804 static int
15805 soap_ntlm_handshake(struct soap *soap, int command, const char *endpoint, const char *host, int port)
15806 { /* requires libntlm from http://www.nongnu.org/libntlm/ */
15807 const char *userid = (soap->proxy_userid ? soap->proxy_userid : soap->userid);
15808 const char *passwd = (soap->proxy_passwd ? soap->proxy_passwd : soap->passwd);
15809 struct SOAP_ENV__Header *oldheader;
15810 if (soap->ntlm_challenge && userid && passwd && soap->authrealm)
15811 { tSmbNtlmAuthRequest req;
15812 tSmbNtlmAuthResponse res;
15813 tSmbNtlmAuthChallenge ch;
15814 short k = soap->keep_alive;
15815 size_t l = soap->length;
15816 size_t c = soap->count;
15817 soap_mode m = soap->mode, o = soap->omode;
15818 int s = soap->status;
15819 char *a = soap->action;
15820 short v = soap->version;
15821 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "NTLM '%s'\n", soap->ntlm_challenge));
15822 if (!*soap->ntlm_challenge)
15823 { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "NTLM S->C Type 1: received NTLM authentication challenge from server\n"));
15824 /* S -> C 401 Unauthorized
15825 WWW-Authenticate: NTLM
15826 */
15827 buildSmbNtlmAuthRequest(&req, userid, soap->authrealm);
15828 soap->ntlm_challenge = soap_s2base64(soap, (unsigned char*)&req, NULL, SmbLength(&req));
15829 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "NTLM C->S Type 2: sending NTLM authorization to server\nAuthorization: NTLM %s\n", soap->ntlm_challenge));
15830 /* C -> S GET ...
15831 Authorization: NTLM TlRMTVNTUAABAAAAA7IAAAoACgApAAAACQAJACAAAABMSUdIVENJVFlVUlNBLU1JTk9S
15832 */
15833 soap->omode = SOAP_IO_BUFFER;
15834 if (soap_begin_send(soap))
15835 return soap->error;
15836 soap->keep_alive = 1;
15837 soap->status = command;
15838 if (soap->fpost(soap, endpoint, host, port, soap->path, soap->action, 0)
15839 || soap_end_send_flush(soap))
15840 return soap->error;
15841 soap->mode = m;
15842 soap->keep_alive = k;
15843 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "NTLM S->C Type 2: waiting on server NTLM response\n"));
15844 oldheader = soap->header;
15845 if (soap_begin_recv(soap))
15846 if (soap->error == SOAP_EOF)
15847 return soap->error;
15848 soap_end_recv(soap);
15849 soap->header = oldheader;
15850 soap->length = l;
15851 if (soap->status != 401 && soap->status != 407)
15852 return soap->error = SOAP_NTLM_ERROR;
15853 soap->error = SOAP_OK;
15854 }
15855 /* S -> C 401 Unauthorized
15856 WWW-Authenticate: NTLM TlRMTVNTUAACAAAAAAAAACgAAAABggAAU3J2Tm9uY2UAAAAAAAAAAA==
15857 */
15858 soap_base642s(soap, soap->ntlm_challenge, (char*)&ch, sizeof(tSmbNtlmAuthChallenge), NULL);
15859 buildSmbNtlmAuthResponse(&ch, &res, userid, passwd);
15860 soap->ntlm_challenge = soap_s2base64(soap, (unsigned char*)&res, NULL, SmbLength(&res));
15861 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "NTLM C->S Type 3: sending NTLM authorization to server\nAuthorization: NTLM %s\n", soap->ntlm_challenge));
15862 /* C -> S GET ...
15863 Authorization: NTLM TlRMTVNTUAADAAAAGAAYAHIAAAAYABgAigAAABQAFABAAAAADAAMAFQAAAASABIAYAAAAAAAAACiAAAAAYIAAFUAUgBTAEEALQBNAEkATgBPAFIAWgBhAHAAaABvAGQATABJAEcASABUAEMASQBUAFkArYfKbe/jRoW5xDxHeoxC1gBmfWiS5+iX4OAN4xBKG/IFPwfH3agtPEia6YnhsADT
15864 */
15865 soap->userid = NULL;
15866 soap->passwd = NULL;
15867 soap->proxy_userid = NULL;
15868 soap->proxy_passwd = NULL;
15869 soap->keep_alive = k;
15870 soap->length = l;
15871 soap->count = c;
15872 soap->mode = m;
15873 soap->omode = o;
15874 soap->status = s;
15875 soap->action = a;
15876 soap->version = v;
15877 }
15878 return SOAP_OK;
15879 }
15880 #endif
15881 #endif
15882
15883 /******************************************************************************/
15884 #ifndef WITH_LEAN
15885 SOAP_FMAC1
15886 char*
15887 SOAP_FMAC2
15888 soap_s2base64(struct soap *soap, const unsigned char *s, char *t, int n)
15889 { register int i;
15890 register unsigned long m;
15891 register char *p;
15892 if (!t)
15893 t = (char*)soap_malloc(soap, (n + 2) / 3 * 4 + 1);
15894 if (!t)
15895 return NULL;
15896 p = t;
15897 t[0] = '\0';
15898 if (!s)
15899 return p;
15900 for (; n > 2; n -= 3, s += 3)
15901 { m = s[0];
15902 m = (m << 8) | s[1];
15903 m = (m << 8) | s[2];
15904 for (i = 4; i > 0; m >>= 6)
15905 t[--i] = soap_base64o[m & 0x3F];
15906 t += 4;
15907 }
15908 t[0] = '\0';
15909 if (n > 0) /* 0 < n <= 2 implies that t[0..4] is allocated (base64 scaling formula) */
15910 { m = 0;
15911 for (i = 0; i < n; i++)
15912 m = (m << 8) | *s++;
15913 for (; i < 3; i++)
15914 m <<= 8;
15915 for (i = 4; i > 0; m >>= 6)
15916 t[--i] = soap_base64o[m & 0x3F];
15917 for (i = 3; i > n; i--)
15918 t[i] = '=';
15919 t[4] = '\0';
15920 }
15921 return p;
15922 }
15923 #endif
15924
15925 /******************************************************************************/
15926 #ifndef WITH_LEAN
15927 SOAP_FMAC1
15928 const char*
15929 SOAP_FMAC2
15930 soap_base642s(struct soap *soap, const char *s, char *t, size_t l, int *n)
15931 { register size_t i, j;
15932 register soap_wchar c;
15933 register unsigned long m;
15934 register const char *p;
15935 if (!s || !*s)
15936 { if (n)
15937 *n = 0;
15938 if (soap->error)
15939 return NULL;
15940 return SOAP_NON_NULL;
15941 }
15942 if (!t)
15943 { l = (strlen(s) + 3) / 4 * 3 + 1; /* make sure enough space for \0 */
15944 t = (char*)soap_malloc(soap, l);
15945 }
15946 if (!t)
15947 return NULL;
15948 p = t;
15949 if (n)
15950 *n = 0;
15951 for (i = 0; ; i += 3, l -= 3)
15952 { m = 0;
15953 j = 0;
15954 while (j < 4)
15955 { c = *s++;
15956 if (c == '=' || !c)
15957 { if (l >= j - 1)
15958 { switch (j)
15959 { case 2:
15960 *t++ = (char)((m >> 4) & 0xFF);
15961 i++;
15962 l--;
15963 break;
15964 case 3:
15965 *t++ = (char)((m >> 10) & 0xFF);
15966 *t++ = (char)((m >> 2) & 0xFF);
15967 i += 2;
15968 l -= 2;
15969 }
15970 }
15971 if (n)
15972 *n = (int)i;
15973 if (l)
15974 *t = '\0';
15975 return p;
15976 }
15977 c -= '+';
15978 if (c >= 0 && c <= 79)
15979 { int b = soap_base64i[c];
15980 if (b >= 64)
15981 { soap->error = SOAP_TYPE;
15982 return NULL;
15983 }
15984 m = (m << 6) + b;
15985 j++;
15986 }
15987 else if (!soap_blank(c + '+'))
15988 { soap->error = SOAP_TYPE;
15989 return NULL;
15990 }
15991 }
15992 if (l < 3)
15993 { if (n)
15994 *n = (int)i;
15995 if (l)
15996 *t = '\0';
15997 return p;
15998 }
15999 *t++ = (char)((m >> 16) & 0xFF);
16000 *t++ = (char)((m >> 8) & 0xFF);
16001 *t++ = (char)(m & 0xFF);
16002 }
16003 }
16004 #endif
16005
16006 /******************************************************************************/
16007 #ifndef WITH_LEAN
16008 SOAP_FMAC1
16009 char*
16010 SOAP_FMAC2
16011 soap_s2hex(struct soap *soap, const unsigned char *s, char *t, int n)
16012 { register char *p;
16013 if (!t)
16014 t = (char*)soap_malloc(soap, 2 * n + 1);
16015 if (!t)
16016 return NULL;
16017 p = t;
16018 t[0] = '\0';
16019 if (s)
16020 { for (; n > 0; n--)
16021 { register int m = *s++;
16022 *t++ = (char)((m >> 4) + (m > 159 ? 'a' - 10 : '0'));
16023 m &= 0x0F;
16024 *t++ = (char)(m + (m > 9 ? 'a' - 10 : '0'));
16025 }
16026 }
16027 *t++ = '\0';
16028 return p;
16029 }
16030 #endif
16031
16032 /******************************************************************************/
16033 #ifndef WITH_LEAN
16034 SOAP_FMAC1
16035 const char*
16036 SOAP_FMAC2
16037 soap_hex2s(struct soap *soap, const char *s, char *t, size_t l, int *n)
16038 { register const char *p;
16039 if (!s || !*s)
16040 { if (n)
16041 *n = 0;
16042 if (soap->error)
16043 return NULL;
16044 return SOAP_NON_NULL;
16045 }
16046 if (!t)
16047 { l = strlen(s) / 2 + 1; /* make sure enough space for \0 */
16048 t = (char*)soap_malloc(soap, l);
16049 }
16050 if (!t)
16051 return NULL;
16052 p = t;
16053 while (l)
16054 { register int d1, d2;
16055 d1 = *s++;
16056 if (!d1)
16057 break;
16058 d2 = *s++;
16059 if (!d2)
16060 break;
16061 *t++ = (char)(((d1 >= 'A' ? (d1 & 0x7) + 9 : d1 - '0') << 4) + (d2 >= 'A' ? (d2 & 0x7) + 9 : d2 - '0'));
16062 l--;
16063 }
16064 if (n)
16065 *n = (int)(t - p);
16066 if (l)
16067 *t = '\0';
16068 return p;
16069 }
16070 #endif
16071
16072 /******************************************************************************/
16073 #ifndef WITH_NOHTTP
16074 #ifndef PALM_1
16075 SOAP_FMAC1
16076 int
16077 SOAP_FMAC2
16078 soap_puthttphdr(struct soap *soap, int status, size_t count)
16079 { if (soap->status != SOAP_GET && soap->status != SOAP_DEL && soap->status != SOAP_CONNECT)
16080 { register const char *s = "text/xml; charset=utf-8";
16081 register int err = SOAP_OK;
16082 #ifndef WITH_LEANER
16083 register const char *r = NULL;
16084 #endif
16085 if ((status == SOAP_FILE || soap->status == SOAP_PUT || soap->status == SOAP_POST_FILE) && soap->http_content && !strchr(s, 10) && !strchr(s, 13))
16086 s = soap->http_content;
16087 else if (status == SOAP_HTML)
16088 s = "text/html; charset=utf-8";
16089 else if (count || ((soap->omode & SOAP_IO) == SOAP_IO_CHUNK))
16090 { if (soap->version == 2)
16091 s = "application/soap+xml; charset=utf-8";
16092 }
16093 #ifndef WITH_LEANER
16094 if (soap->mode & (SOAP_ENC_DIME | SOAP_ENC_MTOM))
16095 { if (soap->mode & SOAP_ENC_MTOM)
16096 { if (soap->version == 2)
16097 r = "application/soap+xml";
16098 else
16099 r = "text/xml";
16100 s = "application/xop+xml";
16101 }
16102 else
16103 s = "application/dime";
16104 }
16105 if ((soap->mode & SOAP_ENC_MIME) && soap->mime.boundary && strlen(soap->mime.boundary) + strlen(soap->mime.start ? soap->mime.start : SOAP_STR_EOS) < sizeof(soap->tmpbuf) - 80)
16106 { register const char *t;
16107 #ifdef HAVE_SNPRINTF
16108 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), "multipart/related; charset=utf-8; boundary=\"%s\"; type=\"", soap->mime.boundary);
16109 #else
16110 sprintf(soap->tmpbuf, "multipart/related; charset=utf-8; boundary=\"%s\"; type=\"", soap->mime.boundary);
16111 #endif
16112 t = strchr(s, ';');
16113 if (t)
16114 strncat(soap->tmpbuf, s, t - s);
16115 else
16116 strcat(soap->tmpbuf, s);
16117 if (soap->mime.start && strlen(soap->tmpbuf) + strlen(soap->mime.start) + 11 < sizeof(soap->tmpbuf))
16118 { strcat(soap->tmpbuf, "\"; start=\"");
16119 strcat(soap->tmpbuf, soap->mime.start);
16120 }
16121 strcat(soap->tmpbuf, "\"");
16122 if (r && strlen(soap->tmpbuf) + strlen(r) + 15 < sizeof(soap->tmpbuf))
16123 { strcat(soap->tmpbuf, "; start-info=\"");
16124 strcat(soap->tmpbuf, r);
16125 strcat(soap->tmpbuf, "\"");
16126 }
16127 }
16128 else
16129 strncpy(soap->tmpbuf, s, sizeof(soap->tmpbuf));
16130 soap->tmpbuf[sizeof(soap->tmpbuf) - 1] = '\0';
16131 s = soap->tmpbuf;
16132 if (status == SOAP_OK && soap->version == 2 && soap->action && strlen(soap->action) + strlen(s) < sizeof(soap->tmpbuf) - 80)
16133 {
16134 #ifdef HAVE_SNPRINTF
16135 size_t l = strlen(s);
16136 soap_snprintf(soap->tmpbuf + l, sizeof(soap->tmpbuf) - l, "; action=\"%s\"", soap->action);
16137 #else
16138 sprintf(soap->tmpbuf + strlen(s), "; action=\"%s\"", soap->action);
16139 #endif
16140 }
16141 #endif
16142 if ((err = soap->fposthdr(soap, "Content-Type", s)))
16143 return err;
16144 #ifdef WITH_ZLIB
16145 if ((soap->omode & SOAP_ENC_ZLIB))
16146 {
16147 #ifdef WITH_GZIP
16148 err = soap->fposthdr(soap, "Content-Encoding", soap->zlib_out == SOAP_ZLIB_DEFLATE ? "deflate" : "gzip");
16149 #else
16150 err = soap->fposthdr(soap, "Content-Encoding", "deflate");
16151 #endif
16152 if (err)
16153 return err;
16154 }
16155 #endif
16156 #ifndef WITH_LEANER
16157 if ((soap->omode & SOAP_IO) == SOAP_IO_CHUNK)
16158 err = soap->fposthdr(soap, "Transfer-Encoding", "chunked");
16159 else
16160 #endif
16161 if (s)
16162 {
16163 #ifdef HAVE_SNPRINTF
16164 soap_snprintf(soap->tmpbuf, sizeof(soap->tmpbuf), "%lu", (unsigned long)count);
16165 #else
16166 sprintf(soap->tmpbuf, "%lu", (unsigned long)count);
16167 #endif
16168 err = soap->fposthdr(soap, "Content-Length", soap->tmpbuf);
16169 }
16170 if (err)
16171 return err;
16172 }
16173 return soap->fposthdr(soap, "Connection", soap->keep_alive ? "keep-alive" : "close");
16174 }
16175 #endif
16176 #endif
16177
16178 /******************************************************************************/
16179 #ifndef WITH_LEAN
16180 static const char*
16181 soap_set_validation_fault(struct soap *soap, const char *s, const char *t)
16182 { if (!t)
16183 t = SOAP_STR_EOS;
16184 if (*soap->tag)
16185 {
16186 #ifdef HAVE_SNPRINTF
16187 soap_snprintf(soap->msgbuf, sizeof(soap->msgbuf), "Validation constraint violation: %s%s in element '%s'", s, t ? t : SOAP_STR_EOS, soap->tag);
16188 #else
16189 if (strlen(soap->tag) + strlen(t) < sizeof(soap->msgbuf) - 100)
16190 sprintf(soap->msgbuf, "Validation constraint violation: %s%s in element '%s'", s, t, soap->tag);
16191 else
16192 sprintf(soap->msgbuf, "Validation constraint violation: %s", s);
16193 #endif
16194 }
16195 else
16196 {
16197 #ifdef HAVE_SNPRINTF
16198 soap_snprintf(soap->msgbuf, sizeof(soap->msgbuf), "Validation constraint violation: %s%s", s, t ? t : SOAP_STR_EOS);
16199 #else
16200 if (strlen(soap->tag) + strlen(t) < sizeof(soap->msgbuf) - 100)
16201 sprintf(soap->msgbuf, "Validation constraint violation: %s%s", s, t);
16202 else
16203 sprintf(soap->msgbuf, "Validation constraint violation: %s", s);
16204 #endif
16205 }
16206 return soap->msgbuf;
16207 }
16208 #endif
16209
16210 /******************************************************************************/
16211 #ifndef PALM_1
16212 SOAP_FMAC1
16213 void
16214 SOAP_FMAC2
16215 soap_set_fault(struct soap *soap)
16216 { const char **c = soap_faultcode(soap);
16217 const char **s = soap_faultstring(soap);
16218 if (soap->fseterror)
16219 soap->fseterror(soap, c, s);
16220 if (!*c)
16221 { if (soap->version == 2)
16222 *c = "SOAP-ENV:Sender";
16223 else
16224 *c = "SOAP-ENV:Client";
16225 }
16226 if (*s)
16227 return;
16228 switch (soap->error)
16229 {
16230 #ifndef WITH_LEAN
16231 case SOAP_CLI_FAULT:
16232 *s = "Client fault";
16233 break;
16234 case SOAP_SVR_FAULT:
16235 *s = "Server fault";
16236 break;
16237 case SOAP_TAG_MISMATCH:
16238 *s = soap_set_validation_fault(soap, "tag name or namespace mismatch", NULL);
16239 break;
16240 case SOAP_TYPE:
16241 *s = soap_set_validation_fault(soap, "data type mismatch ", soap->type);
16242 break;
16243 case SOAP_SYNTAX_ERROR:
16244 *s = "Well-formedness violation";
16245 break;
16246 case SOAP_NO_TAG:
16247 *s = "No tag: no XML root element or missing SOAP message body element";
16248 break;
16249 case SOAP_MUSTUNDERSTAND:
16250 *c = "SOAP-ENV:MustUnderstand";
16251 #ifdef HAVE_SNPRINTF
16252 soap_snprintf(soap->msgbuf, sizeof(soap->msgbuf), "The data in element '%s' must be understood but cannot be handled", soap->tag);
16253 #else
16254 strncpy(soap->msgbuf, soap->tag, sizeof(soap->msgbuf));
16255 soap->msgbuf[sizeof(soap->msgbuf) - 1] = '\0';
16256 #endif
16257 *s = soap->msgbuf;
16258 break;
16259 case SOAP_VERSIONMISMATCH:
16260 *c = "SOAP-ENV:VersionMismatch";
16261 *s = "Invalid SOAP message or SOAP version mismatch";
16262 break;
16263 case SOAP_DATAENCODINGUNKNOWN:
16264 *c = "SOAP-ENV:DataEncodingUnknown";
16265 *s = "Unsupported SOAP data encoding";
16266 break;
16267 case SOAP_NAMESPACE:
16268 *s = soap_set_validation_fault(soap, "namespace error", NULL);
16269 break;
16270 case SOAP_USER_ERROR:
16271 *s = "User data error";
16272 break;
16273 case SOAP_FATAL_ERROR:
16274 *s = "Fatal error";
16275 break;
16276 case SOAP_NO_METHOD:
16277 #ifdef HAVE_SNPRINTF
16278 soap_snprintf(soap->msgbuf, sizeof(soap->msgbuf), "Method '%s' not implemented: method name or namespace not recognized", soap->tag);
16279 #else
16280 sprintf(soap->msgbuf, "Method '%s' not implemented: method name or namespace not recognized", soap->tag);
16281 #endif
16282 *s = soap->msgbuf;
16283 break;
16284 case SOAP_NO_DATA:
16285 *s = "Data required for operation";
16286 break;
16287 case SOAP_GET_METHOD:
16288 *s = "HTTP GET method not implemented";
16289 break;
16290 case SOAP_PUT_METHOD:
16291 *s = "HTTP PUT method not implemented";
16292 break;
16293 case SOAP_HTTP_METHOD:
16294 *s = "HTTP method not implemented";
16295 break;
16296 case SOAP_EOM:
16297 *s = "Out of memory";
16298 break;
16299 case SOAP_MOE:
16300 *s = "Memory overflow or memory corruption error";
16301 break;
16302 case SOAP_HDR:
16303 *s = "Header line too long";
16304 break;
16305 case SOAP_IOB:
16306 *s = "Array index out of bounds";
16307 break;
16308 case SOAP_NULL:
16309 *s = soap_set_validation_fault(soap, "nil not allowed", NULL);
16310 break;
16311 case SOAP_DUPLICATE_ID:
16312 *s = soap_set_validation_fault(soap, "multiple elements (use the SOAP_XML_TREE flag) with duplicate id ", soap->id);
16313 if (soap->version == 2)
16314 *soap_faultsubcode(soap) = "SOAP-ENC:DuplicateID";
16315 break;
16316 case SOAP_MISSING_ID:
16317 *s = soap_set_validation_fault(soap, "missing id for ref ", soap->id);
16318 if (soap->version == 2)
16319 *soap_faultsubcode(soap) = "SOAP-ENC:MissingID";
16320 break;
16321 case SOAP_HREF:
16322 *s = soap_set_validation_fault(soap, "incompatible object type id-ref ", soap->id);
16323 break;
16324 case SOAP_FAULT:
16325 break;
16326 #ifndef WITH_NOIO
16327 case SOAP_UDP_ERROR:
16328 *s = "Message too large for UDP packet";
16329 break;
16330 case SOAP_TCP_ERROR:
16331 *s = tcp_error(soap);
16332 break;
16333 #endif
16334 case SOAP_HTTP_ERROR:
16335 *s = "An HTTP processing error occurred";
16336 break;
16337 case SOAP_NTLM_ERROR:
16338 *s = "An HTTP NTLM authentication error occurred";
16339 break;
16340 case SOAP_SSL_ERROR:
16341 #ifdef WITH_OPENSSL
16342 *s = "SSL/TLS error";
16343 #else
16344 *s = "OpenSSL not installed: recompile with -DWITH_OPENSSL";
16345 #endif
16346 break;
16347 case SOAP_PLUGIN_ERROR:
16348 *s = "Plugin registry error";
16349 break;
16350 case SOAP_DIME_ERROR:
16351 *s = "DIME format error or max DIME size exceeds SOAP_MAXDIMESIZE";
16352 break;
16353 case SOAP_DIME_HREF:
16354 *s = "DIME href to missing attachment";
16355 break;
16356 case SOAP_DIME_MISMATCH:
16357 *s = "DIME version/transmission error";
16358 break;
16359 case SOAP_DIME_END:
16360 *s = "End of DIME error";
16361 break;
16362 case SOAP_MIME_ERROR:
16363 *s = "MIME format error";
16364 break;
16365 case SOAP_MIME_HREF:
16366 *s = "MIME href to missing attachment";
16367 break;
16368 case SOAP_MIME_END:
16369 *s = "End of MIME error";
16370 break;
16371 case SOAP_ZLIB_ERROR:
16372 #ifdef WITH_ZLIB
16373 #ifdef HAVE_SNPRINTF
16374 soap_snprintf(soap->msgbuf, sizeof(soap->msgbuf), "Zlib/gzip error: '%s'", soap->d_stream->msg ? soap->d_stream->msg : SOAP_STR_EOS);
16375 #else
16376 sprintf(soap->msgbuf, "Zlib/gzip error: '%s'", soap->d_stream->msg ? soap->d_stream->msg : SOAP_STR_EOS);
16377 #endif
16378 *s = soap->msgbuf;
16379 #else
16380 *s = "Zlib/gzip not installed for (de)compression: recompile with -DWITH_GZIP";
16381 #endif
16382 break;
16383 case SOAP_REQUIRED:
16384 *s = soap_set_validation_fault(soap, "missing required attribute", NULL);
16385 break;
16386 case SOAP_PROHIBITED:
16387 *s = soap_set_validation_fault(soap, "prohibited attribute present", NULL);
16388 break;
16389 case SOAP_OCCURS:
16390 *s = soap_set_validation_fault(soap, "occurrence violation", NULL);
16391 break;
16392 case SOAP_LENGTH:
16393 *s = soap_set_validation_fault(soap, "content range or length violation", NULL);
16394 break;
16395 case SOAP_FD_EXCEEDED:
16396 *s = "Maximum number of open connections was reached (no define HAVE_POLL): increase FD_SETSIZE";
16397 break;
16398 case SOAP_UTF_ERROR:
16399 *s = "UTF content encoding error";
16400 break;
16401 case SOAP_STOP:
16402 *s = "Stopped: no response sent or received (informative)";
16403 break;
16404 #endif
16405 case SOAP_EOF:
16406 #ifndef WITH_NOIO
16407 *s = soap_strerror(soap); /* *s = soap->msgbuf */
16408 #ifndef WITH_LEAN
16409 if (strlen(soap->msgbuf) + 25 < sizeof(soap->msgbuf))
16410 { memmove(soap->msgbuf + 25, soap->msgbuf, strlen(soap->msgbuf) + 1);
16411 memcpy(soap->msgbuf, "End of file or no input: ", 25);
16412 }
16413 #endif
16414 break;
16415 #else
16416 *s = "End of file or no input";
16417 break;
16418 #endif
16419 default:
16420 #ifndef WITH_NOHTTP
16421 #ifndef WITH_LEAN
16422 if (soap->error > 200 && soap->error < 600)
16423 {
16424 #ifdef HAVE_SNPRINTF
16425 soap_snprintf(soap->msgbuf, sizeof(soap->msgbuf), "HTTP Error: %d %s", soap->error, http_error(soap, soap->error));
16426 #else
16427 sprintf(soap->msgbuf, "HTTP Error: %d %s", soap->error, http_error(soap, soap->error));
16428 #endif
16429 *s = soap->msgbuf;
16430 }
16431 else
16432 #endif
16433 #endif
16434 {
16435 #ifdef HAVE_SNPRINTF
16436 soap_snprintf(soap->msgbuf, sizeof(soap->msgbuf), "Error %d", soap->error);
16437 #else
16438 sprintf(soap->msgbuf, "Error %d", soap->error);
16439 #endif
16440 *s = soap->msgbuf;
16441 }
16442 }
16443 }
16444 #endif
16445
16446 /******************************************************************************/
16447 #ifndef PALM_1
16448 SOAP_FMAC1
16449 int
16450 SOAP_FMAC2
16451 soap_send_fault(struct soap *soap)
16452 { register int status = soap->error;
16453 if (status == SOAP_OK || status == SOAP_STOP)
16454 return soap_closesock(soap);
16455 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Sending back fault struct for error code %d\n", soap->error));
16456 soap->keep_alive = 0; /* to terminate connection */
16457 soap_set_fault(soap);
16458 if (soap->error < 200 && soap->error != SOAP_FAULT)
16459 soap->header = NULL;
16460 if (status != SOAP_EOF || (!soap->recv_timeout && !soap->send_timeout))
16461 { register int r = 1;
16462 #ifndef WITH_NOIO
16463 if (soap->fpoll && soap->fpoll(soap))
16464 r = 0;
16465 #ifndef WITH_LEAN
16466 else if (soap_valid_socket(soap->socket))
16467 { r = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_SND, 0);
16468 if (r > 0)
16469 { int t;
16470 if (!(r & SOAP_TCP_SELECT_SND)
16471 || ((r & SOAP_TCP_SELECT_RCV)
16472 && recv(soap->socket, (char*)&t, 1, MSG_PEEK) < 0))
16473 r = 0;
16474 }
16475 }
16476 #endif
16477 #endif
16478 if (r > 0)
16479 { soap->error = SOAP_OK;
16480 soap->encodingStyle = NULL; /* no encodingStyle in Faults */
16481 soap_serializeheader(soap);
16482 soap_serializefault(soap);
16483 soap_begin_count(soap);
16484 if (soap->mode & SOAP_IO_LENGTH)
16485 { soap_envelope_begin_out(soap);
16486 soap_putheader(soap);
16487 soap_body_begin_out(soap);
16488 soap_putfault(soap);
16489 soap_body_end_out(soap);
16490 soap_envelope_end_out(soap);
16491 }
16492 soap_end_count(soap);
16493 if (soap_response(soap, status)
16494 || soap_envelope_begin_out(soap)
16495 || soap_putheader(soap)
16496 || soap_body_begin_out(soap)
16497 || soap_putfault(soap)
16498 || soap_body_end_out(soap)
16499 || soap_envelope_end_out(soap))
16500 return soap_closesock(soap);
16501 soap_end_send(soap);
16502 }
16503 }
16504 soap->error = status;
16505 return soap_closesock(soap);
16506 }
16507 #endif
16508
16509 /******************************************************************************/
16510 #ifndef PALM_1
16511 SOAP_FMAC1
16512 int
16513 SOAP_FMAC2
16514 soap_recv_fault(struct soap *soap, int check)
16515 { register int status = soap->error;
16516 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Check if receiving SOAP Fault\n"));
16517 if (!check)
16518 { /* try getfault when no tag or tag mismatched at level 2, otherwise ret */
16519 if (soap->error != SOAP_NO_TAG
16520 && (soap->error != SOAP_TAG_MISMATCH || soap->level != 2))
16521 return soap->error;
16522 }
16523 else if (soap->version == 0) /* check == 1 but no SOAP: do not parse SOAP Fault */
16524 return SOAP_OK;
16525 soap->error = SOAP_OK;
16526 if (soap_getfault(soap))
16527 { /* check flag set: check if SOAP Fault is present, if not just return */
16528 if (check && soap->error == SOAP_TAG_MISMATCH && soap->level == 2)
16529 return soap->error = SOAP_OK;
16530 DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Error: soap_get_soapfault() failed at level %u tag '%s'\n", soap->level, soap->tag));
16531 *soap_faultcode(soap) = (soap->version == 2 ? "SOAP-ENV:Sender" : "SOAP-ENV:Client");
16532 soap->error = status;
16533 soap_set_fault(soap);
16534 }
16535 else
16536 { register const char *s = *soap_faultcode(soap);
16537 if (!soap_match_tag(soap, s, "SOAP-ENV:Server") || !soap_match_tag(soap, s, "SOAP-ENV:Receiver"))
16538 status = SOAP_SVR_FAULT;
16539 else if (!soap_match_tag(soap, s, "SOAP-ENV:Client") || !soap_match_tag(soap, s, "SOAP-ENV:Sender"))
16540 status = SOAP_CLI_FAULT;
16541 else if (!soap_match_tag(soap, s, "SOAP-ENV:MustUnderstand"))
16542 status = SOAP_MUSTUNDERSTAND;
16543 else if (!soap_match_tag(soap, s, "SOAP-ENV:VersionMismatch"))
16544 status = SOAP_VERSIONMISMATCH;
16545 else
16546 { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Received SOAP Fault code %s\n", s));
16547 status = SOAP_FAULT;
16548 }
16549 if (!soap_body_end_in(soap))
16550 soap_envelope_end_in(soap);
16551 }
16552 soap_end_recv(soap);
16553 soap->error = status;
16554 return soap_closesock(soap);
16555 }
16556 #endif
16557
16558 /******************************************************************************/
16559 #ifndef WITH_NOHTTP
16560 #ifndef PALM_1
16561 SOAP_FMAC1
16562 int
16563 SOAP_FMAC2
16564 soap_send_empty_response(struct soap *soap, int httpstatuscode)
16565 { register soap_mode m = soap->omode;
16566 if (!(m & SOAP_IO_UDP))
16567 { soap->count = 0;
16568 if ((m & SOAP_IO) == SOAP_IO_CHUNK)
16569 soap->omode = (m & ~SOAP_IO) | SOAP_IO_BUFFER;
16570 soap_response(soap, httpstatuscode);
16571 soap_end_send(soap); /* force end of sends */
16572 soap->error = SOAP_STOP; /* stops the server (from returning a response) */
16573 soap->omode = m;
16574 }
16575 return soap_closesock(soap);
16576 }
16577 #endif
16578 #endif
16579
16580 /******************************************************************************/
16581 #ifndef WITH_NOHTTP
16582 #ifndef PALM_1
16583 SOAP_FMAC1
16584 int
16585 SOAP_FMAC2
16586 soap_recv_empty_response(struct soap *soap)
16587 { if (!(soap->omode & SOAP_IO_UDP))
16588 { if (!soap_begin_recv(soap))
16589 {
16590 #ifndef WITH_LEAN
16591 if (soap->body)
16592 soap_get_http_body(soap, NULL); /* read (empty?) HTTP body and discard */
16593 #endif
16594 soap_end_recv(soap);
16595 }
16596 else if (soap->error == SOAP_NO_DATA || soap->error == 202)
16597 soap->error = SOAP_OK;
16598 }
16599 return soap_closesock(soap);
16600 }
16601 #endif
16602 #endif
16603
16604 /******************************************************************************/
16605 #ifndef WITH_NOIO
16606 #ifndef PALM_1
16607 static const char*
16608 soap_strerror(struct soap *soap)
16609 { register int err = soap->errnum;
16610 *soap->msgbuf = '\0';
16611 if (err)
16612 {
16613 #ifndef WIN32
16614 # ifdef HAVE_STRERROR_R
16615 # ifdef _GNU_SOURCE
16616 return strerror_r(err, soap->msgbuf, sizeof(soap->msgbuf)); /* GNU-specific */
16617 # else
16618 strerror_r(err, soap->msgbuf, sizeof(soap->msgbuf)); /* XSI-compliant */
16619 # endif
16620 # else
16621 return strerror(err);
16622 # endif
16623 #else
16624 #ifndef UNDER_CE
16625 DWORD len;
16626 *soap->msgbuf = '\0';
16627 len = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)soap->msgbuf, (DWORD)sizeof(soap->msgbuf), NULL);
16628 #else
16629 DWORD i, len;
16630 *soap->msgbuf = '\0';
16631 len = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err, 0, (LPTSTR)soap->msgbuf, (DWORD)(sizeof(soap->msgbuf)/sizeof(TCHAR)), NULL);
16632 for (i = 0; i <= len; i++)
16633 { if (((TCHAR*)soap->msgbuf)[i] < 0x80)
16634 soap->msgbuf[i] = (char)((TCHAR*)soap->msgbuf)[i];
16635 else
16636 soap->msgbuf[i] = '?';
16637 }
16638 #endif
16639 #endif
16640 }
16641 else
16642 { char *s = soap->msgbuf;
16643 #ifndef WITH_LEAN
16644 int rt = soap->recv_timeout, st = soap->send_timeout;
16645 int ru = ' ', su = ' ';
16646 #endif
16647 strcpy(s, "Operation interrupted or timed out");
16648 #ifndef WITH_LEAN
16649 if (rt < 0)
16650 { rt = -rt;
16651 ru = 'u';
16652 }
16653 if (st < 0)
16654 { st = -st;
16655 su = 'u';
16656 }
16657 if (rt)
16658 {
16659 #ifdef HAVE_SNPRINTF
16660 size_t l = strlen(s);
16661 soap_snprintf(s + l, sizeof(soap->msgbuf) - l, " (%d%cs recv delay)", rt, ru);
16662 #else
16663 sprintf(s + strlen(s), " (%d%cs recv delay)", rt, ru);
16664 #endif
16665 }
16666 if (st)
16667 {
16668 #ifdef HAVE_SNPRINTF
16669 size_t l = strlen(s);
16670 soap_snprintf(s + l, sizeof(soap->msgbuf) - l, " (%d%cs send delay)", st, su);
16671 #else
16672 sprintf(s + strlen(s), " (%d%cs send delay)", st, su);
16673 #endif
16674 }
16675 #endif
16676 }
16677 return soap->msgbuf;
16678 }
16679 #endif
16680 #endif
16681
16682 /******************************************************************************/
16683 #ifndef PALM_2
16684 static int
16685 soap_set_error(struct soap *soap, const char *faultcode, const char *faultsubcodeQName, const char *faultstring, const char *faultdetailXML, int soaperror)
16686 { *soap_faultcode(soap) = faultcode;
16687 if (faultsubcodeQName)
16688 *soap_faultsubcode(soap) = faultsubcodeQName;
16689 *soap_faultstring(soap) = faultstring;
16690 if (faultdetailXML && *faultdetailXML)
16691 { register const char **s = soap_faultdetail(soap);
16692 if (s)
16693 *s = faultdetailXML;
16694 }
16695 return soap->error = soaperror;
16696 }
16697 #endif
16698
16699 /******************************************************************************/
16700 #ifndef PALM_2
16701 SOAP_FMAC1
16702 int
16703 SOAP_FMAC2
16704 soap_set_sender_error(struct soap *soap, const char *faultstring, const char *faultdetailXML, int soaperror)
16705 { return soap_set_error(soap, soap->version == 2 ? "SOAP-ENV:Sender" : "SOAP-ENV:Client", NULL, faultstring, faultdetailXML, soaperror);
16706 }
16707 #endif
16708
16709 /******************************************************************************/
16710 #ifndef PALM_2
16711 SOAP_FMAC1
16712 int
16713 SOAP_FMAC2
16714 soap_set_receiver_error(struct soap *soap, const char *faultstring, const char *faultdetailXML, int soaperror)
16715 { return soap_set_error(soap, soap->version == 2 ? "SOAP-ENV:Receiver" : "SOAP-ENV:Server", NULL, faultstring, faultdetailXML, soaperror);
16716 }
16717 #endif
16718
16719 /******************************************************************************/
16720 #ifndef PALM_2
16721 static int
16722 soap_copy_fault(struct soap *soap, const char *faultcode, const char *faultsubcodeQName, const char *faultstring, const char *faultdetailXML)
16723 { char *r = NULL, *s = NULL, *t = NULL;
16724 if (faultsubcodeQName)
16725 r = soap_strdup(soap, faultsubcodeQName);
16726 if (faultstring)
16727 s = soap_strdup(soap, faultstring);
16728 if (faultdetailXML)
16729 t = soap_strdup(soap, faultdetailXML);
16730 return soap_set_error(soap, faultcode, r, s, t, SOAP_FAULT);
16731 }
16732 #endif
16733
16734 /******************************************************************************/
16735 #ifndef PALM_2
16736 SOAP_FMAC1
16737 int
16738 SOAP_FMAC2
16739 soap_sender_fault(struct soap *soap, const char *faultstring, const char *faultdetailXML)
16740 { return soap_sender_fault_subcode(soap, NULL, faultstring, faultdetailXML);
16741 }
16742 #endif
16743
16744 /******************************************************************************/
16745 #ifndef PALM_2
16746 SOAP_FMAC1
16747 int
16748 SOAP_FMAC2
16749 soap_sender_fault_subcode(struct soap *soap, const char *faultsubcodeQName, const char *faultstring, const char *faultdetailXML)
16750 { return soap_copy_fault(soap, soap->version == 2 ? "SOAP-ENV:Sender" : "SOAP-ENV:Client", faultsubcodeQName, faultstring, faultdetailXML);
16751 }
16752 #endif
16753
16754 /******************************************************************************/
16755 #ifndef PALM_2
16756 SOAP_FMAC1
16757 int
16758 SOAP_FMAC2
16759 soap_receiver_fault(struct soap *soap, const char *faultstring, const char *faultdetailXML)
16760 { return soap_receiver_fault_subcode(soap, NULL, faultstring, faultdetailXML);
16761 }
16762 #endif
16763
16764 /******************************************************************************/
16765 #ifndef PALM_2
16766 SOAP_FMAC1
16767 int
16768 SOAP_FMAC2
16769 soap_receiver_fault_subcode(struct soap *soap, const char *faultsubcodeQName, const char *faultstring, const char *faultdetailXML)
16770 { return soap_copy_fault(soap, soap->version == 2 ? "SOAP-ENV:Receiver" : "SOAP-ENV:Server", faultsubcodeQName, faultstring, faultdetailXML);
16771 }
16772 #endif
16773
16774 /******************************************************************************/
16775 #ifndef PALM_2
16776 #ifndef WITH_NOSTDLIB
16777 SOAP_FMAC1
16778 void
16779 SOAP_FMAC2
16780 soap_print_fault(struct soap *soap, FILE *fd)
16781 { if (soap_check_state(soap))
16782 fprintf(fd, "Error: soap struct state not initialized\n");
16783 else if (soap->error)
16784 { const char **c, *v = NULL, *s, *d;
16785 c = soap_faultcode(soap);
16786 if (!*c)
16787 soap_set_fault(soap);
16788 if (soap->version == 2)
16789 v = soap_check_faultsubcode(soap);
16790 s = *soap_faultstring(soap);
16791 d = soap_check_faultdetail(soap);
16792 fprintf(fd, "%s%d fault: %s [%s]\n\"%s\"\nDetail: %s\n", soap->version ? "SOAP 1." : "Error ", soap->version ? (int)soap->version : soap->error, *c, v ? v : "no subcode", s ? s : "[no reason]", d ? d : "[no detail]");
16793 }
16794 }
16795 #endif
16796 #endif
16797
16798 /******************************************************************************/
16799 #ifdef __cplusplus
16800 #ifndef WITH_LEAN
16801 #ifndef WITH_NOSTDLIB
16802 #ifndef WITH_COMPAT
16803 SOAP_FMAC1
16804 void
16805 SOAP_FMAC2
16806 soap_stream_fault(struct soap *soap, std::ostream& os)
16807 { if (soap_check_state(soap))
16808 os << "Error: soap struct state not initialized\n";
16809 else if (soap->error)
16810 { const char **c, *v = NULL, *s, *d;
16811 c = soap_faultcode(soap);
16812 if (!*c)
16813 soap_set_fault(soap);
16814 if (soap->version == 2)
16815 v = soap_check_faultsubcode(soap);
16816 s = *soap_faultstring(soap);
16817 d = soap_check_faultdetail(soap);
16818 os << (soap->version ? "SOAP 1." : "Error ")
16819 << (soap->version ? (int)soap->version : soap->error)
16820 << " fault: " << *c
16821 << "[" << (v ? v : "no subcode") << "]"
16822 << std::endl
16823 << "\"" << (s ? s : "[no reason]") << "\""
16824 << std::endl
16825 << "Detail: " << (d ? d : "[no detail]")
16826 << std::endl;
16827 }
16828 }
16829 #endif
16830 #endif
16831 #endif
16832 #endif
16833
16834 /******************************************************************************/
16835 #ifndef WITH_LEAN
16836 #ifndef WITH_NOSTDLIB
16837 SOAP_FMAC1
16838 char*
16839 SOAP_FMAC2
16840 soap_sprint_fault(struct soap *soap, char *buf, size_t len)
16841 { if (soap_check_state(soap))
16842 { strncpy(buf, "Error: soap struct not initialized", len);
16843 buf[len - 1] = '\0';
16844 }
16845 else if (soap->error)
16846 { const char **c, *v = NULL, *s, *d;
16847 c = soap_faultcode(soap);
16848 if (!*c)
16849 soap_set_fault(soap);
16850 if (soap->version == 2)
16851 v = *soap_faultsubcode(soap);
16852 s = *soap_faultstring(soap);
16853 d = soap_check_faultdetail(soap);
16854 #ifdef HAVE_SNPRINTF
16855 soap_snprintf(buf, len, "%s%d fault: %s [%s]\n\"%s\"\nDetail: %s\n", soap->version ? "SOAP 1." : "Error ", soap->version ? (int)soap->version : soap->error, *c, v ? v : "no subcode", s ? s : "[no reason]", d ? d : "[no detail]");
16856 #else
16857 if (len > 40 + (v ? strlen(v) : 0) + (s ? strlen(s) : 0) + (d ? strlen(d) : 0))
16858 sprintf(buf, "%s%d fault: %s [%s]\n\"%s\"\nDetail: %s\n", soap->version ? "SOAP 1." : "Error ", soap->version ? (int)soap->version : soap->error, *c, v ? v : "no subcode", s ? s : "[no reason]", d ? d : "[no detail]");
16859 else if (len > 40)
16860 sprintf(buf, "%s%d fault: %s\n", soap->version ? "SOAP 1." : "Error ", soap->version ? (int)soap->version : soap->error, *c);
16861 else
16862 buf[0] = '\0';
16863 #endif
16864 }
16865 return buf;
16866 }
16867 #endif
16868 #endif
16869
16870 /******************************************************************************/
16871 #ifndef PALM_1
16872 #ifndef WITH_NOSTDLIB
16873 SOAP_FMAC1
16874 void
16875 SOAP_FMAC2
16876 soap_print_fault_location(struct soap *soap, FILE *fd)
16877 {
16878 #ifndef WITH_LEAN
16879 int i, j, c1, c2;
16880 if (soap->error && soap->error != SOAP_STOP && soap->bufidx <= soap->buflen && soap->buflen > 0 && soap->buflen <= SOAP_BUFLEN)
16881 { i = (int)soap->bufidx - 1;
16882 if (i <= 0)
16883 i = 0;
16884 c1 = soap->buf[i];
16885 soap->buf[i] = '\0';
16886 if ((int)soap->buflen >= i + 1024)
16887 j = i + 1023;
16888 else
16889 j = (int)soap->buflen - 1;
16890 c2 = soap->buf[j];
16891 soap->buf[j] = '\0';
16892 fprintf(fd, "%s%c\n<!-- ** HERE ** -->\n", soap->buf, c1);
16893 if (soap->bufidx < soap->buflen)
16894 fprintf(fd, "%s\n", soap->buf + soap->bufidx);
16895 soap->buf[i] = (char)c1;
16896 soap->buf[j] = (char)c2;
16897 }
16898 #endif
16899 }
16900 #endif
16901 #endif
16902
16903 /******************************************************************************/
16904 #ifndef PALM_1
16905 SOAP_FMAC1
16906 int
16907 SOAP_FMAC2
16908 soap_register_plugin_arg(struct soap *soap, int (*fcreate)(struct soap*, struct soap_plugin*, void*), void *arg)
16909 { register struct soap_plugin *p;
16910 register int r;
16911 if (!(p = (struct soap_plugin*)SOAP_MALLOC(soap, sizeof(struct soap_plugin))))
16912 return soap->error = SOAP_EOM;
16913 p->id = NULL;
16914 p->data = NULL;
16915 p->fcopy = NULL;
16916 p->fdelete = NULL;
16917 r = fcreate(soap, p, arg);
16918 if (!r && p->fdelete)
16919 { p->next = soap->plugins;
16920 soap->plugins = p;
16921 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Registered '%s' plugin\n", p->id));
16922 return SOAP_OK;
16923 }
16924 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not register plugin '%s': plugin returned error %d (or fdelete callback not set)\n", p->id ? p->id : "?", r));
16925 SOAP_FREE(soap, p);
16926 return r;
16927 }
16928 #endif
16929
16930 /******************************************************************************/
16931 #ifndef PALM_1
16932 static void *
16933 fplugin(struct soap *soap, const char *id)
16934 { register struct soap_plugin *p;
16935 for (p = soap->plugins; p; p = p->next)
16936 if (p->id == id || !strcmp(p->id, id))
16937 return p->data;
16938 return NULL;
16939 }
16940 #endif
16941
16942 /******************************************************************************/
16943 #ifndef PALM_2
16944 SOAP_FMAC1
16945 void *
16946 SOAP_FMAC2
16947 soap_lookup_plugin(struct soap *soap, const char *id)
16948 { return soap->fplugin(soap, id);
16949 }
16950 #endif
16951
16952 /******************************************************************************/
16953 #ifdef __cplusplus
16954 }
16955 #endif
16956
16957 /******************************************************************************\
16958 *
16959 * C++ soap struct methods
16960 *
16961 \******************************************************************************/
16962
16963 #ifdef __cplusplus
16964 soap::soap()
16965 { soap_init(this);
16966 }
16967 #endif
16968
16969 /******************************************************************************/
16970 #ifdef __cplusplus
16971 soap::soap(soap_mode m)
16972 { soap_init1(this, m);
16973 }
16974 #endif
16975
16976 /******************************************************************************/
16977 #ifdef __cplusplus
16978 soap::soap(soap_mode im, soap_mode om)
16979 { soap_init2(this, im, om);
16980 }
16981 #endif
16982
16983 /******************************************************************************/
16984 #ifdef __cplusplus
16985 soap::soap(const struct soap& soap)
16986 { soap_copy_context(this, &soap);
16987 }
16988 #endif
16989
16990 /******************************************************************************/
16991 #ifdef __cplusplus
16992 soap::~soap()
16993 { soap_destroy(this);
16994 soap_end(this);
16995 soap_done(this);
16996 }
16997 #endif
16998
16999 /******************************************************************************/